Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removed exportFileXML, and importXML, updated indra/test's

Browse Source 
and generally updated cpp's to V-D look(include order, spelling fixes, and whatnot)
Also, commented out pointless using namespace std.
This commit is contained in:
Lirusaito
2012-07-03 10:07:14 -04:00
parent b0c28c5eb2
commit ca9c99577f
19 changed files with 211 additions and 410 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
indra/llcharacter/llbvhloader.cpp
View File

@@ -44,7 +44,7 @@
#include "llapr.h"
using namespace std;
//using namespace std;
#define INCHES_TO_METERS 0.02540005f

108
indra/llinventory/llinventory.cpp
View File

@@ -45,9 +45,8 @@
#include "llsdutil.h"
///----------------------------------------------------------------------------
/// exported functions
/// Exported functions
///----------------------------------------------------------------------------
static const std::string INV_ITEM_ID_LABEL("item_id");
static const std::string INV_FOLDER_ID_LABEL("folder_id");
static const std::string INV_PARENT_ID_LABEL("parent_id");
@@ -1199,109 +1198,8 @@ fail:
}
LLXMLNode *LLInventoryItem::exportFileXML(BOOL include_asset_key) const
{
LLMemType m1(LLMemType::MTYPE_INVENTORY);
LLXMLNode *ret = new LLXMLNode("item", FALSE);
ret->createChild("uuid", TRUE)->setUUIDValue(1, &mUUID);
ret->createChild("parent_uuid", TRUE)->setUUIDValue(1, &mParentUUID);
mPermissions.exportFileXML()->setParent(ret);
// Check for permissions to see the asset id, and if so write it
// out as an asset id. Otherwise, apply our cheesy encryption.
if(include_asset_key)
{
U32 mask = mPermissions.getMaskBase();
if(((mask & PERM_ITEM_UNRESTRICTED) == PERM_ITEM_UNRESTRICTED)
|| (mAssetUUID.isNull()))
{
ret->createChild("asset_id", FALSE)->setUUIDValue(1, &mAssetUUID);
}
else
{
LLUUID shadow_id(mAssetUUID);
LLXORCipher cipher(MAGIC_ID.mData, UUID_BYTES);
cipher.encrypt(shadow_id.mData, UUID_BYTES);
ret->createChild("shadow_id", FALSE)->setUUIDValue(1, &shadow_id);
}
}
std::string type_str = LLAssetType::lookup(mType);
std::string inv_type_str = LLInventoryType::lookup(mInventoryType);
ret->createChild("asset_type", FALSE)->setStringValue(type_str);
ret->createChild("inventory_type", FALSE)->setStringValue(inv_type_str);
S32 tmp_flags = (S32) mFlags;
ret->createChild("flags", FALSE)->setByteValue(4, (U8*)(&tmp_flags), LLXMLNode::ENCODING_HEX);
mSaleInfo.exportFileXML()->setParent(ret);
std::string temp;
temp.assign(mName);
ret->createChild("name", FALSE)->setStringValue(temp);
temp.assign(mDescription);
ret->createChild("description", FALSE)->setStringValue(temp);
S32 date = mCreationDate;
ret->createChild("creation_date", FALSE)->setIntValue(1, &date);
return ret;
}
BOOL LLInventoryItem::importXML(LLXMLNode* node)
{
BOOL success = FALSE;
if (node)
{
success = TRUE;
LLXMLNodePtr sub_node;
if (node->getChild("uuid", sub_node))
success = (1 == sub_node->getUUIDValue(1, &mUUID));
if (node->getChild("parent_uuid", sub_node))
success = success && (1 == sub_node->getUUIDValue(1, &mParentUUID));
if (node->getChild("permissions", sub_node))
success = success && mPermissions.importXML(sub_node);
if (node->getChild("asset_id", sub_node))
success = success && (1 == sub_node->getUUIDValue(1, &mAssetUUID));
if (node->getChild("shadow_id", sub_node))
{
success = success && (1 == sub_node->getUUIDValue(1, &mAssetUUID));
LLXORCipher cipher(MAGIC_ID.mData, UUID_BYTES);
cipher.decrypt(mAssetUUID.mData, UUID_BYTES);
}
if (node->getChild("asset_type", sub_node))
mType = LLAssetType::lookup(sub_node->getValue());
if (node->getChild("inventory_type", sub_node))
mInventoryType = LLInventoryType::lookup(sub_node->getValue());
if (node->getChild("flags", sub_node))
{
S32 tmp_flags = 0;
success = success && (1 == sub_node->getIntValue(1, &tmp_flags));
mFlags = (U32) tmp_flags;
}
if (node->getChild("sale_info", sub_node))
success = success && mSaleInfo.importXML(sub_node);
if (node->getChild("name", sub_node))
mName = sub_node->getValue();
if (node->getChild("description", sub_node))
mDescription = sub_node->getValue();
if (node->getChild("creation_date", sub_node))
{
S32 date = 0;
success = success && (1 == sub_node->getIntValue(1, &date));
mCreationDate = date;
}
if (!success)
{
lldebugs << "LLInventory::importXML() failed for node named '"
<< node->getName() << "'" << llendl;
}
}
return success;
}
// Deleted LLInventoryItem::exportFileXML() and LLInventoryItem::importXML()
// because I can't find any non-test code references to it. 2009-05-04 JC
S32 LLInventoryItem::packBinaryBucket(U8* bin_bucket, LLPermissions* perm_override) const
{

5
indra/llinventory/llinventory.h
View File

@@ -214,15 +214,11 @@ public:
virtual BOOL importLegacyStream(std::istream& input_stream);
virtual BOOL exportLegacyStream(std::ostream& output_stream, BOOL include_asset_key = TRUE) const;
virtual LLXMLNode *exportFileXML(BOOL include_asset_key = TRUE) const;
BOOL importXML(LLXMLNode* node);
//--------------------------------------------------------------------
// Helper Functions
//--------------------------------------------------------------------
public:
// Pack all information needed to reconstruct this item into the given binary bucket.
S32 packBinaryBucket(U8* bin_bucket, LLPermissions* perm_override = NULL) const;
void unpackBinaryBucket(U8* bin_bucket, S32 bin_bucket_size);
LLSD asLLSD() const;
@@ -249,7 +245,6 @@ protected:
// items. Users come with a set of default categories, and can create
// new ones as needed.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
class LLInventoryCategory : public LLInventoryObject
{
public:

63
indra/llinventory/llpermissions.cpp
View File

@@ -853,67 +853,8 @@ BOOL LLPermissions::exportLegacyStream(std::ostream& output_stream) const
return TRUE;
}
LLXMLNode *LLPermissions::exportFileXML() const
{
LLXMLNode *ret = new LLXMLNode("permissions", FALSE);
ret->createChild("group_owned", TRUE)->setBoolValue(mIsGroupOwned);
ret->createChild("base_mask", FALSE)->setByteValue(4, (U8*)&mMaskBase, LLXMLNode::ENCODING_HEX);
ret->createChild("owner_mask", FALSE)->setByteValue(4, (U8*)&mMaskOwner, LLXMLNode::ENCODING_HEX);
ret->createChild("group_mask", FALSE)->setByteValue(4, (U8*)&mMaskGroup, LLXMLNode::ENCODING_HEX);
ret->createChild("everyone_mask", FALSE)->setByteValue(4, (U8*)&mMaskEveryone, LLXMLNode::ENCODING_HEX);
ret->createChild("next_owner_mask", FALSE)->setByteValue(4, (U8*)&mMaskNextOwner, LLXMLNode::ENCODING_HEX);
ret->createChild("creator_id", FALSE)->setUUIDValue(1, &mCreator);
ret->createChild("owner_id", FALSE)->setUUIDValue(1, &mOwner);
ret->createChild("last_owner_id", FALSE)->setUUIDValue(1, &mLastOwner);
ret->createChild("group_id", FALSE)->setUUIDValue(1, &mGroup);
return ret;
}
bool LLPermissions::importXML(LLXMLNode* node)
{
bool success = false;
if (node)
{
success = true;
LLXMLNodePtr sub_node;
if (node->getChild("base_mask", sub_node))
success = success && (4 == sub_node->getByteValue(4, (U8*)&mMaskBase));
if (node->getChild("owner_mask", sub_node))
success = success && (4 == sub_node->getByteValue(4, (U8*)&mMaskOwner));
if (node->getChild("group_mask", sub_node))
success = success && (4 == sub_node->getByteValue(4, (U8*)&mMaskGroup));
if (node->getChild("everyone_mask", sub_node))
success = success && (4 == sub_node->getByteValue(4, (U8*)&mMaskEveryone));
if (node->getChild("next_owner_mask", sub_node))
success = success && (4 == sub_node->getByteValue(4, (U8*)&mMaskNextOwner));
if (node->getChild("creator_id", sub_node))
success = success && (1 == sub_node->getUUIDValue(1, &mCreator));
if (node->getChild("owner_id", sub_node))
success = success && (1 == sub_node->getUUIDValue(1, &mOwner));
if (node->getChild("last_owner_id", sub_node))
success = success && (1 == sub_node->getUUIDValue(1, &mLastOwner));
if (node->getChild("group_id", sub_node))
success = success && (1 == sub_node->getUUIDValue(1, &mGroup));
if (node->getChild("group_owned", sub_node))
{
BOOL tmpbool = FALSE;
success = success && (1 == sub_node->getBoolValue(1, &tmpbool));
mIsGroupOwned = (bool)tmpbool;
}
if (!success)
{
lldebugs << "LLPermissions::importXML() failed for node named '"
<< node->getName() << "'" << llendl;
}
}
return success;
}
// Deleted LLPermissions::exportFileXML() and LLPermissions::importXML()
// because I can't find any non-test code references to it. 2009-05-04 JC
bool LLPermissions::operator==(const LLPermissions &rhs) const
{

6
indra/llinventory/llpermissions.h
View File

@@ -149,7 +149,7 @@ public:
const LLUUID& getGroup() const { return mGroup; }
// return the agent_id of the last agent owner. Only returns
// LLUUID::null if there has never been a previous owner.
// LLUUID::null if there has never been a previous owner (*note: this is apparently not true, say for textures in inventory, it may return LLUUID::null even if there was a previous owner).
const LLUUID& getLastOwner() const { return mLastOwner; }
U32 getMaskBase() const { return mMaskBase; }
@@ -235,6 +235,7 @@ public:
// Last owner doesn't have much in the way of permissions so it's
//not too dangerous to do this.
void setLastOwner(const LLUUID& last_owner);
// saves last owner, sets owner to uuid null, sets group
// owned. group_id must be the group of the object (that's who it
// is being deeded to) and the object must be group
@@ -324,9 +325,6 @@ public:
BOOL importLegacyStream(std::istream& input_stream);
BOOL exportLegacyStream(std::ostream& output_stream) const;
LLXMLNode *exportFileXML() const;
bool importXML(LLXMLNode* node);
bool operator==(const LLPermissions &rhs) const;
bool operator!=(const LLPermissions &rhs) const;

36
indra/llinventory/llsaleinfo.cpp
View File

@@ -30,8 +30,8 @@
* $/LicenseInfo$
*/
#include "linden_common.h"
#include <iostream>
#include "linden_common.h"
#include "llsaleinfo.h"
@@ -135,38 +135,8 @@ bool LLSaleInfo::fromLLSD(const LLSD& sd, BOOL& has_perm_mask, U32& perm_mask)
return true;
}
LLXMLNode *LLSaleInfo::exportFileXML() const
{
LLXMLNode *ret = new LLXMLNode("sale_info", FALSE);
std::string type_str = ll_safe_string( lookup(mSaleType));
ret->createChild("type", TRUE)->setStringValue(1, &type_str);
ret->createChild("price", TRUE)->setIntValue(1, &mSalePrice);
return ret;
}
BOOL LLSaleInfo::importXML(LLXMLNode* node)
{
BOOL success = FALSE;
if (node)
{
success = TRUE;
LLXMLNodePtr sub_node;
if (node->getChild("type", sub_node))
{
mSaleType = lookup(sub_node->getValue().c_str());
}
if (node->getChild("price", sub_node))
{
success &= (1 == sub_node->getIntValue(1, &mSalePrice));
}
if (!success)
{
lldebugs << "LLSaleInfo::importXML() failed for node named '"
<< node->getName() << "'" << llendl;
}
}
return success;
}
// Deleted LLSaleInfo::exportFileXML() and LLSaleInfo::importXML()
// because I can't find any non-test code references to it. 2009-05-04 JC
BOOL LLSaleInfo::importFile(LLFILE* fp, BOOL& has_perm_mask, U32& perm_mask)
{

3
indra/llinventory/llsaleinfo.h
View File

@@ -101,9 +101,6 @@ public:
bool fromLLSD(const LLSD& sd, BOOL& has_perm_mask, U32& perm_mask);
BOOL importLegacyStream(std::istream& input_stream, BOOL& has_perm_mask, U32& perm_mask);
LLXMLNode *exportFileXML() const;
BOOL importXML(LLXMLNode* node);
LLSD packMessage() const;
void unpackMessage(LLSD sales);

75
indra/newview/llconsole.cpp
View File

@@ -1,11 +1,11 @@
/**
/**
* @file llconsole.cpp
* @brief a scrolling console output device
*
* $LicenseInfo:firstyear=2001&license=viewergpl$
*
*
* Copyright (c) 2001-2009, Linden Research, Inc.
*
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
@@ -13,17 +13,17 @@
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
@@ -45,8 +45,6 @@
#include "llviewerwindow.h"
#include "lltextparser.h"
#include "llsd.h"
#include "llfontgl.h"
#include "llmath.h"
#include "llstartup.h"
@@ -72,7 +70,7 @@ LLConsole::LLConsole(const std::string& name, const LLRect &rect,
{
mTimer.reset();
setFontSize( font_size_index );
setFontSize( font_size_index );
}
LLConsole::~LLConsole()
@@ -97,10 +95,10 @@ void LLConsole::reshape(S32 width, S32 height, BOOL called_from_parent)
{
return;
}
mConsoleWidth = new_width;
mConsoleHeight= new_height;
LLView::reshape(new_width, new_height, called_from_parent);
for(paragraph_t::iterator paragraph_it = mParagraphs.begin(); paragraph_it != mParagraphs.end(); paragraph_it++)
@@ -127,7 +125,7 @@ void LLConsole::setFontSize(S32 size_index)
{
mFont = LLFontGL::getFontSansSerifHuge();
}
for(paragraph_t::iterator paragraph_it = mParagraphs.begin(); paragraph_it != mParagraphs.end(); paragraph_it++)
{
(*paragraph_it)->updateLines((F32)getRect().getWidth(), mFont, true);
@@ -156,7 +154,7 @@ void LLConsole::draw()
// skip lines added more than mLinePersistTime ago
F32 cur_time = mTimer.getElapsedTimeF32();
F32 skip_time = cur_time - mLinePersistTime;
F32 fade_time = cur_time - mFadeTime;
@@ -192,7 +190,7 @@ void LLConsole::draw()
{
return;
}
// draw remaining lines
F32 y_pos = 0.f;
@@ -207,7 +205,7 @@ void LLConsole::draw()
F32 line_height = mFont->getLineHeight();
S32 message_spacing = 0;
//080813 Spatters: This section makes a single huge black box behind all the text.
S32 bkg_height=8;
S32 bkg_width=0;
@@ -230,7 +228,7 @@ void LLConsole::draw()
{
S32 target_height = llfloor( (*paragraph_it)->mLines.size() * line_height + message_spacing);
S32 target_width = llfloor( (*paragraph_it)->mMaxWidth + CONSOLE_GUTTER_RIGHT);
bkg_height+= target_height;
if (target_width > bkg_width)
{
@@ -323,7 +321,7 @@ void LLConsole::addConsoleLine(const std::string& utf8line, const LLColor4 &colo
}
void LLConsole::addConsoleLine(const LLWString& wline, const LLColor4 &color)
{
{
Paragraph* paragraph = new Paragraph(wline, color, mTimer.getElapsedTimeF32());
LLMutexLock lock(&mQueueMutex);
mNewParagraphs.push_back ( paragraph );
@@ -335,24 +333,24 @@ void LLConsole::Paragraph::makeParagraphColorSegments (const LLColor4 &color)
LLTextParser* highlight = LLTextParser::getInstance();
LLSD paragraph_color_segments;
LLColor4 lcolor=color;
highlight->parseFullLineHighlights(wstring_to_utf8str(mParagraphText), &lcolor);
paragraph_color_segments = highlight->parsePartialLineHighlights(
wstring_to_utf8str(mParagraphText),
lcolor);
for(LLSD::array_const_iterator color_segment_it = paragraph_color_segments.beginArray();
color_segment_it != paragraph_color_segments.endArray();
++color_segment_it)
{
{
LLSD color_llsd = (*color_segment_it)["color"];
std::string color_str = (*color_segment_it)["text"].asString();
ParagraphColorSegment color_segment;
color_segment.mColor.setValue(color_llsd);
color_segment.mNumChars = color_str.length();
mParagraphColorSegments.push_back(color_segment);
}
}
@@ -368,22 +366,22 @@ void LLConsole::Paragraph::updateLines(F32 screen_width, LLFontGL* font, bool fo
return; //No resize required.
}
}
screen_width = screen_width - 30; //Margin for small windows.
if ( mParagraphText.empty()
|| mParagraphColorSegments.empty()
|| font == NULL)
{
return; //Not enough info to complete.
}
mLines.clear(); //Chuck everything.
mMaxWidth = 0.0f;
paragraph_color_segments_t::iterator current_color = mParagraphColorSegments.begin();
U32 current_color_length = (*current_color).mNumChars;
U32 current_color_length = (*current_color).mNumChars;
S32 paragraph_offset = 0; //Offset into the paragraph text.
// Wrap lines that are longer than the view is wide.
@@ -406,13 +404,13 @@ void LLConsole::Paragraph::updateLines(F32 screen_width, LLFontGL* font, bool fo
if (drawable != 0 || found_newline)
{
F32 x_position = 0; //Screen X position of text.
mMaxWidth = llmax( mMaxWidth, (F32)font->getWidth( mParagraphText.substr( paragraph_offset, drawable ).c_str() ) );
line_color_segments_t line;
U32 left_to_draw = drawable;
U32 drawn = 0;
while (left_to_draw >= current_color_length
&& current_color != mParagraphColorSegments.end() )
{
@@ -420,12 +418,12 @@ void LLConsole::Paragraph::updateLines(F32 screen_width, LLFontGL* font, bool fo
line.push_back( LineColorSegment( color_text, //Append segment to line.
(*current_color).mColor,
x_position ) );
x_position += font->getWidth( color_text.c_str() ); //Set up next screen position.
drawn += current_color_length;
left_to_draw -= current_color_length;
current_color++; //Goto next paragraph color record.
if (current_color != mParagraphColorSegments.end())
@@ -433,15 +431,15 @@ void LLConsole::Paragraph::updateLines(F32 screen_width, LLFontGL* font, bool fo
current_color_length = (*current_color).mNumChars;
}
}
if (left_to_draw > 0 && current_color != mParagraphColorSegments.end() )
{
LLWString color_text = mParagraphText.substr( paragraph_offset + drawn, left_to_draw );
line.push_back( LineColorSegment( color_text, //Append segment to line.
(*current_color).mColor,
x_position ) );
current_color_length -= left_to_draw;
}
mLines.push_back(line); //Append line to paragraph line list.
@@ -460,7 +458,7 @@ LLConsole::Paragraph::Paragraph (LLWString str, const LLColor4 &color, F32 add_t
: mParagraphText(str), mAddTime(add_time), mMaxWidth(-1)
{
// Only call makeParagraphColorSegments if the user logged in already (we come
// here before he logged in when they disabled login/logout screens).
// here before they logged in when they disabled login/logout screens).
// Otherwise makeParagraphColorSegments calls LLTextParser::getInstance() which
// causes a one-time initialization by reading highlights.xml, which fails
// when not logged in because it's per account.
@@ -469,4 +467,3 @@ LLConsole::Paragraph::Paragraph (LLWString str, const LLColor4 &color, F32 add_t
makeParagraphColorSegments(color);
}
}

10
indra/newview/lltoolplacer.cpp
View File

@@ -35,9 +35,6 @@
// self header
#include "lltoolplacer.h"
// linden library headers
#include "llprimitive.h"
// viewer headers
#include "llbutton.h"
#include "llviewercontrol.h"
@@ -50,12 +47,10 @@
#include "llviewerobject.h"
#include "llviewerregion.h"
#include "llviewerwindow.h"
#include "llwindow.h"
#include "llworld.h"
#include "llui.h"
//Headers added for functions moved from viewer.cpp
#include "llvoavatarself.h"
#include "llvograss.h"
#include "llvotree.h"
#include "llvolumemessage.h"
@@ -67,6 +62,11 @@
#include "llviewerobjectlist.h"
#include "llviewercamera.h"
#include "llviewerstats.h"
#include "llvoavatarself.h"
// linden library headers
#include "llprimitive.h"
#include "llwindow.h"
// <edit>
#include "llparcel.h" // always rez

22
indra/newview/llvovolume.cpp
View File

@@ -39,6 +39,7 @@
#include "llviewercontrol.h"
#include "lldir.h"
#include "llflexibleobject.h"
#include "llfloatertools.h"
#include "llmaterialtable.h"
#include "llprimitive.h"
#include "llvolume.h"
@@ -50,6 +51,7 @@
#include "object_flags.h"
#include "llagentconstants.h"
#include "lldrawable.h"
#include "lldrawpoolavatar.h"
#include "lldrawpoolbump.h"
#include "llface.h"
#include "llspatialpartition.h"
@@ -68,13 +70,11 @@
#include "pipeline.h"
#include "llsdutil.h"
#include "llmatrix4a.h"
#include "llagent.h"
#include "lldrawpoolavatar.h"
#include "llmeshrepository.h"
#include "llagent.h"
#include "lldatapacker.h"
#include "llviewershadermgr.h"
#include "llvoavatar.h"
#include "llfloatertools.h"
#include "llvocache.h"
// [RLVa:KB] - Checked: 2010-04-04 (RLVa-1.2.0d)
@@ -131,7 +131,7 @@ void LLVOVolume::markDead()
{
if (!mDead)
{
if (mSculptTexture.notNull())
{
mSculptTexture->removeVolume(this);
@@ -310,7 +310,7 @@ U32 LLVOVolume::processUpdateMessage(LLMessageSystem *mesgsys,
}
}
}
return retval;
}
@@ -673,6 +673,7 @@ void LLVOVolume::updateTextureVirtualSize(bool forced)
mSculptTexture->getHeight(), mSculptTexture->getWidth()));
}
}
}
if (getLightTextureID().notNull())
@@ -853,7 +854,7 @@ BOOL LLVOVolume::setVolume(const LLVolumeParams &params_in, const S32 detail, bo
{
mVolumeImpl->onSetVolume(volume_params, mLOD); //detail ?
}
updateSculptTexture();
if (isSculpted())
@@ -988,6 +989,7 @@ void LLVOVolume::sculpt()
if(!raw_image)
{
llassert(discard_level < 0) ;
sculpt_width = 0;
sculpt_height = 0;
sculpt_data = NULL ;
@@ -1056,7 +1058,7 @@ BOOL LLVOVolume::calcLOD()
distance *= sDistanceFactor;
F32 rampDist = LLVOVolume::sLODFactor * 2;
if (distance < rampDist)
@@ -1229,7 +1231,7 @@ BOOL LLVOVolume::genBBoxes(BOOL force_global)
BOOL rebuild = mDrawable->isState(LLDrawable::REBUILD_VOLUME | LLDrawable::REBUILD_POSITION | LLDrawable::REBUILD_RIGGED);
// bool rigged = false;
// bool rigged = false;
LLVolume* volume = mRiggedVolume;
if (!volume)
{
@@ -2089,7 +2091,7 @@ BOOL LLVOVolume::isSculpted() const
}
BOOL LLVOVolume::isMesh() const
{
{
if (isSculpted())
{
LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
@@ -2388,7 +2390,7 @@ U32 LLVOVolume::getRenderCost(texture_cost_t &textures) const
produces_light = 1;
}
for (U32 i = 0; i < num_faces; ++i)
for (S32 i = 0; i < num_faces; ++i)
{
const LLFace* face = drawablep->getFace(i);
if (!face) continue;

2
indra/test/io.cpp
View File

@@ -915,7 +915,7 @@ namespace tut
pipe_and_pump_fitness()
{
LLFrameTimer::updateFrameTime();
LLFrameTimer::updateFrameTime();
apr_pool_create(&mPool, NULL);
mPump = new LLPumpIO(mPool);
mSocket = LLSocket::create(

16
indra/test/llapp_tut.cpp
View File

@@ -86,7 +86,7 @@ namespace tut
void application_object_t::test<2>()
{
const int ARGC = 13;
char* ARGV[ARGC] =
const char* ARGV[ARGC] =
{
"", // argv[0] is usually the application name
"-crashcount",
@@ -97,12 +97,12 @@ namespace tut
"localhost",
"--allowlslhttprequests",
"-asset-uri",
"http://asset.grid.lindenlab.com/assets",
"http://test.lindenlab.com/assets",
"-data",
"127.0.0.1",
"--smtp"
};
bool ok = mApp->parseCommandOptions(ARGC, ARGV);
bool ok = mApp->parseCommandOptions(ARGC, const_cast<char**>(ARGV));
ensure("command line parsed", ok);
ensure_equals(
"crashcount", mApp->getOption("crashcount").asInteger(), 2);
@@ -118,7 +118,7 @@ namespace tut
ensure_equals(
"asset-uri",
mApp->getOption("asset-uri").asString(),
std::string("http://asset.grid.lindenlab.com/assets"));
std::string("http://test.lindenlab.com/assets"));
ensure_equals(
"data",
mApp->getOption("data").asString(),
@@ -130,14 +130,14 @@ namespace tut
void application_object_t::test<3>()
{
const int ARGC = 4;
char* ARGV[ARGC] =
const char* ARGV[ARGC] =
{
"", // argv[0] is usually the application name
"crashcount",
"2",
"--space"
};
bool ok = mApp->parseCommandOptions(ARGC, ARGV);
bool ok = mApp->parseCommandOptions(ARGC, const_cast<char**>(ARGV));
ensure("command line parse failure", !ok);
}
@@ -145,14 +145,14 @@ namespace tut
void application_object_t::test<4>()
{
const int ARGC = 4;
char* ARGV[ARGC] =
const char* ARGV[ARGC] =
{
"", // argv[0] is usually the application name
"--crashcount",
"2",
"space"
};
bool ok = mApp->parseCommandOptions(ARGC, ARGV);
bool ok = mApp->parseCommandOptions(ARGC, const_cast<char**>(ARGV));
ensure("command line parse failure", !ok);
}

91
indra/test/llpermissions_tut.cpp
View File

@@ -61,7 +61,7 @@ namespace tut
uuid2 == LLUUID::null && uuid3 == LLUUID::null));
ensure("LLPermission Get Functions failed", (permissions.getMaskBase() == PERM_ALL && permissions.getMaskOwner() == PERM_ALL &&
permissions.getMaskGroup() == PERM_ALL && permissions.getMaskEveryone() == PERM_ALL && permissions.getMaskNextOwner() == PERM_ALL));
ensure("Ownership functions failed", (permissions.isGroupOwned() == FALSE && permissions.isOwned() == FALSE));
ensure("Ownership functions failed", ((! permissions.isGroupOwned()) && (! permissions.isOwned())));
}
template<> template<>
@@ -204,7 +204,7 @@ namespace tut
LLPermissions perm1;
LLUUID uuid;
BOOL is_group_owned = FALSE;
ensure("1:getOwnership:failed ", (FALSE == perm1.getOwnership(uuid,is_group_owned)));
ensure("1:getOwnership:failed ", ! perm1.getOwnership(uuid,is_group_owned));
LLPermissions perm;
LLUUID creator("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");
@@ -213,11 +213,11 @@ namespace tut
LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");
perm.init(creator,owner,lastOwner,group);
perm.getOwnership(uuid,is_group_owned);
ensure("2:getOwnership:failed ", ((uuid == owner) && (FALSE == is_group_owned)));
ensure("2:getOwnership:failed ", ((uuid == owner) && (! is_group_owned)));
perm.init(creator,LLUUID::null,lastOwner,group);
perm.getOwnership(uuid,is_group_owned);
ensure("3:getOwnership:failed ", ((uuid == group) && (TRUE == is_group_owned)));
ensure("3:getOwnership:failed ", ((uuid == group) && is_group_owned));
}
template<> template<>
@@ -240,17 +240,17 @@ namespace tut
LLUUID agent("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");
LLUUID owner("68edcf47-ccd7-45b8-9f90-1649d7f12806");
LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");
bool is_atomic = TRUE;
ensure("setOwnerAndGroup():failed ", (TRUE == perm.setOwnerAndGroup(agent,owner,group,is_atomic)));
bool is_atomic = true;
ensure("setOwnerAndGroup():failed ", perm.setOwnerAndGroup(agent,owner,group,is_atomic));
LLUUID owner2("68edcf47-ccd7-45b8-9f90-1649d7f12807");
LLUUID group2("9c8eca51-53d5-42a7-bb58-cef070395db9");
// cant change - agent need to be current owner
ensure("setOwnerAndGroup():failed ", (FALSE == perm.setOwnerAndGroup(agent,owner2,group2,is_atomic)));
ensure("setOwnerAndGroup():failed ", ! perm.setOwnerAndGroup(agent,owner2,group2,is_atomic));
// should be able to change - agent and owner same as current owner
ensure("setOwnerAndGroup():failed ", (TRUE == perm.setOwnerAndGroup(owner,owner,group2,is_atomic)));
ensure("setOwnerAndGroup():failed ", perm.setOwnerAndGroup(owner,owner,group2,is_atomic));
}
template<> template<>
@@ -259,7 +259,7 @@ namespace tut
LLPermissions perm;
LLUUID agent;
LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");
ensure("deedToGroup():failed ", (TRUE == perm.deedToGroup(agent,group)));
ensure("deedToGroup():failed ", perm.deedToGroup(agent,group));
}
template<> template<>
void permission_object_t::test<11>()
@@ -268,12 +268,12 @@ namespace tut
LLUUID agent;
BOOL set = 1;
U32 bits = PERM_TRANSFER | PERM_MODIFY;
ensure("setBaseBits():failed ", (TRUE == perm.setBaseBits(agent, set, bits)));
ensure("setOwnerBits():failed ", (TRUE == perm.setOwnerBits(agent, set, bits)));
ensure("setBaseBits():failed ", perm.setBaseBits(agent, set, bits));
ensure("setOwnerBits():failed ", perm.setOwnerBits(agent, set, bits));
LLUUID agent1("9c8eca51-53d5-42a7-bb58-cef070395db8");
ensure("setBaseBits():failed ", (FALSE == perm.setBaseBits(agent1, set, bits)));
ensure("setOwnerBits():failed ", (FALSE == perm.setOwnerBits(agent1, set, bits)));
ensure("setBaseBits():failed ", ! perm.setBaseBits(agent1, set, bits));
ensure("setOwnerBits():failed ", ! perm.setOwnerBits(agent1, set, bits));
}
template<> template<>
@@ -284,14 +284,14 @@ namespace tut
LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");
BOOL set = 1;
U32 bits = 10;
ensure("setGroupBits():failed ", (TRUE == perm.setGroupBits(agent,group, set, bits)));
ensure("setEveryoneBits():failed ", (TRUE == perm.setEveryoneBits(agent,group, set, bits)));
ensure("setNextOwnerBits():failed ", (TRUE == perm.setNextOwnerBits(agent,group, set, bits)));
ensure("setGroupBits():failed ", perm.setGroupBits(agent,group, set, bits));
ensure("setEveryoneBits():failed ", perm.setEveryoneBits(agent,group, set, bits));
ensure("setNextOwnerBits():failed ", perm.setNextOwnerBits(agent,group, set, bits));
LLUUID agent1("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");
ensure("setGroupBits():failed ", (FALSE == perm.setGroupBits(agent1,group, set, bits)));
ensure("setEveryoneBits():failed ", (FALSE == perm.setEveryoneBits(agent1,group, set, bits)));
ensure("setNextOwnerBits():failed ", (FALSE == perm.setNextOwnerBits(agent1,group, set, bits)));
LLUUID agent1("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");
ensure("setGroupBits():failed ", ! perm.setGroupBits(agent1,group, set, bits));
ensure("setEveryoneBits():failed ", ! perm.setEveryoneBits(agent1,group, set, bits));
ensure("setNextOwnerBits():failed ", ! perm.setNextOwnerBits(agent1,group, set, bits));
}
template<> template<>
@@ -301,14 +301,14 @@ namespace tut
LLUUID agent;
LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");
U32 bits = 10;
ensure("allowOperationBy():failed ", (TRUE == perm.allowOperationBy(bits,agent,group)));
ensure("allowOperationBy():failed ", perm.allowOperationBy(bits,agent,group));
LLUUID agent1("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");
LLUUID creator("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");
LLUUID owner("68edcf47-ccd7-45b8-9f90-1649d7f12806");
LLUUID lastOwner("5e47a0dc-97bf-44e0-8b40-de06718cee9d");
perm.init(creator,owner,lastOwner,group);
ensure("allowOperationBy():failed ", (TRUE == perm.allowOperationBy(bits,agent1,group)));
ensure("allowOperationBy():failed ", perm.allowOperationBy(bits,agent1,group));
}
template<> template<>
@@ -321,8 +321,8 @@ namespace tut
LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");
perm.init(creator,owner,lastOwner,group);
LLUUID agent;
ensure("1:allowModifyBy():failed ", (TRUE == perm.allowModifyBy(agent)));
ensure("2:allowModifyBy():failed ", (TRUE == perm.allowModifyBy(agent,group)));
ensure("1:allowModifyBy():failed ", perm.allowModifyBy(agent));
ensure("2:allowModifyBy():failed ", perm.allowModifyBy(agent,group));
U32 val1 = 0x7FFFFFFF;
S32 sVal = 1 << 14;
@@ -342,8 +342,8 @@ namespace tut
LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");
perm.init(creator,owner,lastOwner,group);
LLUUID agent;
ensure("1:allowCopyBy():failed ", (TRUE == perm.allowModifyBy(agent)));
ensure("2:allowCopyBy():failed ", (TRUE == perm.allowModifyBy(agent,group)));
ensure("1:allowCopyBy():failed ", perm.allowModifyBy(agent));
ensure("2:allowCopyBy():failed ", perm.allowModifyBy(agent,group));
U32 val1 = 0x7FFFFFFF;
S32 sVal = 1 << 15;
@@ -363,8 +363,8 @@ namespace tut
LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");
perm.init(creator,owner,lastOwner,group);
LLUUID agent;
ensure("1:allowMoveBy():failed ", (TRUE == perm.allowMoveBy(agent)));
ensure("2:allowMoveBy():failed ", (TRUE == perm.allowMoveBy(agent,group)));
ensure("1:allowMoveBy():failed ", perm.allowMoveBy(agent));
ensure("2:allowMoveBy():failed ", perm.allowMoveBy(agent,group));
U32 val1 = 0x7FFFFFFF;
S32 sVal = 1 << 19;
@@ -383,7 +383,7 @@ namespace tut
LLUUID lastOwner("5e47a0dc-97bf-44e0-8b40-de06718cee9d");
LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");
LLUUID agent;
ensure("1:allowMoveBy():failed ", (TRUE == perm.allowTransferTo(agent)));
ensure("1:allowMoveBy():failed ", perm.allowTransferTo(agent));
perm.init(creator,owner,lastOwner,group);
U32 val1 = 0x7FFFFFFF;
@@ -396,7 +396,7 @@ namespace tut
void permission_object_t::test<18>()
{
LLPermissions perm,perm1;
ensure("1:Operator==:failed ", perm == perm1);
ensure_equals("1:Operator==:failed ", perm, perm1);
LLUUID creator("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");
LLUUID owner("68edcf47-ccd7-45b8-9f90-1649d7f12806");
@@ -404,7 +404,7 @@ namespace tut
LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");
perm.init(creator,owner,lastOwner,group);
perm = perm1;
ensure("2:Operator==:failed ", perm == perm1);
ensure_equals("2:Operator==:failed ", perm, perm1);
}
template<> template<>
@@ -416,7 +416,7 @@ namespace tut
LLUUID lastOwner("5e47a0dc-97bf-44e0-8b40-de06718cee9d");
LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");
perm.init(creator,owner,lastOwner,group);
ensure("2:Operator==:failed ", perm != perm1);
ensure_not_equals("2:Operator==:failed ", perm, perm1);
}
template<> template<>
@@ -453,7 +453,7 @@ namespace tut
}
perm1.importFile(fp);
fclose(fp);
ensure("exportFile()/importFile():failed to export and import the data ", perm1 == perm);
ensure_equals("exportFile()/importFile():failed to export and import the data ", perm1, perm);
}
template<> template<>
@@ -479,21 +479,14 @@ namespace tut
std::istringstream istream(ostream.str());
perm1.importLegacyStream(istream);
ensure("exportLegacyStream()/importLegacyStream():failed to export and import the data ", perm1 == perm);
ensure_equals("exportLegacyStream()/importLegacyStream():failed to export and import the data ", perm1, perm);
}
template<> template<>
void permission_object_t::test<22>()
{
LLPermissions perm,perm1;
LLUUID creator("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");
LLUUID owner("68edcf47-ccd7-45b8-9f90-1649d7f12806");
LLUUID lastOwner("5e47a0dc-97bf-44e0-8b40-de06718cee9d");
LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");
perm.init(creator,owner,lastOwner,group);
LLXMLNode* xml_node = perm.exportFileXML();
perm1.importXML(xml_node);
ensure("exportFileXML()/importXML():failed to export and import the data ", perm1 == perm);
// Deleted LLPermissions::exportFileXML() and LLPermissions::importXML()
// because I can't find any non-test code references to it. 2009-05-04 JC
}
template<> template<>
@@ -509,7 +502,7 @@ namespace tut
stream1 << perm;
perm1.init(creator,owner,lastOwner,group);
stream2 << perm1;
ensure("1:operator << failed",(stream1.str() == stream2.str()));
ensure_equals("1:operator << failed", stream1.str(), stream2.str());
}
template<> template<>
@@ -540,19 +533,19 @@ namespace tut
{
LLAggregatePermissions AggrPermission;
LLAggregatePermissions AggrPermission1;
ensure("getU8() function failed", (AggrPermission.getU8() == 0));
ensure("isEmpty() function failed", (AggrPermission.isEmpty() == TRUE));
ensure_equals("getU8() function failed", AggrPermission.getU8(), 0);
ensure("isEmpty() function failed", AggrPermission.isEmpty());
AggrPermission.getValue(PERM_TRANSFER);
ensure_equals("getValue() function failed", AggrPermission.getValue(PERM_TRANSFER), 0x00);
AggrPermission.aggregate(PERM_ITEM_UNRESTRICTED);
ensure("aggregate() function failed", (AggrPermission.isEmpty() == FALSE));
ensure("aggregate() function failed", ! AggrPermission.isEmpty());
AggrPermission1.aggregate(AggrPermission);
ensure("aggregate() function failed", (AggrPermission1.isEmpty() == FALSE));
ensure("aggregate() function failed", ! AggrPermission1.isEmpty());
std::ostringstream stream1;
stream1 << AggrPermission;
ensure("operator<< failed", (stream1.str() == "{PI_COPY=All, PI_MODIFY=All, PI_TRANSFER=All}"));
ensure_equals("operator<< failed", stream1.str(), "{PI_COPY=All, PI_MODIFY=All, PI_TRANSFER=All}");
}
}

15
indra/test/llsaleinfo_tut.cpp
View File

@@ -167,19 +167,8 @@ namespace tut
template<> template<>
void llsaleinfo_test_t::test<4>()
{
// LLXMLNode is teh suck.
#if 0
S32 sale_price = 23445;
LLSaleInfo saleinfo(LLSaleInfo::FS_CONTENTS, sale_price);
LLXMLNode* x_node = saleinfo.exportFileXML();
LLSaleInfo saleinfo1(LLSaleInfo::FS_NOT, 0);
saleinfo1.importXML(x_node);
ensure_equals("1.importXML() fn failed", saleinfo.getSalePrice(), saleinfo1.getSalePrice());
ensure_equals("2.importXML() fn failed", saleinfo.getSaleType(), saleinfo1.getSaleType());
#endif
// Deleted LLSaleInfo::exportFileXML() and LLSaleInfo::importXML()
// because I can't find any non-test code references to it. 2009-05-04 JC
}
template<> template<>

33
indra/test/llsd_new_tut.cpp
View File

@@ -38,6 +38,19 @@
#include "llsdtraits.h"
#include "llstring.h"
#if LL_WINDOWS
#include <float.h>
namespace
{
int fpclassify(double x)
{
return _fpclass(x);
}
}
#else
using std::fpclassify;
#endif
namespace tut
{
class SDCleanupCheck
@@ -224,19 +237,16 @@ namespace tut
}
else
{
// TODO: Fix on windows....
#ifndef LL_WINDOWS
# if !defined(fpclassify) && __GNUC__ >= 3
# define FPCLASSIFY_NAMESPACE std::
# else
# define FPCLASSIFY_NAMESPACE
# endif
int left = FPCLASSIFY_NAMESPACE fpclassify(v.asReal());
int right = FPCLASSIFY_NAMESPACE fpclassify(eReal);
int left = fpclassify(v.asReal());
int right = fpclassify(eReal);
ensure_equals(s+" to real", left, right);
ensure_equals(s+" to string", v.asString(), eString);
#endif
// ensure_equals(s+" to string", v.asString(), eString);
// I've commented this check out, since there doesn't
// seem to be uniform string representation for NaN on
// all platforms. For example, on my Ubuntu 8.10 laptop
// with libc 2.11.1, sqrt(-1.0) will return '-nan', not
// 'nan'.
}
}
@@ -775,4 +785,3 @@ namespace tut
test serializations
*/
}

56
indra/test/llsdmessagebuilder_tut.cpp
View File

@@ -90,17 +90,17 @@ namespace tut
return createTemplateBlock(_PREHASH_Test0, type, size, block);
}
static LLMessageBlock* createTemplateBlock(char* name, const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
static LLMessageBlock* createTemplateBlock(const char* name, const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
{
LLMessageBlock* result = new LLMessageBlock(name, block);
if(type != MVT_NULL)
{
result->addVariable(_PREHASH_Test0, type, size);
result->addVariable(const_cast<char*>(_PREHASH_Test0), type, size);
}
return result;
}
static LLTemplateMessageBuilder* defaultTemplateBuilder(LLMessageTemplate& messageTemplate, char* name = _PREHASH_Test0)
static LLTemplateMessageBuilder* defaultTemplateBuilder(LLMessageTemplate& messageTemplate, char* name = const_cast<char*>(_PREHASH_Test0))
{
templateNameMap[_PREHASH_TestMessage] = &messageTemplate;
LLTemplateMessageBuilder* builder = new LLTemplateMessageBuilder(templateNameMap);
@@ -353,7 +353,7 @@ namespace tut
{
char binData[] = "abcdefghijklmnop";
addValue(messageBlockData, "testBinData", &binData, MVT_FIXED, sizeof(binData));
addValue(messageBlockData, (char *)"testBinData", &binData, MVT_FIXED, sizeof(binData));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -393,7 +393,7 @@ namespace tut
{
U16 binData[] = {1,2,3,4,5,6,7,8,9}; //9 shorts
addValue(messageBlockData, "testBinData", &binData, MVT_VARIABLE, sizeof(binData) >> 1, 2);
addValue(messageBlockData, (char *)"testBinData", &binData, MVT_VARIABLE, sizeof(binData) >> 1, 2);
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -413,7 +413,7 @@ namespace tut
{
U32 binData[] = {9,8,7,6,5,4,3,2,1};
addValue(messageBlockData, "testBinData", &binData, MVT_VARIABLE, sizeof(binData) >> 2, 4);
addValue(messageBlockData, (char *)"testBinData", &binData, MVT_VARIABLE, sizeof(binData) >> 2, 4);
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -433,7 +433,7 @@ namespace tut
{
U8 data = 0xa5;
addValue(messageBlockData, "testBinData", &data, MVT_U8, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_U8, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -450,7 +450,7 @@ namespace tut
{
U16 data = 0xa55a;
addValue(messageBlockData, "testBinData", &data, MVT_U16, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_U16, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -467,7 +467,7 @@ namespace tut
{
U32 data = 0xa55a7117;
addValue(messageBlockData, "testBinData", &data, MVT_U32, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_U32, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -483,7 +483,7 @@ namespace tut
void LLSDMessageBuilderTestObject::test<27>()
{
U64 data = U64L(0xa55a711711223344);
addValue(messageBlockData, "testBinData", &data, MVT_U64, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_U64, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -500,7 +500,7 @@ namespace tut
{
S8 data = -31;
addValue(messageBlockData, "testBinData", &data, MVT_S8, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_S8, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -517,7 +517,7 @@ namespace tut
{
S16 data = -31;
addValue(messageBlockData, "testBinData", &data, MVT_S16, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_S16, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -534,7 +534,7 @@ namespace tut
{
S32 data = -3100;
addValue(messageBlockData, "testBinData", &data, MVT_S32, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_S32, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -551,7 +551,7 @@ namespace tut
{
S64 data = -31003100;
addValue(messageBlockData, "testBinData", &data, MVT_S64, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_S64, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -568,7 +568,7 @@ namespace tut
{
F32 data = 1234.1234f;
addValue(messageBlockData, "testBinData", &data, MVT_F32, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_F32, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -585,7 +585,7 @@ namespace tut
{
F64 data = 1234.1234;
addValue(messageBlockData, "testBinData", &data, MVT_F64, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_F64, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -602,7 +602,7 @@ namespace tut
{
LLVector3 data(1,2,3);
addValue(messageBlockData, "testBinData", &data, MVT_LLVector3, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLVector3, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -619,7 +619,7 @@ namespace tut
{
LLVector3d data(1,2,3);
addValue(messageBlockData, "testBinData", &data, MVT_LLVector3d, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLVector3d, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -637,7 +637,7 @@ namespace tut
LLVector4 data(1,2,3,4);
LLSD v = ll_sd_from_vector4(data);
addValue(messageBlockData, "testBinData", &data, MVT_LLVector4, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLVector4, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -657,7 +657,7 @@ namespace tut
//we send a quaternion packed into a vec3 (w is infered) - so sizeof(vec) == 12 bytes not 16.
LLVector3 vec = data.packToVector3();
addValue(messageBlockData, "testBinData", &vec, MVT_LLQuaternion, sizeof(vec));
addValue(messageBlockData, (char *)"testBinData", &vec, MVT_LLQuaternion, sizeof(vec));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -674,7 +674,7 @@ namespace tut
{
LLUUID data("01234567-0123-0123-0123-234567abcdef");
addValue(messageBlockData, "testBinData", &data, MVT_LLUUID, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLUUID, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -696,8 +696,8 @@ namespace tut
LLMsgData* md = new LLMsgData("testMessage");
LLMsgBlkData* mbd = new LLMsgBlkData("testBlock", 0);
addValue(mbd, "testBoolFalse", &valueFalse, MVT_BOOL, sizeof(BOOL));
addValue(mbd, "testBoolTrue", &valueTrue, MVT_BOOL, sizeof(BOOL));
addValue(mbd, (char *)"testBoolFalse", &valueFalse, MVT_BOOL, sizeof(BOOL));
addValue(mbd, (char *)"testBoolTrue", &valueTrue, MVT_BOOL, sizeof(BOOL));
md->addBlock(mbd);
LLSDMessageBuilder builder = defaultBuilder();
@@ -715,7 +715,7 @@ namespace tut
U32 data(0xff887766);
LLSD v = ll_sd_from_ipaddr(data);
addValue(messageBlockData, "testBinData", &data, MVT_IP_ADDR, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_IP_ADDR, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -732,7 +732,7 @@ namespace tut
{
U16 data = 0xff88;
addValue(messageBlockData, "testBinData", &data, MVT_IP_PORT, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_IP_PORT, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -749,7 +749,7 @@ namespace tut
{
U16 data[3] = {0,1,2};
addValue(messageBlockData, "testBinData", &data, MVT_U16Vec3, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_U16Vec3, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -769,7 +769,7 @@ namespace tut
{
U16 data[4] = {0,1,2,4};
addValue(messageBlockData, "testBinData", &data, MVT_U16Quat, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_U16Quat, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();
@@ -789,7 +789,7 @@ namespace tut
{
S16 data[19] = {0,-1,2,-4,5,-6,7,-8,9,-10,11,-12,13,-14,15,16,17,18};
addValue(messageBlockData, "testBinData", &data, MVT_S16Array, sizeof(data));
addValue(messageBlockData, (char *)"testBinData", &data, MVT_S16Array, sizeof(data));
messageData->addBlock(messageBlockData);
LLSDMessageBuilder builder = defaultBuilder();

54
indra/test/lltemplatemessagebuilder_tut.cpp
View File

@@ -79,7 +79,7 @@ namespace tut
static LLMessageBlock* defaultBlock(const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
{
return createBlock(_PREHASH_Test0, type, size, block);
return createBlock(const_cast<char*>(_PREHASH_Test0), type, size, block);
}
static LLMessageBlock* createBlock(char* name, const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
@@ -87,12 +87,12 @@ namespace tut
LLMessageBlock* result = new LLMessageBlock(name, block);
if(type != MVT_NULL)
{
result->addVariable(_PREHASH_Test0, type, size);
result->addVariable(const_cast<char*>(_PREHASH_Test0), type, size);
}
return result;
}
static LLTemplateMessageBuilder* defaultBuilder(LLMessageTemplate& messageTemplate, char* name = _PREHASH_Test0)
static LLTemplateMessageBuilder* defaultBuilder(LLMessageTemplate& messageTemplate, char* name = const_cast<char*>(_PREHASH_Test0))
{
nameMap[_PREHASH_TestMessage] = &messageTemplate;
LLTemplateMessageBuilder* builder = new LLTemplateMessageBuilder(nameMap);
@@ -407,11 +407,11 @@ namespace tut
// build template: Test0 before Test1
LLMessageTemplate messageTemplate = defaultTemplate();
messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4, MBT_SINGLE));
// build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, _PREHASH_Test0);
LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, const_cast<char*>(_PREHASH_Test0));
builder->addU32(_PREHASH_Test0, 0xaaaa);
builder->nextBlock(_PREHASH_Test1);
builder->addU32(_PREHASH_Test0, 0xbbbb);
@@ -420,11 +420,11 @@ namespace tut
// build template: Test1 before Test0
messageTemplate = defaultTemplate();
messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
// build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
builder = defaultBuilder(messageTemplate, _PREHASH_Test1);
builder = defaultBuilder(messageTemplate, const_cast<char*>(_PREHASH_Test1));
builder->addU32(_PREHASH_Test0, 0xaaaa);
builder->nextBlock(_PREHASH_Test0);
builder->addU32(_PREHASH_Test0, 0xbbbb);
@@ -447,11 +447,11 @@ namespace tut
// build template: Test0 before Test1
LLMessageTemplate messageTemplate = defaultTemplate();
messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4, MBT_SINGLE));
// build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, _PREHASH_Test0);
LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, const_cast<char*>(_PREHASH_Test0));
builder->addU32(_PREHASH_Test0, 0xaaaa);
builder->nextBlock(_PREHASH_Test1);
builder->addU32(_PREHASH_Test0, 0xbbbb);
@@ -459,7 +459,7 @@ namespace tut
delete builder;
// build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
builder = defaultBuilder(messageTemplate, _PREHASH_Test1);
builder = defaultBuilder(messageTemplate, const_cast<char*>(_PREHASH_Test1));
builder->addU32(_PREHASH_Test0, 0xbbbb);
builder->nextBlock(_PREHASH_Test0);
builder->addU32(_PREHASH_Test0, 0xaaaa);
@@ -482,21 +482,21 @@ namespace tut
// Build template: Test0 only
LLMessageTemplate messageTemplate = defaultTemplate();
messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
// Build message
LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, _PREHASH_Test0);
LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, const_cast<char*>(_PREHASH_Test0));
builder->addU32(_PREHASH_Test0, 0xaaaa);
bufferSize1 = builder->buildMessage(buffer1, MAX_BUFFER_SIZE, 0);
delete builder;
// Build template: Test0 before Test1
messageTemplate = defaultTemplate();
messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4, MBT_SINGLE));
// Build message
builder = defaultBuilder(messageTemplate, _PREHASH_Test0);
builder = defaultBuilder(messageTemplate, const_cast<char*>(_PREHASH_Test0));
builder->addU32(_PREHASH_Test0, 0xaaaa);
builder->nextBlock(_PREHASH_Test1);
builder->addU32(_PREHASH_Test0, 0xbbbb);
@@ -515,8 +515,8 @@ namespace tut
U32 inTest00 = 0, inTest01 = 1, inTest1 = 2;
U32 outTest00, outTest01, outTest1;
LLMessageTemplate messageTemplate = defaultTemplate();
messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4));
messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4));
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4));
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4));
LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
builder->addU32(_PREHASH_Test0, inTest00);
builder->nextBlock(_PREHASH_Test0);
@@ -540,15 +540,15 @@ namespace tut
U32 inTest = 1, outTest;
LLMessageTemplate messageTemplate = defaultTemplate();
messageTemplate.addBlock(
createBlock(_PREHASH_Test0, MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4));
createBlock(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4));
LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
builder->addU32(_PREHASH_Test0, inTest);
LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outTest);
S32 blockCount = reader->getNumberOfBlocks(_PREHASH_Test1);
S32 blockCount = reader->getNumberOfBlocks(const_cast<char*>(_PREHASH_Test1));
ensure_equals("Ensure block count", blockCount, 0);
ensure_equals("Ensure Test0", inTest, outTest);
delete reader;
@@ -560,7 +560,7 @@ namespace tut
{
// build template
LLMessageTemplate messageTemplate = defaultTemplate();
messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4));
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4));
// build message
LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
@@ -885,7 +885,7 @@ namespace tut
delete builder;
// add block to reader template
messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4, MBT_SINGLE));
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4, MBT_SINGLE));
// read message value and default value
numberMap[1] = &messageTemplate;
@@ -918,7 +918,7 @@ namespace tut
delete builder;
// add variable block to reader template
messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4));
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4));
// read message value and check block repeat count
numberMap[1] = &messageTemplate;
@@ -951,7 +951,7 @@ namespace tut
delete builder;
// add variable block to reader template
messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_VARIABLE, 4,
messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_VARIABLE, 4,
MBT_SINGLE));
// read message value and default string

19
indra/test/lltut.cpp
View File

@@ -40,6 +40,7 @@
#include "llformat.h"
#include "llsd.h"
#include "lluri.h"
#include "stringize.h"
namespace tut
{
@@ -76,9 +77,13 @@ namespace tut
void ensure_equals(const char* m, const LLSD& actual,
const LLSD& expected)
{
ensure_equals(std::string(m), actual, expected);
}
void ensure_equals(const std::string& msg, const LLSD& actual,
const LLSD& expected)
{
const std::string& msg = m ? m : "";
ensure_equals(msg + " type", actual.type(), expected.type());
switch (actual.type())
{
@@ -94,7 +99,7 @@ namespace tut
return;
case LLSD::TypeReal:
tut::ensure_equals(msg + " real", actual.asReal(), expected.asReal());
ensure_equals(msg + " real", actual.asReal(), expected.asReal());
return;
case LLSD::TypeString:
@@ -128,7 +133,7 @@ namespace tut
{
ensure_equals(msg + " map keys",
actual_iter->first, expected_iter->first);
ensure_equals((msg + "[" + actual_iter->first + "]").c_str(),
ensure_equals(msg + "[" + actual_iter->first + "]",
actual_iter->second, expected_iter->second);
++actual_iter;
++expected_iter;
@@ -141,11 +146,15 @@ namespace tut
for(int i = 0; i < actual.size(); ++i)
{
ensure_equals((msg + llformat("[%d]", i)).c_str(),
ensure_equals(msg + llformat("[%d]", i),
actual[i], expected[i]);
}
return;
}
default:
// should never get here, but compiler produces warning if we
// don't cover this case, and at Linden warnings are fatal.
throw failure(STRINGIZE("invalid type field " << actual.type()));
}
}

5
indra/test/lltut.h
View File

@@ -74,7 +74,7 @@ namespace tut
inline void ensure_memory_matches(const char* msg,const void* actual, U32 actual_len, const void* expected,U32 expected_len)
{
if((expected_len != actual_len) ||
(memcmp(actual, expected, actual_len) != 0))
(std::memcmp(actual, expected, actual_len) != 0))
{
std::stringstream ss;
ss << (msg?msg:"") << (msg?": ":"") << "not equal";
@@ -121,6 +121,9 @@ namespace tut
void ensure_equals(const char* msg,
const LLSD& actual, const LLSD& expected);
void ensure_equals(const std::string& msg,
const LLSD& actual, const LLSD& expected);
void ensure_starts_with(const std::string& msg,
const std::string& actual, const std::string& expectedStart);