svn merge --ignore-ancestry svn+ssh://svn/svn/linden/release@65088 svn+ssh://svn/svn/linden/branches/release-candidate@65078 -> release Paired by Tess and rdw.

17 files changed, 4001 insertions, 157 deletions

diff --git a/indra/test/llbuffer_tut.cpp b/indra/test/llbuffer_tut.cpp
new file mode 100644
index 0000000000..f403181efa
--- /dev/null
+++ b/indra/test/llbuffer_tut.cpp
@@ -0,0 +1,250 @@
+/**
+ * @file llbuffer_tut.cpp
+ * @author Adroit
+ * @date 2007-03
+ * @brief llbuffer test cases.
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include <tut/tut.h>
+#include "lltut.h"
+#include "llbuffer.h"
+#include "llmemtype.h"
+
+namespace tut
+{
+	struct buffer
+	{
+	};
+
+	typedef test_group<buffer> buffer_t;
+	typedef buffer_t::object buffer_object_t;
+	tut::buffer_t tut_buffer("buffer");
+
+	template<> template<>
+	void buffer_object_t::test<1>()
+	{
+		LLChannelDescriptors channelDescriptors;
+		ensure("in() and out() functions Failed", (0 == channelDescriptors.in() && 1 == channelDescriptors.out()));
+	
+		S32 val = 50;
+		LLChannelDescriptors channelDescriptors1(val);
+		ensure("LLChannelDescriptors in() and out() functions Failed", (50 == channelDescriptors1.in() && 51 == channelDescriptors1.out()));
+	}	
+	
+	template<> template<>
+	void buffer_object_t::test<2>()
+	{
+		LLSegment segment;
+		ensure("LLSegment get functions failed", (0 == segment.getChannel() && NULL == segment.data() && 0 == segment.size()));
+		segment.setChannel(50);
+		ensure_equals("LLSegment setChannel() function failed", segment.getChannel(), 50);
+		ensure("LLSegment isOnChannel() function failed", (TRUE == segment.isOnChannel(50)));
+	}	
+
+	template<> template<>
+	void buffer_object_t::test<3>()
+	{
+		S32 channel = 30;
+		const char str[] = "SecondLife";
+		S32 len = sizeof(str);
+		LLSegment segment(channel, (U8*)str, len);
+		ensure("LLSegment get functions failed", (30 == segment.getChannel() && len == segment.size() && (U8*)str == segment.data()));
+		ensure_memory_matches("LLSegment::data() failed",  segment.data(), segment.size(), (U8*)str, len);
+		ensure("LLSegment isOnChannel() function failed", (TRUE == segment.isOnChannel(channel)));
+	}	 
+	
+	template<> template<>
+	void buffer_object_t::test<4>()
+	{
+		S32 channel = 50;
+		S32 bigSize = 16384*2;
+		char str[] = "SecondLife";
+		S32 smallSize = sizeof(str);
+
+		LLSegment segment;
+		LLHeapBuffer buf; // use default size of DEFAULT_HEAP_BUFFER_SIZE = 16384
+
+		S32 requestSize;
+
+		requestSize = 16384-1;
+		ensure("1. LLHeapBuffer createSegment failed", (TRUE == buf.createSegment(channel, requestSize, segment)) && segment.size() == requestSize);
+		// second request for remainign 1 byte
+
+		requestSize = 1;
+		ensure("2. LLHeapBuffer createSegment failed", (TRUE == buf.createSegment(channel, requestSize, segment)) && segment.size() == requestSize);
+
+		// it should fail now.
+		requestSize = 1;
+		ensure("3. LLHeapBuffer createSegment failed", (FALSE == buf.createSegment(channel, requestSize, segment)));
+
+		LLHeapBuffer buf1(bigSize);
+
+		// requst for more than default size but less than total sizeit should fail now.
+		requestSize = 16384 + 1;
+		ensure("4. LLHeapBuffer createSegment failed", (TRUE == buf1.createSegment(channel, requestSize, segment)) && segment.size() == requestSize);
+
+		LLHeapBuffer buf2((U8*) str, smallSize);
+		requestSize = smallSize;
+		ensure("5. LLHeapBuffer createSegment failed", (TRUE == buf2.createSegment(channel, requestSize, segment)) && segment.size() == requestSize && memcmp(segment.data(), (U8*) str, requestSize) == 0);
+		requestSize = smallSize+1;
+		ensure("6. LLHeapBuffer createSegment failed", (FALSE == buf2.createSegment(channel, requestSize, segment)));
+	}	
+
+	//makeChannelConsumer()
+	template<> template<>
+	void buffer_object_t::test<5>()
+	{
+		LLChannelDescriptors inchannelDescriptors(20);
+		LLChannelDescriptors outchannelDescriptors = LLBufferArray::makeChannelConsumer(inchannelDescriptors);	
+		ensure("LLBufferArray::makeChannelConsumer() function Failed", (21 == outchannelDescriptors.in()));
+	}
+
+	template<> template<>
+	void buffer_object_t::test<6>()
+	{
+		LLBufferArray bufferArray;
+		const char array[] = "SecondLife";
+		S32 len = strlen(array);
+		LLChannelDescriptors channelDescriptors = bufferArray.nextChannel();
+		bufferArray.append(channelDescriptors.in(), (U8*)array, len);
+		S32 count = bufferArray.countAfter(channelDescriptors.in(), NULL);
+		ensure_equals("Appended size is:", count, len);
+	}
+
+	//append() and prepend()
+	template<> template<>
+	void buffer_object_t::test<7>()
+	{
+		LLBufferArray bufferArray;
+		const char array[] = "SecondLife";
+		S32 len = strlen(array);
+		const char array1[] = "LindenLabs";
+		S32 len1 = strlen(array1);
+		
+		std::string str(array1);
+		str.append(array);
+		
+		LLChannelDescriptors channelDescriptors = bufferArray.nextChannel();
+		bufferArray.append(channelDescriptors.in(), (U8*)array, len);
+		bufferArray.prepend(channelDescriptors.in(), (U8*)array1, len1);
+		char buf[100];
+		S32 len2 = 20;
+		bufferArray.readAfter(channelDescriptors.in(), NULL, (U8*)buf, len2);
+		ensure_equals("readAfter length failed", len2, 20);
+		
+		buf[len2] = '\0';
+		ensure_equals("readAfter/prepend/append failed", buf, str);
+	}
+
+	//append()
+	template<> template<>
+	void buffer_object_t::test<8>()
+	{
+		LLBufferArray bufferArray;
+		const char array[] = "SecondLife";
+		S32 len = strlen(array);
+		const char array1[] = "LindenLabs";
+		S32 len1 = strlen(array1);
+		
+		std::string str(array);
+		str.append(array1);
+		
+		LLChannelDescriptors channelDescriptors = bufferArray.nextChannel();
+		bufferArray.append(channelDescriptors.in(), (U8*)array, len);		
+		bufferArray.append(channelDescriptors.in(), (U8*)array1, len1);
+		char buf[100];
+		S32 len2 = 20;
+		bufferArray.readAfter(channelDescriptors.in(), NULL, (U8*)buf, len2);
+		ensure_equals("readAfter length failed", len2, 20);
+		
+		buf[len2] = '\0';
+		ensure_equals("readAfter/append/append failed", buf, str);
+	}
+
+	template<> template<>
+	void buffer_object_t::test<9>()
+	{
+		LLBufferArray bufferArray;
+		const char array[] = "SecondLife";
+		S32 len = strlen(array) + 1;
+		std::string str(array);
+		LLChannelDescriptors channelDescriptors = bufferArray.nextChannel();
+		bufferArray.append(channelDescriptors.in(), (U8*)array, len);
+		LLBufferArray bufferArray1;
+		ensure("Contents are not copied and the source buffer is not empty", (1 == bufferArray1.takeContents(bufferArray)));
+		
+		char buf[100];
+		S32 len2 = len;
+		bufferArray1.readAfter(channelDescriptors.in(), NULL, (U8*)buf, len2);	
+		ensure_equals("takeContents failed to copy", buf, str);
+	}
+
+	//seek()
+	template<> template<>
+	void buffer_object_t::test<10>()
+	{
+		const char array[] = "SecondLife is a Virtual World";
+		S32 len = strlen(array);
+		LLBufferArray bufferArray;
+		bufferArray.append(0, (U8*)array, len);
+		
+		char buf[255];
+		S32 len1 = 16;
+		U8* last = bufferArray.readAfter(0, 0, (U8*)buf, len1);
+		buf[len1] = '\0';
+		last = bufferArray.seek(0, last, -2);
+
+		len1 = 15;
+		last = bufferArray.readAfter(0, last, (U8*)buf, len1);
+		buf[len1] = '\0';
+		std::string str(buf);
+		ensure_equals("Seek does'nt worked", str, std::string("a Virtual World"));
+	}
+
+	template<> template<>
+	void buffer_object_t::test<11>()
+	{
+		const char array[] = "SecondLife is a Virtual World";
+		S32 len = strlen(array);
+		LLBufferArray bufferArray;
+		bufferArray.append(0, (U8*)array, len);
+		
+		char buf[255];
+		S32 len1 = 10;
+		U8* last = bufferArray.readAfter(0, 0, (U8*)buf, len1);
+		bufferArray.splitAfter(last);
+		LLBufferArray::segment_iterator_t iterator = bufferArray.beginSegment();
+		++iterator;
+		std::string str(((char*)(*iterator).data()), (*iterator).size());
+		ensure_equals("Strings are not equal;splitAfter() operation failed", str, std::string(" is a Virtual World"));
+	}
+
+	//makeSegment()->eraseSegment()
+	template<> template<>
+	void buffer_object_t::test<12>()
+	{
+		LLBufferArray bufferArray;
+		LLChannelDescriptors channelDescriptors;
+		LLBufferArray::segment_iterator_t it;
+		S32 length = 1000;
+		it = bufferArray.makeSegment(channelDescriptors.out(), length);
+		ensure("makeSegment() function failed", (it != bufferArray.endSegment()));
+		ensure("eraseSegment() function failed", bufferArray.eraseSegment(it));
+		ensure("eraseSegment() begin/end should now be same", bufferArray.beginSegment() == bufferArray.endSegment());
+	}
+
+	// constructSegmentAfter()
+	template<> template<>
+	void buffer_object_t::test<13>()
+	{
+		LLBufferArray bufferArray;
+		LLBufferArray::segment_iterator_t it;
+		LLSegment segment;
+		LLBufferArray::segment_iterator_t end = bufferArray.endSegment();
+		it = bufferArray.constructSegmentAfter(NULL, segment);
+		ensure("constructSegmentAfter() function failed", (it == end));
+	}
+}
diff --git a/indra/test/lldatapacker_tut.cpp b/indra/test/lldatapacker_tut.cpp
index 71def354f9..5e81185f29 100644
--- a/indra/test/lldatapacker_tut.cpp
+++ b/indra/test/lldatapacker_tut.cpp
@@ -1,30 +1,11 @@
 /**
  * @file lldatapacker_tut.cpp
  * @author Adroit
- * @date February 2007
+ * @date 2007-02
  * @brief LLDataPacker test cases.
  *
- * Copyright (c) 2007-2007, Linden Research, Inc.
- * 
- * 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
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
  */
 
 #include <tut/tut.h>
diff --git a/indra/test/llmessageconfig_tut.cpp b/indra/test/llmessageconfig_tut.cpp
index f7eede73a3..1e9f861b25 100644
--- a/indra/test/llmessageconfig_tut.cpp
+++ b/indra/test/llmessageconfig_tut.cpp
@@ -12,41 +12,46 @@
 #include "llmessageconfig.h"
 #include "llsdserialize.h"
 #include "llfile.h"
+#include "lldir.h"
 #include "lltimer.h"
 #include "llframetimer.h"
 
 namespace tut
 {
-	///var/tmp/babbage/dev/message-liberation/etc
-	static const char file_name[] = "/tmp/message.xml";
-	static const long refreshRateMillis = 6000;
-	
 	struct LLMessageConfigTestData {
+		std::string mTestConfigDir;
 
-		LLSD getCurrentConfig()
+		LLMessageConfigTestData()
 		{
-			LLSD data;
-			// store aside the current config to overwrite the test ones
-			// when the test finishes
-			llifstream in_file(file_name);
-			if (in_file.is_open())
-			{
-				LLSDSerialize::fromXML(data, in_file);
-			}
-			return data;
+			// generate temp dir
+			mTestConfigDir = "/tmp/llmessage-config-test";
+			LLFile::mkdir(mTestConfigDir.c_str());
+
+			LLMessageConfig::initClass("simulator", mTestConfigDir);
+		}
+
+		~LLMessageConfigTestData()
+		{
+			// rm contents of temp dir
+			gDirUtilp->deleteFilesInDir(mTestConfigDir, "*");
+			// rm temp dir
+			LLFile::rmdir(mTestConfigDir.c_str());
 		}
 
+		void reloadConfig(const LLSD& config)
+		{
+			LLMessageConfig::useConfig(config);
+		}
+		
 		void writeConfigFile(const LLSD& config)
 		{
-			LLMessageConfig::initClass("simulator", "/tmp");
-			llofstream file(file_name);
+			std::string configFile = mTestConfigDir + "/message.xml";
+			llofstream file(configFile.c_str());
 			if (file.is_open())
 			{
 				LLSDSerialize::toPrettyXML(config, file);
 			}
 			file.close();
-			ms_sleep(refreshRateMillis);
-			LLFrameTimer::updateFrameTime();
 		}
 	};
 	
@@ -58,150 +63,116 @@ namespace tut
 	void LLMessageConfigTestObject::test<1>()
 		// tests server defaults
 	{
-		LLSD config_backup = getCurrentConfig();
 		LLSD config;
 		config["serverDefaults"]["simulator"] = "template";
-		writeConfigFile(config);
-		ensure_equals("Ensure server default is not llsd",
-					  LLMessageConfig::isServerDefaultBuilderLLSD(),
-					  false);
-		ensure_equals("Ensure server default is template",
-					  LLMessageConfig::isServerDefaultBuilderTemplate(),
-					  true);
-		writeConfigFile(config_backup);
+		reloadConfig(config);
+		ensure_equals("Ensure server default is not template",
+					  LLMessageConfig::getServerDefaultFlavor(),
+					  LLMessageConfig::TEMPLATE_FLAVOR);
 	}
 
 	template<> template<>
 	void LLMessageConfigTestObject::test<2>()
-		// tests message builders
+		// tests message flavors
 	{
-		LLSD config_backup = getCurrentConfig();
 		LLSD config;
 		config["serverDefaults"]["simulator"] = "template";
-		config["messages"]["msg1"]["builder"] = "template";
-		config["messages"]["msg2"]["builder"] = "llsd";
-		writeConfigFile(config);
-		ensure_equals("Ensure msg template builder not llsd",
-					  LLMessageConfig::isMessageBuiltLLSD("msg1"),
-					  false);
-		ensure_equals("Ensure msg template builder",
-					  LLMessageConfig::isMessageBuiltTemplate("msg1"),
-					  true);
-		ensure_equals("Ensure msg llsd builder",
-					  LLMessageConfig::isMessageBuiltLLSD("msg2"),
-					  true);
-		ensure_equals("Ensure msg llsd builder not template",
-					  LLMessageConfig::isMessageBuiltTemplate("msg2"),
-					  false);
-		writeConfigFile(config_backup);
+		config["messages"]["msg1"]["flavor"] = "template";
+		config["messages"]["msg2"]["flavor"] = "llsd";
+		reloadConfig(config);
+		ensure_equals("Ensure msg template flavor",
+					  LLMessageConfig::getMessageFlavor("msg1"),
+					  LLMessageConfig::TEMPLATE_FLAVOR);
+		ensure_equals("Ensure msg llsd flavor",
+					  LLMessageConfig::getMessageFlavor("msg2"),
+					  LLMessageConfig::LLSD_FLAVOR);
 	}
 
 	template<> template<>
 	void LLMessageConfigTestObject::test<4>()
-		// tests message builder defaults
+		// tests message flavor defaults
 	{
-		LLSD config_backup = getCurrentConfig();
 		LLSD config;
 		config["serverDefaults"]["simulator"] = "llsd";
 		config["messages"]["msg1"]["trusted-sender"] = true;
-		writeConfigFile(config);
-		ensure_equals("Ensure missing message defaults to server builder, not template",
-					  LLMessageConfig::isMessageBuiltTemplate("Test"),
-					  false);
-		ensure_equals("Ensure missing message default to server builder llsd",
-					  LLMessageConfig::isMessageBuiltLLSD("Test"),
-					  true);
-		ensure_equals("Ensure missing builder defaults to server builder, not template",
-					  LLMessageConfig::isMessageBuiltTemplate("msg1"),
-					  false);
-		ensure_equals("Ensure missing builder default to server builder llsd",
-					  LLMessageConfig::isMessageBuiltLLSD("msg1"),
-					  true);
-
-		ensure_equals("Ensure server default is not llsd",
-					  LLMessageConfig::isServerDefaultBuilderLLSD(),
-					  true);
-		ensure_equals("Ensure server default is template",
-					  LLMessageConfig::isServerDefaultBuilderTemplate(),
-					  false);
-
-		writeConfigFile(config_backup);
+		reloadConfig(config);
+		ensure_equals("Ensure missing message gives no flavor",
+					  LLMessageConfig::getMessageFlavor("Test"),
+					  LLMessageConfig::NO_FLAVOR);
+		ensure_equals("Ensure missing flavor is NO_FLAVOR even with sender trustedness set",
+					  LLMessageConfig::getMessageFlavor("msg1"),
+					  LLMessageConfig::NO_FLAVOR);
+		ensure_equals("Ensure server default is llsd",
+					  LLMessageConfig::getServerDefaultFlavor(),
+					  LLMessageConfig::LLSD_FLAVOR);
 	}
 
 	template<> template<>
 	void LLMessageConfigTestObject::test<3>()
 		// tests trusted/untrusted senders
 	{
-		LLSD config_backup = getCurrentConfig();
 		LLSD config;
 		config["serverDefaults"]["simulator"] = "template";
-		config["messages"]["msg1"]["builder"] = "llsd";
+		config["messages"]["msg1"]["flavor"] = "llsd";
 		config["messages"]["msg1"]["trusted-sender"] = false;
-		config["messages"]["msg2"]["builder"] = "llsd";
+		config["messages"]["msg2"]["flavor"] = "llsd";
 		config["messages"]["msg2"]["trusted-sender"] = true;
-		writeConfigFile(config);
-		ensure_equals("Ensure untrusted is not trusted",
-					  LLMessageConfig::isMessageTrusted("msg1"),
-					  false);
+		reloadConfig(config);
 		ensure_equals("Ensure untrusted is untrusted",
-					  LLMessageConfig::isValidUntrustedMessage("msg1"),
-					  true);
+					  LLMessageConfig::getSenderTrustedness("msg1"),
+					  LLMessageConfig::UNTRUSTED);
 		ensure_equals("Ensure trusted is trusted",
-					  LLMessageConfig::isMessageTrusted("msg2"),
-					  true);
-		ensure_equals("Ensure trusted is not untrusted",
-					  LLMessageConfig::isValidUntrustedMessage("msg2"),
-					  false);
-		writeConfigFile(config_backup);
+					  LLMessageConfig::getSenderTrustedness("msg2"),
+					  LLMessageConfig::TRUSTED);
+		ensure_equals("Ensure missing trustedness is NOT_SET",
+					  LLMessageConfig::getSenderTrustedness("msg3"),
+					  LLMessageConfig::NOT_SET);
 	}
 	
 	template<> template<>
 	void LLMessageConfigTestObject::test<5>()
-		// tests trusted/untrusted without flag, only builder
+		// tests trusted/untrusted without flag, only flavor
 	{
-		LLSD config_backup = getCurrentConfig();
 		LLSD config;
 		config["serverDefaults"]["simulator"] = "template";
-		config["messages"]["msg1"]["builder"] = "llsd";
-		writeConfigFile(config);
-		ensure_equals("Ensure missing trusted is not trusted",
-					  LLMessageConfig::isMessageTrusted("msg1"),
-					  false);
-		ensure_equals("Ensure missing trusted is not untrusted",
-					  LLMessageConfig::isValidUntrustedMessage("msg1"),
-					  false);
-		writeConfigFile(config_backup);
+		config["messages"]["msg1"]["flavor"] = "llsd";
+		reloadConfig(config);
+		ensure_equals("Ensure msg1 exists, has llsd flavor",
+					  LLMessageConfig::getMessageFlavor("msg1"),
+					  LLMessageConfig::LLSD_FLAVOR);
+		ensure_equals("Ensure missing trusted is not set",
+					  LLMessageConfig::getSenderTrustedness("msg1"),
+					  LLMessageConfig::NOT_SET);
 	}
 
 	template<> template<>
 	void LLMessageConfigTestObject::test<6>()
-		// tests message builder defaults
 	{
-		LLSD config_backup = getCurrentConfig();
 		LLSD config;
-		config["serverDefaults"]["simulator"] = "template";
-		config["messages"]["msg1"]["trusted-sender"] = true;
-		writeConfigFile(config);
-		ensure_equals("Ensure missing message defaults to server builder, not template",
-					  LLMessageConfig::isMessageBuiltTemplate("Test"),
-					  true);
-		ensure_equals("Ensure missing message default to server builder llsd",
-					  LLMessageConfig::isMessageBuiltLLSD("Test"),
-					  false);
-		ensure_equals("Ensure missing builder defaults to server builder, not template",
-					  LLMessageConfig::isMessageBuiltTemplate("msg1"),
+		config["capBans"]["MapLayer"] = true;
+		config["capBans"]["MapLayerGod"] = false;
+		reloadConfig(config);
+		ensure_equals("Ensure cap ban true MapLayer",
+					  LLMessageConfig::isCapBanned("MapLayer"),
 					  true);
-		ensure_equals("Ensure missing builder default to server builder llsd",
-					  LLMessageConfig::isMessageBuiltLLSD("msg1"),
+		ensure_equals("Ensure cap ban false",
+					  LLMessageConfig::isCapBanned("MapLayerGod"),
 					  false);
+	}
 
-		ensure_equals("Ensure server default is not llsd",
-					  LLMessageConfig::isServerDefaultBuilderLLSD(),
-					  false);
-		ensure_equals("Ensure server default is template",
-					  LLMessageConfig::isServerDefaultBuilderTemplate(),
-					  true);
+	template<> template<>
+	void LLMessageConfigTestObject::test<7>()
+		// tests that config changes are picked up/refreshed periodically
+	{
+		LLSD config;
+		config["serverDefaults"]["simulator"] = "llsd";
+		writeConfigFile(config);
 
-		writeConfigFile(config_backup);
+		// wait for it to reload after N seconds
+		ms_sleep(6*1000);
+		LLFrameTimer::updateFrameTime();
+		ensure_equals("Ensure reload after 6 seconds",
+					  LLMessageConfig::getServerDefaultFlavor(),
+					  LLMessageConfig::LLSD_FLAVOR);
 	}
 }
diff --git a/indra/test/llmessagetemplateparser_tut.cpp b/indra/test/llmessagetemplateparser_tut.cpp
new file mode 100644
index 0000000000..2f76d7fb20
--- /dev/null
+++ b/indra/test/llmessagetemplateparser_tut.cpp
@@ -0,0 +1,350 @@
+/** 
+ * @file llmessagetemplateparser_tut.cpp
+ * @date April 2007
+ * @brief LLMessageTemplateParser unit tests
+ *
+ * Copyright (c) 2006-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include <tut/tut.h>
+#include "lltut.h"
+#include "llmessagetemplateparser.h"
+
+namespace tut
+{
+	struct LLMessageTemplateParserTestData {
+		LLMessageTemplateParserTestData() : mMessage("unset message")
+		{
+		}
+
+		~LLMessageTemplateParserTestData()
+		{
+		}
+
+		void ensure_next(LLTemplateTokenizer & tokens,
+						 std::string value,
+						 U32 line)
+		{
+			std::string next = tokens.next();
+			ensure_equals(mMessage + " token matches", next, value);
+			ensure_equals(mMessage + " line matches", tokens.line(), line);
+		}
+
+		char * prehash(const char * name)
+		{
+			return gMessageStringTable.getString(name);
+		}
+
+		void ensure_block_attributes(std::string identifier,
+									 const LLMessageTemplate * message,
+									 const char * name,
+									 EMsgBlockType type,
+									 S32 number,
+									 S32 total_size)
+		{
+			const LLMessageBlock * block = message->getBlock(prehash(name));
+			identifier = identifier + ":" + message->mName + ":" + name + " block";
+			ensure(identifier + " exists", block != NULL);
+			ensure_equals(identifier + " name", block->mName, prehash(name));
+			ensure_equals(identifier + " type", block->mType, type);
+			ensure_equals(identifier + " number", block->mNumber, number);
+			ensure_equals(identifier + " total size", block->mTotalSize, total_size);
+		}
+
+		void ensure_variable_attributes(std::string identifier,
+										const LLMessageBlock * block,
+										const char * name,
+										EMsgVariableType type,
+										S32 size)
+		{
+			const LLMessageVariable * var = block->getVariable(prehash(name));
+			identifier = identifier + ":" + block->mName + ":" + name + " variable";
+			ensure(identifier + " exists", var != NULL);
+			ensure_equals(
+				identifier + " name", var->getName(), prehash(name));
+			ensure_equals(
+				identifier + " type", var->getType(), type);
+			ensure_equals(identifier + " size", var->getSize(), size);
+		}
+		
+		std::string mMessage;
+			
+	};
+	
+	typedef test_group<LLMessageTemplateParserTestData> LLMessageTemplateParserTestGroup;
+	typedef LLMessageTemplateParserTestGroup::object LLMessageTemplateParserTestObject;
+	LLMessageTemplateParserTestGroup llMessageTemplateParserTestGroup("LLMessageTemplateParser");
+	
+	template<> template<>
+	void LLMessageTemplateParserTestObject::test<1>()
+		// tests tokenizer constructor and next methods
+	{
+		mMessage = "test method 1 walkthrough";
+		LLTemplateTokenizer tokens("first line\nnext\t line\n\nfourth");
+		ensure_next(tokens, "first", 1);
+		ensure_next(tokens, "line", 1);
+		ensure_next(tokens, "next", 2);
+		ensure_next(tokens, "line", 2);
+		ensure_next(tokens, "fourth", 4);
+
+		tokens = LLTemplateTokenizer("\n\t{ \t   Test1 Fixed \n 523 }\n\n");
+		ensure(tokens.want("{"));
+		ensure_next(tokens, "Test1", 2);
+		ensure_next(tokens, "Fixed", 2);
+		ensure_next(tokens, "523", 3);
+		ensure(tokens.want("}"));
+
+		tokens = LLTemplateTokenizer("first line\nnext\t line\n\nfourth");
+		ensure(tokens.want("first"));
+		ensure_next(tokens, "line", 1);
+		ensure_next(tokens, "next", 2);
+		ensure_next(tokens, "line", 2);
+		ensure(tokens.want("fourth"));
+	}
+
+	template<> template<>
+	void LLMessageTemplateParserTestObject::test<2>()
+		// tests tokenizer want method
+	{
+		// *NOTE: order matters
+		LLTemplateTokenizer tokens("first line\nnext\t line\n\nfourth");
+		ensure_equals("wants first token", tokens.want("first"), true);
+		ensure_equals("doesn't want blar token", tokens.want("blar"), false);
+		ensure_equals("wants line token", tokens.want("line"), true);
+	}
+
+	template<> template<>
+	void LLMessageTemplateParserTestObject::test<3>()
+		// tests tokenizer eof methods
+	{
+		LLTemplateTokenizer tokens("single\n\n");
+		ensure_equals("is not at eof at beginning", tokens.atEOF(), false);
+		ensure_equals("doesn't want eof", tokens.wantEOF(), false);
+		ensure_equals("wants the first token just to consume it",
+					  tokens.want("single"), true);
+		ensure_equals("is not at eof in middle", tokens.atEOF(), false);
+		ensure_equals("wants eof", tokens.wantEOF(), true);
+		ensure_equals("is at eof at end", tokens.atEOF(), true);
+	}
+
+	template<> template<>
+	void LLMessageTemplateParserTestObject::test<4>()
+		// tests variable parsing method
+	{
+		LLTemplateTokenizer tokens(std::string("{    Test0  \n\t\n   U32 \n\n }"));
+		LLMessageVariable * var = LLTemplateParser::parseVariable(tokens);
+
+		ensure("test0 var parsed", var != 0);
+		ensure_equals("name of variable", std::string(var->getName()), std::string("Test0"));
+		ensure_equals("type of variable is U32", var->getType(), MVT_U32);
+		ensure_equals("size of variable", var->getSize(), 4);
+
+		delete var;
+
+		std::string message_string("\n\t{ \t   Test1 Fixed \n 523 }\n\n");
+		tokens = LLTemplateTokenizer(message_string);
+		var = LLTemplateParser::parseVariable(tokens);
+
+		ensure("test1 var parsed", var != 0);
+		ensure_equals("name of variable", std::string(var->getName()), std::string("Test1"));
+		ensure_equals("type of variable is Fixed", var->getType(), MVT_FIXED);
+		ensure_equals("size of variable", var->getSize(), 523);
+
+		delete var;
+	
+		// *NOTE: the parsers call llerrs on invalid input, so we can't really
+		// test that  :-(
+	}
+
+	template<> template<>
+	void LLMessageTemplateParserTestObject::test<5>()
+		// tests block parsing method
+	{
+		LLTemplateTokenizer tokens("{ BlockA Single { VarX F32 } }");
+		LLMessageBlock * block = LLTemplateParser::parseBlock(tokens);
+
+		ensure("blockA block parsed", block != 0);
+		ensure_equals("name of block", std::string(block->mName), std::string("BlockA"));
+		ensure_equals("type of block is Single", block->mType, MBT_SINGLE);
+		ensure_equals("total size of block", block->mTotalSize, 4);
+		ensure_equals("number of block defaults to 1", block->mNumber, 1);
+		ensure_equals("variable type of VarX is F32",
+					  block->getVariableType(prehash("VarX")), MVT_F32);
+		ensure_equals("variable size of VarX",
+					  block->getVariableSize(prehash("VarX")), 4);
+
+		delete block;
+
+		tokens = LLTemplateTokenizer("{ Stuff Variable { Id LLUUID } }");
+		block = LLTemplateParser::parseBlock(tokens);
+
+		ensure("stuff block parsed", block != 0);
+		ensure_equals("name of block", std::string(block->mName), std::string("Stuff"));
+		ensure_equals("type of block is Multiple", block->mType, MBT_VARIABLE);
+		ensure_equals("total size of block", block->mTotalSize, 16);
+		ensure_equals("number of block defaults to 1", block->mNumber, 1);
+		ensure_equals("variable type of Id is LLUUID",
+					  block->getVariableType(prehash("Id")), MVT_LLUUID);
+		ensure_equals("variable size of Id",
+					  block->getVariableSize(prehash("Id")), 16);
+
+		delete block;
+
+		tokens = LLTemplateTokenizer("{ Stuff2 Multiple 45 { Shid LLVector3d } }");
+		block = LLTemplateParser::parseBlock(tokens);
+
+		ensure("stuff2 block parsed", block != 0);
+		ensure_equals("name of block", std::string(block->mName), std::string("Stuff2"));
+		ensure_equals("type of block is Multiple", block->mType, MBT_MULTIPLE);
+		ensure_equals("total size of block", block->mTotalSize, 24);
+		ensure_equals("number of blocks", block->mNumber, 45);
+		ensure_equals("variable type of Shid is Vector3d",
+					  block->getVariableType(prehash("Shid")), MVT_LLVector3d);
+		ensure_equals("variable size of Shid",
+					  block->getVariableSize(prehash("Shid")), 24);
+
+		delete block;		
+	}
+
+	template<> template<>
+	void LLMessageTemplateParserTestObject::test<6>()
+		// tests message parsing method on a simple message
+	{
+		std::string message_skel(
+			"{\n"
+			"TestMessage Low 1 NotTrusted Zerocoded\n"
+			"// comment \n"
+			"  {\n"
+			"TestBlock1      Single\n"
+			"      {   Test1       U32 }\n"
+			"  }\n"
+			"  {\n"
+			"      NeighborBlock       Multiple        4\n"
+			"      {   Test0       U32 }\n"
+			"      {   Test1       U32 }\n"
+			"      {   Test2       U32 }\n"
+			"  }\n"
+			"}");
+		LLTemplateTokenizer tokens(message_skel);
+		LLMessageTemplate * message = LLTemplateParser::parseMessage(tokens);
+
+		ensure("simple message parsed", message != 0);
+		ensure_equals("name of message", std::string(message->mName), std::string("TestMessage"));
+		ensure_equals("frequency is Low", message->mFrequency, MFT_LOW);
+		ensure_equals("trust is untrusted", message->mTrust, MT_NOTRUST);
+		ensure_equals("message number", message->mMessageNumber, (U32)((255 << 24) | (255 << 16) | 1));
+		ensure_equals("message encoding is zerocoded", message->mEncoding, ME_ZEROCODED);
+		ensure_equals("message deprecation is notdeprecated", message->mDeprecation, MD_NOTDEPRECATED);
+
+		LLMessageBlock * block = message->getBlock(prehash("NonexistantBlock"));
+		ensure("Nonexistant block does not exist", block == 0);
+		
+		delete message;
+	}
+
+		template<> template<>
+	void LLMessageTemplateParserTestObject::test<7>()
+		// tests message parsing method on a deprecated message
+	{
+		std::string message_skel(
+			"{\n"
+			"TestMessageDeprecated High 34 Trusted Unencoded Deprecated\n"
+			"  {\n"
+			"TestBlock2      Single\n"
+			"      {   Test2       S32 }\n"
+			"  }\n"
+			"}");
+		LLTemplateTokenizer tokens(message_skel);
+		LLMessageTemplate * message = LLTemplateParser::parseMessage(tokens);
+		
+		ensure("deprecated message parsed", message != 0);
+		ensure_equals("name of message", std::string(message->mName), std::string("TestMessageDeprecated"));
+		ensure_equals("frequency is High", message->mFrequency, MFT_HIGH);
+		ensure_equals("trust is trusted", message->mTrust, MT_TRUST);
+		ensure_equals("message number", message->mMessageNumber, (U32)34);
+		ensure_equals("message encoding is unencoded", message->mEncoding, ME_UNENCODED);
+		ensure_equals("message deprecation is deprecated", message->mDeprecation, MD_DEPRECATED);
+
+		delete message;
+	}
+
+	void LLMessageTemplateParserTestObject::test<8>()
+		// tests message parsing on RezMultipleAttachmentsFromInv, a possibly-faulty message
+	{
+		std::string message_skel(
+			"{\n\
+				RezMultipleAttachmentsFromInv Low 452 NotTrusted Zerocoded\n\
+				{\n\
+					AgentData			Single\n\
+					{	AgentID			LLUUID	}\n\
+					{	SessionID		LLUUID	}\n\
+				}	\n\
+				{\n\
+					HeaderData			Single\n\
+					{	CompoundMsgID			LLUUID  }	// All messages a single \"compound msg\" must have the same id\n\
+					{	TotalObjects			U8	}\n\
+					{	FirstDetachAll			BOOL	}\n\
+				}\n\
+				{\n\
+					ObjectData			Variable		// 1 to 4 of these per packet\n\
+					{	ItemID					LLUUID	}\n\
+					{	OwnerID					LLUUID	}\n\
+					{	AttachmentPt			U8	}	// 0 for default\n\
+					{	ItemFlags				U32 }\n\
+					{	GroupMask				U32 }\n\
+					{	EveryoneMask			U32 }\n\
+					{	NextOwnerMask			U32	}\n\
+					{	Name					Variable	1	}\n\
+					{	Description				Variable	1	}\n\
+				}\n\
+			}\n\
+			");
+		LLTemplateTokenizer tokens(message_skel);
+		LLMessageTemplate * message = LLTemplateParser::parseMessage(tokens);
+
+		ensure("RezMultipleAttachmentsFromInv message parsed", message != 0);
+		ensure_equals("name of message", message->mName, prehash("RezMultipleAttachmentsFromInv"));
+		ensure_equals("frequency is low", message->mFrequency, MFT_LOW);
+		ensure_equals("trust is not trusted", message->mTrust, MT_NOTRUST);
+		ensure_equals("message number", message->mMessageNumber, (U32)((255 << 24) | (255 << 16) | 452));
+		ensure_equals("message encoding is zerocoded", message->mEncoding, ME_ZEROCODED);
+
+		ensure_block_attributes(
+			"RMAFI", message, "AgentData", MBT_SINGLE, 1, 16+16);
+		LLMessageBlock * block = message->getBlock(prehash("AgentData"));
+		ensure_variable_attributes("RMAFI",
+								   block, "AgentID", MVT_LLUUID, 16);
+		ensure_variable_attributes("RMAFI",
+								   block, "SessionID", MVT_LLUUID, 16);
+		
+		ensure_block_attributes(
+			"RMAFI", message, "HeaderData", MBT_SINGLE, 1, 16+1+1);
+		block = message->getBlock(prehash("HeaderData"));
+		ensure_variable_attributes(
+			"RMAFI", block, "CompoundMsgID", MVT_LLUUID, 16);
+		ensure_variable_attributes(
+			"RMAFI", block, "TotalObjects", MVT_U8, 1);
+		ensure_variable_attributes(
+			"RMAFI", block, "FirstDetachAll", MVT_BOOL, 1);
+
+
+		ensure_block_attributes(
+			"RMAFI", message, "ObjectData", MBT_VARIABLE, 1, -1);
+		block = message->getBlock(prehash("ObjectData"));
+		ensure_variable_attributes("RMAFI", block, "ItemID", MVT_LLUUID, 16);
+		ensure_variable_attributes("RMAFI", block, "OwnerID", MVT_LLUUID, 16);
+		ensure_variable_attributes("RMAFI", block, "AttachmentPt", MVT_U8, 1);
+		ensure_variable_attributes("RMAFI", block, "ItemFlags", MVT_U32, 4);
+		ensure_variable_attributes("RMAFI", block, "GroupMask", MVT_U32, 4);
+		ensure_variable_attributes("RMAFI", block, "EveryoneMask", MVT_U32, 4);
+		ensure_variable_attributes("RMAFI", block, "NextOwnerMask", MVT_U32, 4);
+		ensure_variable_attributes("RMAFI", block, "Name", MVT_VARIABLE, 1);
+		ensure_variable_attributes("RMAFI", block, "Description", MVT_VARIABLE, 1);
+
+		delete message;
+	}
+
+	
+
+}
diff --git a/indra/test/llpermissions_tut.cpp b/indra/test/llpermissions_tut.cpp
new file mode 100644
index 0000000000..1a1e392a65
--- /dev/null
+++ b/indra/test/llpermissions_tut.cpp
@@ -0,0 +1,533 @@
+/**
+ * @file llpermissions_tut.cpp
+ * @author Adroit
+ * @date March 2007
+ * @brief llpermissions test cases.
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+ 
+#include <tut/tut.h>
+#include "lltut.h"
+#include "message.h"
+#include "llpermissions.h"
+
+
+namespace tut
+{
+	struct permission
+	{
+	};
+	typedef test_group<permission> permission_t;
+	typedef permission_t::object permission_object_t;
+	tut::permission_t tut_permission("permission");
+
+	template<> template<>
+	void permission_object_t::test<1>()
+	{
+		LLPermissions permissions;
+		LLUUID	uuid = permissions.getCreator();
+		LLUUID	uuid1 = permissions.getOwner(); 
+		LLUUID	uuid2 = permissions.getGroup();
+		LLUUID	uuid3 = permissions.getLastOwner(); 
+
+		ensure("LLPermission Get Functions failed", (uuid == LLUUID::null && uuid1 == LLUUID::null && 
+			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));
+	}
+
+	template<> template<>
+	void permission_object_t::test<2>()
+	{
+		LLPermissions permissions;
+		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");		
+		permissions.init(creator, owner, lastOwner, group);
+
+		ensure_equals("init/getCreator():failed to return the creator ", creator, permissions.getCreator());	
+		ensure_equals("init/getOwner():failed to return the owner ", owner, permissions.getOwner());
+		ensure_equals("init/getLastOwner():failed to return the group ", lastOwner, permissions.getLastOwner());	
+		ensure_equals("init/getGroup():failed to return the group ", group, permissions.getGroup());	
+	}
+
+	template<> template<>
+	void permission_object_t::test<3>()
+	{
+		LLPermissions permissions;
+		U32 base = PERM_ALL;
+		U32 owner = PERM_ITEM_UNRESTRICTED; //PERM_ITEM_UNRESTRICTED = PERM_MODIFY | PERM_COPY | PERM_TRANSFER;
+		U32 group = PERM_TRANSFER | PERM_MOVE | PERM_COPY|PERM_MODIFY;
+		U32 everyone = PERM_TRANSFER | PERM_MOVE | PERM_MODIFY;
+		U32 next = PERM_NONE;
+
+		U32 fixedbase = base;
+		U32 fixedowner = PERM_ITEM_UNRESTRICTED; //owner & fixedbase
+		U32 fixedgroup = PERM_ITEM_UNRESTRICTED; // no PERM_MOVE as owner does not have that perm either
+		U32 fixedeveryone = PERM_TRANSFER; // no PERM_MOVE. Everyone can never modify.
+		U32 fixednext = PERM_NONE;
+
+		permissions.initMasks(base, owner, everyone, group, next); // will fix perms if not allowed.
+		ensure_equals("initMasks/getMaskBase():failed to return the MaskBase ", fixedbase, permissions.getMaskBase());	
+		ensure_equals("initMasks/getMaskOwner():failed to return the MaskOwner ", fixedowner, permissions.getMaskOwner());	
+		ensure_equals("initMasks/getMaskEveryone():failed to return the MaskGroup ", fixedgroup, permissions.getMaskGroup());	
+		ensure_equals("initMasks/getMaskEveryone():failed to return the MaskEveryone ", fixedeveryone, permissions.getMaskEveryone());	
+		ensure_equals("initMasks/getMaskNextOwner():failed to return the MaskNext ", fixednext, permissions.getMaskNextOwner());	
+
+		// explictly set should maintain the values
+		permissions.setMaskBase(base); //no fixing
+		ensure_equals("setMaskBase/getMaskBase():failed to return the MaskBase ", base, permissions.getMaskBase());	
+
+		permissions.setMaskOwner(owner);
+		ensure_equals("setMaskOwner/getMaskOwner():failed to return the MaskOwner ", owner, permissions.getMaskOwner());	
+		
+		permissions.setMaskEveryone(everyone);
+		ensure_equals("setMaskEveryone/getMaskEveryone():failed to return the MaskEveryone ", everyone, permissions.getMaskEveryone());	
+
+		permissions.setMaskGroup(group);
+		ensure_equals("setMaskGroup/getMaskEveryone():failed to return the MaskGroup ", group, permissions.getMaskGroup());	
+
+		permissions.setMaskNext(next);
+		ensure_equals("setMaskNext/getMaskNextOwner():failed to return the MaskNext ", next, permissions.getMaskNextOwner());	
+
+		// further tests can be added to ensure perms for owner/group/everyone etc. get properly fixed. 
+		// code however suggests that there is no explict check if the perms are correct and the user of this 
+		// class is expected to know how to use them correctly. skipping further test cases for now for various
+		// perm combinations.
+	}
+
+	template<> template<>
+	void permission_object_t::test<4>()
+	{
+		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");		
+		perm1.init(creator,owner,lastOwner,group);
+		perm.set(perm1);
+		ensure("set():failed to set ", (creator == perm.getCreator()) && (owner == perm.getOwner())&&
+									(lastOwner == perm.getLastOwner())&& (group == perm.getGroup()));	
+		}
+
+	template<> template<>
+	void permission_object_t::test<5>()
+	{
+		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");		
+		perm1.init(creator,owner,lastOwner,group);
+
+		U32 base = PERM_TRANSFER;
+		U32 ownerp = PERM_TRANSFER;
+		U32 groupp = PERM_TRANSFER;
+		U32 everyone = PERM_TRANSFER;
+		U32 next = PERM_NONE;
+
+		perm1.initMasks(base, ownerp, everyone, groupp, next);
+
+		base = PERM_ALL;
+		ownerp = PERM_ITEM_UNRESTRICTED; //PERM_ITEM_UNRESTRICTED = PERM_MODIFY | PERM_COPY | PERM_TRANSFER;
+		groupp = PERM_TRANSFER | PERM_COPY|PERM_MODIFY;
+		everyone = PERM_TRANSFER;
+		next = PERM_NONE;
+		
+		perm.init(creator,owner,lastOwner,group);
+		perm.initMasks(base, ownerp, everyone, groupp, next); 
+
+		// restrict permissions by accumulation
+		perm.accumulate(perm1);
+
+		U32 fixedbase = PERM_TRANSFER | PERM_MOVE;
+		U32 fixedowner = PERM_TRANSFER;
+		U32 fixedgroup = PERM_TRANSFER;
+		U32 fixedeveryone = PERM_TRANSFER;
+		U32 fixednext = PERM_NONE;
+
+		ensure_equals("accumulate failed ", fixedbase, perm.getMaskBase());	
+		ensure_equals("accumulate failed ", fixedowner, perm.getMaskOwner());	
+		ensure_equals("accumulate failed ", fixedgroup, perm.getMaskGroup());	
+		ensure_equals("accumulate failed ", fixedeveryone, perm.getMaskEveryone());	
+		ensure_equals("accumulate failed ", fixednext, perm.getMaskNextOwner());	
+	}
+
+	template<> template<>
+	void permission_object_t::test<6>()
+	{
+		LLPermissions perm;
+		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);
+		ensure_equals("getSafeOwner:failed ", owner,perm.getSafeOwner());
+		
+		///NULL Owner
+		perm.init(creator,LLUUID::null,lastOwner,group);
+		ensure_equals("getSafeOwner:failed ", group, perm.getSafeOwner());
+	}
+	
+		template<> template<>
+	void permission_object_t::test<7>()
+	{
+		LLPermissions perm1;
+		LLUUID uuid;
+		BOOL is_group_owned = FALSE;
+		ensure("1:getOwnership:failed ", (FALSE == perm1.getOwnership(uuid,is_group_owned)));
+		
+		LLPermissions perm;
+		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);
+		perm.getOwnership(uuid,is_group_owned);
+		ensure("2:getOwnership:failed ", ((uuid == owner) && (FALSE == 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))); 
+	}
+
+	template<> template<>
+	void permission_object_t::test<8>()
+	{
+		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);
+		perm1.init(creator,owner,lastOwner,group);
+		ensure_equals("getCRC32:failed ", perm.getCRC32(),perm1.getCRC32());
+	}
+
+	template<> template<>
+	void permission_object_t::test<9>()
+	{
+		LLPermissions perm;
+		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)));
+		
+		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)));
+		
+		// should be able to change - agent and owner same as current owner
+		ensure("setOwnerAndGroup():failed ", (TRUE == perm.setOwnerAndGroup(owner,owner,group2,is_atomic)));
+	}
+
+	template<> template<>
+	void permission_object_t::test<10>()
+	{
+		LLPermissions perm;
+		LLUUID agent;
+		LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");
+		ensure("deedToGroup():failed ", (TRUE == perm.deedToGroup(agent,group)));
+	}
+	template<> template<>
+	void permission_object_t::test<11>()
+	{
+		LLPermissions perm;
+		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)));
+
+		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)));
+	}
+
+	template<> template<>
+	void permission_object_t::test<12>()
+	{
+		LLPermissions perm;
+		LLUUID agent;
+		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)));
+
+		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)));
+	}
+
+	template<> template<>
+	void permission_object_t::test<13>()
+	{
+		LLPermissions perm;
+		LLUUID agent;
+		LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");		
+		U32 bits = 10;
+		ensure("allowOperationBy():failed ", (TRUE == 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)));
+	}
+
+	template<> template<>
+	void permission_object_t::test<14>()
+	{
+		LLPermissions perm;
+		LLUUID creator("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");	
+		LLUUID owner;
+		LLUUID lastOwner("5e47a0dc-97bf-44e0-8b40-de06718cee9d"); 
+		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)));
+				
+		U32 val1 = 0x7FFFFFFF;
+		S32 sVal = 1 << 14;
+		sVal = val1 & sVal;
+		LLUUID agent1("9c8eca51-53d5-42a7-bb58-cef070395db8"); 
+		ensure("3:allowModifyBy():failed ", (sVal == perm.allowModifyBy(agent1)));
+		ensure("4:allowModifyBy():failed ", (sVal == perm.allowModifyBy(agent1,group)));
+	}
+	
+	template<> template<>
+	void permission_object_t::test<15>()
+	{
+		LLPermissions perm;
+		LLUUID creator("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");	
+		LLUUID owner;
+		LLUUID lastOwner("5e47a0dc-97bf-44e0-8b40-de06718cee9d"); 
+		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)));
+				
+		U32 val1 = 0x7FFFFFFF;
+		S32 sVal = 1 << 15;
+		sVal = val1 & sVal;
+		LLUUID agent1("9c8eca51-53d5-42a7-bb58-cef070395db8"); 
+		ensure("3:allowCopyBy():failed ", (sVal == perm.allowCopyBy(agent1)));
+		ensure("4:allowCopyBy():failed ", (sVal == perm.allowCopyBy(agent1,group)));
+	}
+
+	template<> template<>
+	void permission_object_t::test<16>()
+	{
+		LLPermissions perm;
+		LLUUID creator("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");	
+		LLUUID owner;
+		LLUUID lastOwner("5e47a0dc-97bf-44e0-8b40-de06718cee9d"); 
+		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)));
+
+		U32 val1 = 0x7FFFFFFF;
+		S32 sVal = 1 << 19;
+		sVal = val1 & sVal;
+		LLUUID agent1("9c8eca51-53d5-42a7-bb58-cef070395db8"); 
+		ensure("3:allowMoveBy():failed ", (sVal == perm.allowMoveBy(agent1)));
+		ensure("4:allowMoveBy():failed ", (sVal == perm.allowMoveBy(agent1,group)));
+	}
+
+	template<> template<>
+	void permission_object_t::test<17>()
+	{
+		LLPermissions perm;
+		LLUUID creator("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");	
+		LLUUID owner;
+		LLUUID lastOwner("5e47a0dc-97bf-44e0-8b40-de06718cee9d"); 
+		LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");		
+		LLUUID agent;
+		ensure("1:allowMoveBy():failed ", (TRUE == perm.allowTransferTo(agent)));
+		
+		perm.init(creator,owner,lastOwner,group);
+		U32 val1 = 0x7FFFFFFF;
+		S32 sVal = 1 << 13;
+		sVal = val1 & sVal;
+		ensure("2:allowMoveBy():failed ", (sVal == perm.allowTransferTo(agent)));
+	}
+
+	template<> template<>
+	void permission_object_t::test<18>()
+	{
+		LLPermissions perm,perm1;
+		ensure("1:Operator==:failed ", 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);
+		perm = perm1;
+		ensure("2:Operator==:failed ", perm == perm1);
+	}
+
+	template<> template<>
+	void permission_object_t::test<19>()
+	{
+		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);
+		ensure("2:Operator==:failed ", perm != perm1);
+	}
+
+	template<> template<>
+	void permission_object_t::test<20>()
+	{
+		FILE* fp = fopen("linden_file.dat","w+");
+		if(!fp)
+		{
+			llerrs << "file coudnt be opened\n" << llendl;
+			return;
+		}
+		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);
+		
+		U32 base = PERM_TRANSFER | PERM_COPY;
+		U32 ownerp = PERM_TRANSFER;
+		U32 groupp = PERM_TRANSFER;
+		U32 everyone = PERM_TRANSFER;
+		U32 next = PERM_NONE;
+
+		perm.initMasks(base, ownerp, everyone, groupp, next);
+
+		perm.exportFile(fp);
+		fclose(fp);	
+		fp = fopen("linden_file.dat","r+");
+		if(!fp)
+		{
+			llerrs << "file coudnt be opened\n" << llendl;
+			return;
+		}
+		perm1.importFile(fp);
+		fclose(fp);
+		ensure("exportFile()/importFile():failed to export and import the data ", perm1 == perm);	
+}
+
+	template<> template<>
+	void permission_object_t::test<21>()
+	{
+		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);
+
+		U32 base = PERM_TRANSFER | PERM_COPY;
+		U32 ownerp = PERM_TRANSFER;
+		U32 groupp = PERM_TRANSFER;
+		U32 everyone = PERM_TRANSFER;
+		U32 next = PERM_NONE;
+
+		perm.initMasks(base, ownerp, everyone, groupp, next);
+
+		std::ostringstream ostream;
+		perm.exportLegacyStream(ostream);
+		std::istringstream istream(ostream.str());
+		perm1.importLegacyStream(istream);
+
+		ensure("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);	
+	}
+
+	template<> template<>
+	void permission_object_t::test<23>()
+	{
+		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);
+		std::ostringstream stream1, stream2;
+		stream1 << perm;
+		perm1.init(creator,owner,lastOwner,group);
+		stream2 << perm1;
+		ensure("1:operator << failed",(stream1.str() == stream2.str()));	
+	}
+
+	template<> template<>
+	void permission_object_t::test<24>()
+	{
+		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);
+		
+		U32 base = PERM_TRANSFER | PERM_COPY;
+		U32 ownerp = PERM_TRANSFER;
+		U32 groupp = PERM_TRANSFER;
+		U32 everyone = PERM_TRANSFER;
+		U32 next = PERM_NONE;
+
+		perm.initMasks(base, ownerp, everyone, groupp, next);
+
+		LLSD sd = ll_create_sd_from_permissions(perm);
+		perm1 = ll_permissions_from_sd(sd);
+		ensure_equals("ll_permissions_from_sd() and ll_create_sd_from_permissions()functions failed", perm, perm1);
+	}
+
+	template<> template<>
+	void permission_object_t::test<25>()
+	{
+		LLAggregatePermissions AggrPermission;	
+		LLAggregatePermissions AggrPermission1;	
+		ensure("getU8() function failed", (AggrPermission.getU8() == 0));
+		ensure("isEmpty() function failed", (AggrPermission.isEmpty() == TRUE));
+		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));
+
+		AggrPermission1.aggregate(AggrPermission);
+		ensure("aggregate() function failed", (AggrPermission1.isEmpty() == FALSE));
+
+		std::ostringstream stream1;
+		stream1 << AggrPermission;
+		ensure("operator<< failed", (stream1.str() == "{PI_COPY=All, PI_MODIFY=All, PI_TRANSFER=All}"));
+	}
+}
diff --git a/indra/test/llsaleinfo_tut.cpp b/indra/test/llsaleinfo_tut.cpp
new file mode 100644
index 0000000000..ef6e1cc94b
--- /dev/null
+++ b/indra/test/llsaleinfo_tut.cpp
@@ -0,0 +1,228 @@
+/** 
+ * @file LLSaleInfo_tut.cpp
+ * @author Adroit
+ * @date 2007-03
+ * @brief Test cases of llsaleinfo.h
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include <tut/tut.h>
+#include "lltut.h"
+#include "linden_common.h"
+#include "llsaleinfo.h"
+
+namespace tut
+{
+	struct llsaleinfo_tut
+	{
+	};
+	typedef test_group<llsaleinfo_tut> llsaleinfo_tut_t;
+	typedef llsaleinfo_tut_t::object llsaleinfo_test_t;
+	tut::llsaleinfo_tut_t tut_llsaleinfo_test("llsaleinfo");
+
+	template<> template<>
+	void llsaleinfo_test_t::test<1>()
+	{
+		//test case for getSaleType(), getSalePrice(), getCRC32() fn.
+		//test case for setSaleType(), setSalePrice() fn.
+
+		S32 sale_price = 10000;
+		LLSaleInfo llsaleinfo(LLSaleInfo::FS_COPY, sale_price);
+		char* sale= "copy";
+
+		LLSD llsd_obj1 = ll_create_sd_from_sale_info(llsaleinfo);
+		LLSaleInfo saleinfo1 = ll_sale_info_from_sd(llsd_obj1);
+		
+		ensure("1. The getSaleType() fn failed", LLSaleInfo::FS_COPY == llsaleinfo.getSaleType());
+		ensure("2. LLSaleInfo::isForSale() fn failed", TRUE == llsaleinfo.isForSale());
+		ensure("3. The getSalePrice() fn failed", sale_price == llsaleinfo.getSalePrice());
+		ensure("4. The getCRC32() fn failed", 235833404 == llsaleinfo.getCRC32());
+		ensure("5. LLSaleInfo::lookup(const char* name) fn failed", LLSaleInfo::FS_COPY == llsaleinfo.lookup(sale));
+		ensure_equals("6. ll_create_sd_from_sale_info() fn failed", llsaleinfo.getSalePrice(), saleinfo1.getSalePrice());
+		ensure_equals("7. ll_create_sd_from_sale_info() fn failed", llsaleinfo.getSaleType(), saleinfo1.getSaleType());
+
+		llsaleinfo.setSalePrice(10000000);
+		llsaleinfo.setSaleType(LLSaleInfo::FS_ORIGINAL);
+		sale = "cntn";
+		llsd_obj1 = ll_create_sd_from_sale_info(llsaleinfo);
+		saleinfo1 = ll_sale_info_from_sd(llsd_obj1);
+
+		ensure("8. The getSaleType() and setSaleType() fn failed", LLSaleInfo::FS_ORIGINAL == llsaleinfo.getSaleType());
+		ensure("9. LLSaleInfo::isForSale() fn failed", TRUE == llsaleinfo.isForSale());
+		ensure("10. The getSalePrice() fn failed", 10000000 == llsaleinfo.getSalePrice());
+		ensure("11. The getCRC32() fn failed", 127911702 == llsaleinfo.getCRC32());
+		ensure("12. LLSaleInfo::lookup(const char* name) fn failed", LLSaleInfo::FS_CONTENTS == llsaleinfo.lookup(sale));
+		ensure_equals("13. ll_create_sd_from_sale_info() fn failed", llsaleinfo.getSalePrice(), saleinfo1.getSalePrice());
+		ensure_equals("14. ll_create_sd_from_sale_info() fn failed", llsaleinfo.getSaleType(), saleinfo1.getSaleType());
+
+		llsaleinfo.setSalePrice(55000550);
+		llsaleinfo.setSaleType(LLSaleInfo::FS_CONTENTS);
+		sale = "orig";
+		llsd_obj1 = ll_create_sd_from_sale_info(llsaleinfo);
+		saleinfo1 = ll_sale_info_from_sd(llsd_obj1);
+
+		ensure("15. The getSaleType() and setSaleType() fn failed", LLSaleInfo::FS_CONTENTS == llsaleinfo.getSaleType());
+		ensure("16. LLSaleInfo::isForSale() fn failed", TRUE == llsaleinfo.isForSale());
+		ensure("17. The getSalePrice() fn failed", 55000550 == llsaleinfo.getSalePrice());
+		ensure("18. The getCRC32() fn failed", 408735656 == llsaleinfo.getCRC32());
+		ensure("19. LLSaleInfo::lookup(const char* name) fn failed", LLSaleInfo::FS_ORIGINAL == llsaleinfo.lookup(sale));
+		ensure_equals("20. ll_create_sd_from_sale_info() fn failed", llsaleinfo.getSalePrice(), saleinfo1.getSalePrice());
+		ensure_equals("21. ll_create_sd_from_sale_info() fn failed", llsaleinfo.getSaleType(), saleinfo1.getSaleType());
+
+		llsaleinfo.setSalePrice(-6432);
+		llsaleinfo.setSaleType(LLSaleInfo::FS_NOT);
+		sale = "not";
+		llsd_obj1 = ll_create_sd_from_sale_info(llsaleinfo);
+		saleinfo1 = ll_sale_info_from_sd(llsd_obj1);
+
+		ensure("22. The getSaleType() and setSaleType() fn failed", LLSaleInfo::FS_NOT == llsaleinfo.getSaleType());
+		ensure("23. LLSaleInfo::isForSale() fn failed", FALSE == llsaleinfo.isForSale());
+		ensure("24. The getSalePrice() fn failed", 0 == llsaleinfo.getSalePrice());
+		ensure("25. The getCRC32() fn failed", 0 == llsaleinfo.getCRC32());
+		ensure("26. LLSaleInfo::lookup(const char* name) fn failed", LLSaleInfo::FS_NOT == llsaleinfo.lookup(sale));
+		ensure_equals("27. ll_create_sd_from_sale_info() fn failed", llsaleinfo.getSalePrice(), saleinfo1.getSalePrice());
+		ensure_equals("28. ll_create_sd_from_sale_info() fn failed", llsaleinfo.getSaleType(), saleinfo1.getSaleType());
+	}
+
+	template<> template<>
+	void llsaleinfo_test_t::test<2>()
+	{
+
+		FILE* fp = fopen("linden_file.dat","w+");
+		if(!fp)
+		{
+			llerrs << "file could not be opened\n" << llendl;
+			return;
+		}
+			
+		S32 sale_price = 43500;
+		LLSaleInfo llsaleinfo(LLSaleInfo::FS_COPY, sale_price);
+		
+		llsaleinfo.exportFile(fp);
+		fclose(fp);
+
+		LLSaleInfo llsaleinfo1;
+		U32 perm_mask;
+		BOOL has_perm_mask;
+		fp = fopen("linden_file.dat","r");
+		
+		if(!fp)
+		{
+			llerrs << "file coudnt be opened\n" << llendl;
+			return;
+		}
+		
+		llsaleinfo1.importFile(fp, has_perm_mask, perm_mask);
+		fclose(fp);
+		
+		ensure("importFile() fn failed ", llsaleinfo.getSaleType() == llsaleinfo1.getSaleType() &&
+								     llsaleinfo.getSalePrice() == llsaleinfo1.getSalePrice());				
+	}
+
+	template<> template<>
+	void llsaleinfo_test_t::test<3>()
+	{
+		S32 sale_price = 525452;
+		LLSaleInfo llsaleinfo(LLSaleInfo::FS_ORIGINAL, sale_price);
+		
+		std::ostringstream ostream;
+		llsaleinfo.exportLegacyStream(ostream);
+		
+		std::istringstream istream(ostream.str());
+		LLSaleInfo llsaleinfo1;
+		U32 perm_mask = 0;
+		BOOL has_perm_mask = FALSE;
+		llsaleinfo1.importLegacyStream(istream, has_perm_mask, perm_mask);
+					
+		ensure("importLegacyStream() fn failed ", llsaleinfo.getSalePrice() == llsaleinfo1.getSalePrice() &&
+										       llsaleinfo.getSaleType() == llsaleinfo1.getSaleType());		
+	}
+
+	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
+	}
+
+	template<> template<>
+	void llsaleinfo_test_t::test<5>()
+	{	
+		S32 sale_price = 99000;
+		LLSaleInfo saleinfo(LLSaleInfo::FS_ORIGINAL, sale_price);
+		
+		LLSD sd_result = saleinfo.asLLSD();
+		
+		U32 perm_mask = 0 ;
+		BOOL has_perm_mask = FALSE;
+
+		LLSaleInfo saleinfo1;
+		saleinfo1.fromLLSD( sd_result, has_perm_mask, perm_mask);	
+
+		ensure_equals("asLLSD and fromLLSD failed", saleinfo.getSalePrice(), saleinfo1.getSalePrice());
+		ensure_equals("asLLSD and fromLLSD failed", saleinfo.getSaleType(), saleinfo1.getSaleType());
+	}
+
+	//static EForSale lookup(const char* name) fn test
+	template<> template<>
+	void llsaleinfo_test_t::test<6>()
+	{
+		S32 sale_price = 233223;
+		LLSaleInfo::EForSale ret_type = LLSaleInfo::lookup("orig");
+		
+		ensure_equals("lookup(const char* name) fn failed", ret_type, LLSaleInfo::FS_ORIGINAL);
+
+		LLSaleInfo saleinfo(LLSaleInfo::FS_COPY, sale_price);
+		const char* result = LLSaleInfo::lookup(LLSaleInfo::FS_COPY);
+		ensure("char* lookup(EForSale type) fn failed", 0 == strcmp("copy", result));
+	}
+
+	//void LLSaleInfo::accumulate(const LLSaleInfo& sale_info) fn test
+	template<> template<>
+	void llsaleinfo_test_t::test<7>()
+	{
+		S32 sale_price = 20;
+		LLSaleInfo saleinfo(LLSaleInfo::FS_COPY, sale_price);
+		LLSaleInfo saleinfo1(LLSaleInfo::FS_COPY, sale_price);
+		saleinfo1.accumulate(saleinfo);
+		ensure_equals("LLSaleInfo::accumulate(const LLSaleInfo& sale_info) fn failed", saleinfo1.getSalePrice(), 40);
+				
+	}
+
+	// test cases of bool operator==(const LLSaleInfo &rhs) fn
+	// test case of bool operator!=(const LLSaleInfo &rhs) fn
+	template<> template<>
+	void llsaleinfo_test_t::test<8>()
+	{
+		S32 sale_price = 55000;
+		LLSaleInfo saleinfo(LLSaleInfo::FS_ORIGINAL, sale_price);
+		LLSaleInfo saleinfoequal(LLSaleInfo::FS_ORIGINAL, sale_price);
+		LLSaleInfo saleinfonotequal(LLSaleInfo::FS_ORIGINAL, sale_price*2);
+		
+		ensure("operator == fn. failed", true == (saleinfo == saleinfoequal));
+		ensure("operator != fn. failed", true == (saleinfo != saleinfonotequal));
+	}			
+
+	template<> template<>
+	void llsaleinfo_test_t::test<9>()
+	{
+
+		//TBD: void LLSaleInfo::packMessage(LLMessageSystem* msg) const
+		//TBD: void LLSaleInfo::unpackMessage(LLMessageSystem* msg, const char* block)
+		//TBD: void LLSaleInfo::unpackMultiMessage(LLMessageSystem* msg, const char* block, S32 block_num)
+	}
+
+}
diff --git a/indra/test/llsdmessagebuilder_tut.cpp b/indra/test/llsdmessagebuilder_tut.cpp
index b153292abc..900de1f2dd 100755
--- a/indra/test/llsdmessagebuilder_tut.cpp
+++ b/indra/test/llsdmessagebuilder_tut.cpp
@@ -114,7 +114,7 @@ namespace tut
 	void LLSDMessageBuilderTestObject::test<7>()
 		 // F32
 	{
-	  F32 outValue, inValue = 121.44;
+	  F32 outValue, inValue = 121.44f;
 	  LLSDMessageBuilder builder = defaultBuilder();
 	  builder.addF32("var", inValue);
 	  LLSDMessageReader reader = setReader(builder);
diff --git a/indra/test/llsdmessagereader_tut.cpp b/indra/test/llsdmessagereader_tut.cpp
index 31810ae00e..60a4ea0f29 100755
--- a/indra/test/llsdmessagereader_tut.cpp
+++ b/indra/test/llsdmessagereader_tut.cpp
@@ -10,6 +10,7 @@
 #include <tut/tut.h>
 #include "lltut.h"
 
+#include "message.h"
 #include "llsdmessagereader.h"
 #include "llsdutil.h"
 
@@ -21,7 +22,7 @@ namespace tut
 									const std::string& expected_name)
 		{
 			LLSDMessageReader msg;
-			msg.setMessage(msg_name, msg_data);
+			msg.setMessage(gMessageStringTable.getString(msg_name.c_str()), msg_data);
 			ensure_equals("Ensure name", std::string(msg.getMessageName()), 
 						  expected_name);
 		}
@@ -169,7 +170,7 @@ namespace tut
 	void LLSDMessageReaderTestObject::test<9>()
 		// F32
 	{
-		F32 outValue, inValue = 121.44;
+		F32 outValue, inValue = 121.44f;
 		LLSDMessageReader msg = testType(inValue);
 		msg.getF32("block", "var", outValue);
 		ensure_equals("Ensure F32", outValue, inValue);
@@ -297,4 +298,3 @@ namespace tut
 		ensure_equals("Ensure Binary", outValue, inValue);
 	}
 }
-
diff --git a/indra/test/llsdtraits.h b/indra/test/llsdtraits.h
index 2e6a96a425..955a5b2036 100644
--- a/indra/test/llsdtraits.h
+++ b/indra/test/llsdtraits.h
@@ -1,3 +1,11 @@
+/**
+ * @file llsdtraits.h
+ * @brief Unit test helpers
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
 #ifndef LLSDTRAITS_H
 #define LLSDTRAITS_H
 
diff --git a/indra/test/llsdutil_tut.cpp b/indra/test/llsdutil_tut.cpp
new file mode 100644
index 0000000000..db476840bf
--- /dev/null
+++ b/indra/test/llsdutil_tut.cpp
@@ -0,0 +1,132 @@
+/**
+ * @file llsdutil_tut.cpp
+ * @author Adroit
+ * @date 2007-02
+ * @brief LLSD conversion routines test cases.
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+#include "lltut.h"
+#include "v3color.h"
+#include "v4math.h"
+#include "m4math.h"
+#include "llsdutil.h"
+
+
+namespace tut
+{
+	struct llsdutil_data
+	{
+	};
+	typedef test_group<llsdutil_data> llsdutil_test;;
+	typedef llsdutil_test::object llsdutil_object;
+	tut::llsdutil_test tutil("llsdutil");
+
+	template<> template<>
+	void llsdutil_object::test<1>()
+	{
+		LLSD sd;
+		U64 valueIn , valueOut;
+		valueIn = U64L(0xFEDCBA9876543210);
+		sd = ll_sd_from_U64(valueIn);
+		valueOut = ll_U64_from_sd(sd);
+		ensure_equals("U64 valueIn->sd->valueOut", valueIn, valueOut);
+	}
+
+	template<> template<>
+	void llsdutil_object::test<2>()
+	{
+		LLSD sd;
+		U32 valueIn, valueOut;
+		valueIn = 0x87654321;
+		sd = ll_sd_from_U32(valueIn);
+		valueOut = ll_U32_from_sd(sd);
+		ensure_equals("U32 valueIn->sd->valueOut", valueIn, valueOut);
+	}
+
+	template<> template<>
+	void llsdutil_object::test<3>()
+	{
+		U32 valueIn, valueOut;
+		valueIn = 0x87654321;
+		LLSD sd;
+		sd = ll_sd_from_ipaddr(valueIn);
+		valueOut = ll_ipaddr_from_sd(sd);
+		ensure_equals("valueIn->sd->valueOut", valueIn, valueOut);
+	}
+
+	template<> template<>
+	void llsdutil_object::test<4>()
+	{
+		LLSD sd;
+		LLVector3 vec1(-1.0, 2.0, -3.0);
+		sd = ll_sd_from_vector3(vec1); 
+		LLVector3 vec2 = ll_vector3_from_sd(sd);
+		ensure_equals("vector3 -> sd -> vector3: 1", vec1, vec2);
+
+		LLVector3 vec3(sd);
+		ensure_equals("vector3 -> sd -> vector3: 2", vec1, vec3);
+
+		sd.clear();
+		vec1.setVec(0., 0., 0.);
+		sd = ll_sd_from_vector3(vec1); 
+		vec2 = ll_vector3_from_sd(sd);
+		ensure_equals("vector3 -> sd -> vector3: 3", vec1, vec2);
+		sd.clear();
+	}
+
+	template<> template<>
+	void llsdutil_object::test<5>()
+	{
+		LLSD sd;
+		LLVector3d vec1((F64)(U64L(0xFEDCBA9876543210) << 2), -1., 0);
+		sd = ll_sd_from_vector3d(vec1); 
+		LLVector3d vec2 = ll_vector3d_from_sd(sd);
+		ensure_equals("vector3d -> sd -> vector3d: 1", vec1, vec2);
+		
+		LLVector3d vec3(sd); 
+		ensure_equals("vector3d -> sd -> vector3d : 2", vec1, vec3);
+	}
+
+	template<> template<>
+	void llsdutil_object::test<6>()
+	{
+		LLSD sd;
+		LLVector2 vec((F32) -3., (F32) 4.2);
+		sd = ll_sd_from_vector2(vec); 
+		LLVector2 vec1 = ll_vector2_from_sd(sd);
+		ensure_equals("vector2 -> sd -> vector2", vec, vec1);
+		
+		LLSD sd2 = ll_sd_from_vector2(vec1); 
+		ensure_equals("sd -> vector2 -> sd: 2", sd, sd2);
+	}
+
+	template<> template<>
+	void llsdutil_object::test<7>()
+	{
+		LLSD sd;
+		LLQuaternion quat((F32) 1., (F32) -0.98, (F32) 2.3, (F32) 0xffff);
+		sd = ll_sd_from_quaternion(quat); 
+		LLQuaternion quat1 = ll_quaternion_from_sd(sd);
+		ensure_equals("LLQuaternion -> sd -> LLQuaternion", quat, quat1);
+		
+		LLSD sd2 = ll_sd_from_quaternion(quat1); 
+		ensure_equals("sd -> LLQuaternion -> sd ", sd, sd2);
+	}
+
+	template<> template<>
+	void llsdutil_object::test<8>()
+	{
+		LLSD sd;
+		LLColor4 c(1.0f, 2.2f, 4.0f, 7.f);
+		sd = ll_sd_from_color4(c); 
+		LLColor4 c1 =ll_color4_from_sd(sd);
+		ensure_equals("LLColor4 -> sd -> LLColor4", c, c1);
+		
+		LLSD sd1 = ll_sd_from_color4(c1);
+		ensure_equals("sd -> LLColor4 -> sd", sd, sd1);
+	}
+}
diff --git a/indra/test/llstreamtools_tut.cpp b/indra/test/llstreamtools_tut.cpp
new file mode 100644
index 0000000000..17e5c7cc2c
--- /dev/null
+++ b/indra/test/llstreamtools_tut.cpp
@@ -0,0 +1,908 @@
+/**
+ * @file llstreamtools_tut.cpp
+ * @author Adroit
+ * @date February 2007
+ * @brief llstreamtools test cases.
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+ 
+#include <tut/tut.h>
+#include <fstream>
+#include "llstreamtools.h"
+#include "lltut.h"
+
+
+namespace tut
+{
+	struct streamtools_data
+	{
+	};
+	typedef test_group<streamtools_data> streamtools_test;
+	typedef streamtools_test::object streamtools_object;
+	tut::streamtools_test streamtools_testcase("streamtools");
+
+	//test cases for skip_whitespace()
+	template<> template<>
+	void streamtools_object::test<1>()
+	{
+		char arr[255];
+		std::string str;
+		std::string expected_result;
+		std::string actual_result;
+		std::istringstream is;
+
+		is.str(str = "");
+		ensure("skip_whitespace: empty string", (false == skip_whitespace(is)));
+
+		is.clear();
+		is.str(str = " SecondLife is a 3D World");
+		skip_whitespace(is);
+		is.get(arr, 255, '\0');
+		expected_result = "SecondLife is a 3D World";
+		ensure_equals("skip_whitespace: space", arr, expected_result);
+
+		is.clear();
+		is.str(str = "\t          \tSecondLife is a 3D World");
+		skip_whitespace(is);
+		is.get(arr, 255, '\0');
+		expected_result = "SecondLife is a 3D World";
+		ensure_equals("skip_whitespace: space and tabs", arr, expected_result);
+
+		is.clear();
+		is.str(str = "\t          \tSecondLife is a 3D World       ");
+		skip_whitespace(is);
+		is.get(arr, 255, '\0');
+		expected_result = "SecondLife is a 3D World       ";
+		ensure_equals("skip_whitespace: space at end", arr, expected_result);
+
+		is.clear();
+		is.str(str = "\t \r\nSecondLife is a 3D World");
+		skip_whitespace(is);
+		is.get(arr, 255, '\0');
+		expected_result = "\r\nSecondLife is a 3D World";
+		ensure_equals("skip_whitespace: space at end", arr, expected_result);
+	}
+
+	//testcases for skip_emptyspaces()
+	template<> template<>
+	void streamtools_object::test<2>()
+	{
+		char arr[255];
+		std::string str;
+		std::string expected_result;
+		std::string actual_result;
+		std::istringstream is;
+		bool ret;
+
+		is.clear();
+		is.str(str = "  \tSecondLife is a 3D World.\n");
+		skip_emptyspace(is);
+		is.get(arr, 255, '\0');
+		expected_result = "SecondLife is a 3D World.\n";
+		ensure_equals("skip_emptyspace: space and tabs", arr, expected_result);
+
+		is.clear();
+		is.str(str = "  \t\r\n    \r    SecondLife is a 3D World.\n");
+		skip_emptyspace(is);
+		is.get(arr, 255, '\0');
+		expected_result = "SecondLife is a 3D World.\n";
+		ensure_equals("skip_emptyspace: space, tabs, carriage return, newline", arr, expected_result);
+
+		is.clear();
+		is.str(str = "");
+		ret = skip_emptyspace(is);
+		is.get(arr, 255, '\0');
+		ensure("skip_emptyspace: empty string", ret == false);
+
+		is.clear();
+		is.str(str = "  \r\n  \t ");
+		ret = skip_emptyspace(is);
+		is.get(arr, 255, '\0');
+		ensure("skip_emptyspace: space newline empty", ret == false);
+	}
+
+	//testcases for skip_comments_and_emptyspace()
+	template<> template<>
+	void streamtools_object::test<3>()
+	{
+		char arr[255];
+		std::string str;
+		std::string expected_result;
+		std::string actual_result;
+		std::istringstream is;
+		bool ret;
+
+		is.clear();
+		is.str(str = "  \t\r\n    \r    SecondLife is a 3D World.\n");
+		skip_comments_and_emptyspace(is);
+		is.get(arr, 255, '\0');
+		expected_result = "SecondLife is a 3D World.\n";
+		ensure_equals("skip_comments_and_emptyspace: space, tabs, carriage return, newline", arr, expected_result);
+
+		is.clear();
+		is.str(str = "#    \r\n    SecondLife is a 3D World.");
+		skip_comments_and_emptyspace(is);
+		is.get(arr, 255, '\0');
+		expected_result = "SecondLife is a 3D World.";
+		ensure_equals("skip_comments_and_emptyspace: skip comment - 1", arr, expected_result);
+
+		is.clear();
+		is.str(str = "#    \r\n  #  SecondLife is a 3D World. ##");
+		skip_comments_and_emptyspace(is);
+		is.get(arr, 255, '\0');
+		expected_result = "";
+		ensure_equals("skip_comments_and_emptyspace: skip comment - 2", arr, expected_result);
+
+		is.clear();
+		is.str(str = " \r\n  SecondLife is a 3D World. ##");
+		skip_comments_and_emptyspace(is);
+		is.get(arr, 255, '\0');
+		expected_result = "SecondLife is a 3D World. ##";
+		ensure_equals("skip_comments_and_emptyspace: skip comment - 3", arr, expected_result);
+
+		is.clear();
+		is.str(str = "");
+		ret = skip_comments_and_emptyspace(is);
+		is.get(arr, 255, '\0');
+		ensure("skip_comments_and_emptyspace: empty string", ret == false);
+
+		is.clear();
+		is.str(str = "  \r\n  \t # SecondLife is a 3D World");
+		ret = skip_comments_and_emptyspace(is);
+		is.get(arr, 255, '\0');
+		ensure("skip_comments_and_emptyspace: space newline comment empty", ret == false);
+	}
+	
+	//testcases for skip_line()
+	template<> template<>
+	void streamtools_object::test<4>()
+	{
+		char arr[255];
+		std::string str;
+		std::string expected_result;
+		std::string actual_result;
+		std::istringstream is;
+		bool ret;
+
+		is.clear();
+		is.str(str = "SecondLife is a 3D World.\n\n It provides an opportunity to the site \nuser to perform real life activities in virtual world.");
+		skip_line(is);
+		is.get(arr, 255, '\0');
+		expected_result = "\n It provides an opportunity to the site \nuser to perform real life activities in virtual world.";
+		ensure_equals("skip_line: 1 newline", arr, expected_result);
+
+		is.clear();
+		is.str(expected_result);
+		skip_line(is);
+		is.get(arr, 255, '\0');
+		expected_result = " It provides an opportunity to the site \nuser to perform real life activities in virtual world.";
+		ensure_equals("skip_line: 2 newline", arr, expected_result);
+
+		is.clear();
+		is.str(expected_result);
+		skip_line(is);
+		is.get(arr, 255, '\0');
+		expected_result = "user to perform real life activities in virtual world.";
+		ensure_equals("skip_line: 3 newline", arr, expected_result);
+
+		is.clear();
+		is.str(str = "");
+		ret = skip_line(is);
+		ensure("skip_line: empty string", ret == false);
+	}
+
+	
+	// testcases for skip_to_next_word()
+	template<> template<>
+	void streamtools_object::test<5>()
+	{
+		char arr[255];
+		std::string str;
+		std::string expected_result;
+		std::string actual_result;
+		std::istringstream is;
+		bool ret;
+
+		is.clear();
+		is.str(str = "SecondLife is a 3D_World.\n\n It-provides an opportunity to the site \nuser to perform real life activities in virtual world.");
+		skip_to_next_word(is); // get past SecondLife
+		is.get(arr, 255, '\0');
+		expected_result = "is a 3D_World.\n\n It-provides an opportunity to the site \nuser to perform real life activities in virtual world.";
+		ensure_equals("skip_to_next_word: 1", arr, expected_result);
+
+		is.clear();
+		is.str(expected_result);
+		skip_to_next_word(is); // get past is
+		skip_to_next_word(is); // get past a
+		skip_to_next_word(is); // get past 3D_World.\n\n 
+		is.get(arr, 255, '\0');
+		expected_result = "It-provides an opportunity to the site \nuser to perform real life activities in virtual world.";
+		ensure_equals("skip_to_next_word: get past .\n\n 2", arr, expected_result);
+		
+		is.clear();
+		is.str(expected_result);
+		skip_to_next_word(is); // get past It- 
+		expected_result = "provides an opportunity to the site \nuser to perform real life activities in virtual world.";
+		is.get(arr, 255, '\0');
+		ensure_equals("skip_to_next_word: get past -", arr, expected_result);
+
+		is.clear();
+		is.str(str = "");
+		ret = skip_to_next_word(is);
+		ensure("skip_line: empty string", ret == false);
+
+		is.clear();
+		is.str(str = "                   \r\n\r\n");
+		ret = skip_to_next_word(is);
+		ensure("skip_line: space new lines", ret == false);
+	}
+
+
+	//testcases for skip_to_end_of_next_keyword()
+	template<> template<>
+	void streamtools_object::test<6>()
+	{
+		char arr[255];
+		std::string str;
+		std::string expected_result;
+		std::string actual_result;
+		std::istringstream is;
+		bool ret;
+
+		is.clear();
+		is.str(str = "FIRSTKEY followed by second delimiter\nSECONDKEY\t SecondValue followed by third delimiter   \nSECONDKEY\nFOURTHKEY FOURTHVALUEis a 3DWorld.");
+		ret = skip_to_end_of_next_keyword("FIRSTKEY", is); 
+		is.get(arr, 255, '\0');
+		expected_result = " followed by second delimiter\nSECONDKEY\t SecondValue followed by third delimiter   \nSECONDKEY\nFOURTHKEY FOURTHVALUEis a 3DWorld.";
+		ensure_equals("skip_to_end_of_next_keyword: 1", arr, expected_result);
+
+		is.clear();
+		is.str(expected_result);
+		ret = skip_to_end_of_next_keyword("SECONDKEY", is); 
+		is.get(arr, 255, '\0');
+		expected_result = "\t SecondValue followed by third delimiter   \nSECONDKEY\nFOURTHKEY FOURTHVALUEis a 3DWorld.";
+		ensure_equals("skip_to_end_of_next_keyword: 2", arr, expected_result);
+
+		is.clear();
+		is.str(expected_result);
+		ret = skip_to_end_of_next_keyword("SECONDKEY", is); 
+		is.get(arr, 255, '\0');
+		expected_result = "\nFOURTHKEY FOURTHVALUEis a 3DWorld.";
+		ensure_equals("skip_to_end_of_next_keyword: 3", arr, expected_result);
+
+		is.clear();
+		is.str(expected_result);
+		ret = skip_to_end_of_next_keyword("FOURTHKEY", is); 
+		is.get(arr, 255, '\0');
+		expected_result = " FOURTHVALUEis a 3DWorld.";
+		ensure_equals("skip_to_end_of_next_keyword: 4", arr, expected_result);
+
+		is.clear();
+		is.str(str = "{should be skipped as newline/space/tab does not follow but this one should be picked\n { Does it?\n");
+		ret = skip_to_end_of_next_keyword("{", is); 
+		is.get(arr, 255, '\0');
+		expected_result = " Does it?\n";
+		ensure_equals("skip_to_end_of_next_keyword: multiple delim matches on same line", arr, expected_result);
+
+		is.clear();
+		is.str(str = "Delim { could not be found at start");
+		ret = skip_to_end_of_next_keyword("{", is); 
+		ensure("skip_to_end_of_next_keyword: delim should not be present", ret == false);
+
+		is.clear();
+		is.str(str = "Empty Delim");
+		ret = skip_to_end_of_next_keyword("", is); 
+		ensure("skip_to_end_of_next_keyword: empty delim should not be valid", ret == false);
+
+		is.clear();
+		is.str(str = "");
+		ret = skip_to_end_of_next_keyword("}", is); 
+		ensure("skip_to_end_of_next_keyword: empty string", ret == false);
+	}
+
+	//testcases for get_word(std::string& output_string, std::istream& input_stream)
+	template<> template<>
+	void streamtools_object::test<7>()
+	{
+		std::string str;
+		std::string expected_result;
+		std::string actual_result;
+		std::istringstream is;
+		bool ret;
+
+		is.clear();
+		is.str(str = "  First Second \t \r  \n Third  Fourth-ShouldThisBePartOfFourth  Fifth\n");
+		actual_result = "";
+		ret = get_word(actual_result, is); 
+		expected_result = "First";
+		ensure_equals("get_word: 1", actual_result, expected_result);
+
+		actual_result = "";
+		ret = get_word(actual_result, is); 
+		expected_result = "Second";
+		ensure_equals("get_word: 2", actual_result, expected_result);
+
+		actual_result = "";
+		ret = get_word(actual_result, is); 
+		expected_result = "Third";
+		ensure_equals("get_word: 3", actual_result, expected_result);
+
+		// the current implementation of get_word seems inconsistent with
+		// skip_to_next_word. skip_to_next_word treats any character other
+		// than alhpa-numeric and '_' as a delimter, while get_word()
+		// treats only isspace() (i.e. space,  form-feed('\f'),  newline  ('\n'),  
+		// carriage  return ('\r'), horizontal tab ('\t'), and vertical tab ('\v')
+		// as delimiters 
+		actual_result = "";
+		ret = get_word(actual_result, is); // will copy Fourth-ShouldThisBePartOfFourth
+		expected_result = "Fourth-ShouldThisBePartOfFourth"; // as per current impl.
+		ensure_equals("get_word: 4", actual_result, expected_result);
+
+		actual_result = "";
+		ret = get_word(actual_result, is); // will copy Fifth
+		expected_result = "Fifth"; // as per current impl.
+		ensure_equals("get_word: 5", actual_result, expected_result);
+
+		is.clear();
+		is.str(str = "  \t \r  \n ");
+		actual_result = "";
+		ret = get_word(actual_result, is); 
+		ensure("get_word: empty all spaces, newline tabs", ret == false);
+
+		is.clear();
+		is.str(str = "");
+		actual_result = "";
+		ret = get_word(actual_result, is); 
+		ensure("get_word: empty string", ret == false);
+	}
+
+	// testcase for get_word and skip_to_next_word compatibility
+	template<> template<>
+	void streamtools_object::test<8>()
+	{
+		std::string str;
+		std::string expected_result;
+		std::string actual_result;
+		std::istringstream is;
+		bool ret;
+
+		is.clear();
+		is.str(str = "  First Second \t \r  \n Third  Fourth-ShouldThisBePartOfFourth  Fifth\n");
+		actual_result = "";
+		ret = get_word(actual_result, is); // First
+		actual_result = "";
+		ret = get_word(actual_result, is); // Second
+		actual_result = "";
+		ret = get_word(actual_result, is); // Third
+
+		// the current implementation of get_word seems inconsistent with
+		// skip_to_next_word. skip_to_next_word treats any character other
+		// than alhpa-numeric and '_' as a delimter, while get_word()
+		// treats only isspace() (i.e. space,  form-feed('\f'),  newline  ('\n'),  
+		// carriage  return ('\r'), horizontal tab ('\t'), and vertical tab ('\v')
+		// as delimiters 
+		actual_result = "";
+		ret = get_word(actual_result, is); // will copy Fourth-ShouldThisBePartOfFourth
+
+		actual_result = "";
+		ret = get_word(actual_result, is); // will copy Fifth
+
+		is.clear();
+		is.str(str = "  First Second \t \r  \n Third  Fourth_ShouldThisBePartOfFourth Fifth\n");
+		ret = skip_to_next_word(is);  // should now point to First
+		ret = skip_to_next_word(is);  // should now point to Second
+		ret = skip_to_next_word(is);  // should now point to Third
+		ret = skip_to_next_word(is);  // should now point to Fourth
+		ret = skip_to_next_word(is);  // should now point to ShouldThisBePartOfFourth
+		expected_result = "";
+		// will copy ShouldThisBePartOfFourth, the fifth word, 
+		// while using get_word above five times result in getting "Fifth"
+		ret = get_word(expected_result, is); 
+		ensure_equals("get_word: skip_to_next_word compatibility", actual_result, expected_result);
+	}
+
+	//testcases for get_word(std::string& output_string, std::istream& input_stream, int n)
+	template<> template<>
+	void streamtools_object::test<9>()
+	{
+		std::string str;
+		std::string expected_result;
+		std::string actual_result;
+		std::istringstream is;
+		bool ret;
+
+		is.clear();
+		is.str(str = "  First Second \t \r  \n Third  Fourth-ShouldThisBePartOfFourth  Fifth\n");
+		actual_result = "";
+		ret = get_word(actual_result, is, 255);
+		expected_result = "First";
+		ensure_equals("get_word: 1", actual_result, expected_result);
+
+		actual_result = "";
+		ret = get_word(actual_result, is, 4); 
+		expected_result = "Seco"; // should be cut short
+		ensure_equals("get_word: 2", actual_result, expected_result);
+
+		actual_result = "";
+		ret = get_word(actual_result, is, 255); 
+		expected_result = "nd"; // get remainder of Second
+		ensure_equals("get_word: 3", actual_result, expected_result);
+
+		actual_result = "";
+		ret = get_word(actual_result, is, 0); // 0 size string 
+		expected_result = ""; // get remainder of Second
+		ensure_equals("get_word: 0 sized output", actual_result, expected_result);
+
+		actual_result = "";
+		ret = get_word(actual_result, is, 255); 
+		expected_result = "Third"; 
+		ensure_equals("get_word: 4", actual_result, expected_result);
+
+		is.clear();
+		is.str(str = "  \t \r  \n ");
+		actual_result = "";
+		ret = get_word(actual_result, is, 255); 
+		ensure("get_word: empty all spaces, newline tabs", ret == false);
+
+		is.clear();
+		is.str(str = "");
+		actual_result = "";
+		ret = get_word(actual_result, is, 255); 
+		ensure("get_word: empty string", ret == false);
+	}
+	
+	//test cases for get_line(std::string& output_string, std::istream& input_stream)
+	template<> template<>
+	void streamtools_object::test<10>()
+	{
+		std::string str;
+		std::string expected_result;
+		std::string actual_result;
+		std::istringstream is;
+		bool ret;
+
+		is.clear();
+		is.str(str = "First Second \t \r\n Third  Fourth-ShouldThisBePartOfFourth  IsThisFifth\n");
+		actual_result = "";
+		ret = get_line(actual_result, is);
+		expected_result = "First Second \t \n";
+		ensure_equals("get_line: 1", actual_result, expected_result);
+
+		actual_result = "";
+		ret = get_line(actual_result, is);
+		expected_result = " Third  Fourth-ShouldThisBePartOfFourth  IsThisFifth\n";
+		ensure_equals("get_line: 2", actual_result, expected_result);
+
+		is.clear();
+		is.str(str = "\nFirst Line.\n\nSecond Line.\n");
+		actual_result = "";
+		ret = get_line(actual_result, is);
+		expected_result = "\n";
+		ensure_equals("get_line: First char as newline", actual_result, expected_result);
+
+		actual_result = "";
+		ret = get_line(actual_result, is);
+		expected_result = "First Line.\n";
+		ensure_equals("get_line: 3", actual_result, expected_result);
+
+		actual_result = "";
+		ret = get_line(actual_result, is);
+		expected_result = "\n";
+		ensure_equals("get_line: 4", actual_result, expected_result);
+
+		actual_result = "";
+		ret = get_line(actual_result, is);
+		expected_result = "Second Line.\n";
+		ensure_equals("get_line: 5", actual_result, expected_result);
+	}	
+
+	//test cases for get_line(std::string& output_string, std::istream& input_stream)
+	template<> template<>
+	void streamtools_object::test<11>()
+	{
+		std::string str;
+		std::string expected_result;
+		std::string actual_result;
+		std::istringstream is;
+		bool ret;
+
+		is.clear();
+		is.str(str = "One Line only with no newline");
+		actual_result = "";
+		ret = get_line(actual_result, is);
+		expected_result = "One Line only with no newline";
+		ensure_equals("get_line: No newline", actual_result, expected_result);
+		ensure_equals("return value is good state of stream", ret, is.good());
+	}
+
+	//test cases for get_line(std::string& output_string, std::istream& input_stream)
+	template<> template<>
+	void streamtools_object::test<12>()
+	{
+		skip_fail("get_line() incorrectly handles lone carriage return.");
+		std::string str;
+		std::string expected_result;
+		std::string actual_result;
+		std::istringstream is;
+		bool ret;
+
+		// need to be check if this test case is wrong or the implementation is wrong.
+		is.clear();
+		is.str(str = "Should not skip \r unless they are followed with newline .\r\n");
+		actual_result = "";
+		ret = get_line(actual_result, is);
+		expected_result = "Should not skip \r unless they are followed with newline .\n";
+		ensure_equals("get_line: carriage return skipped even though not followed by newline", actual_result, expected_result);
+	}
+
+	//test cases for get_line(std::string& output_string, std::istream& input_stream)
+	template<> template<>
+	void streamtools_object::test<13>()
+	{
+		std::string str;
+		std::string expected_result;
+		std::string actual_result;
+		std::istringstream is;
+		bool ret;
+
+		is.clear();
+		is.str(str = "\n");
+		actual_result = "";
+		ret = get_line(actual_result, is);
+		expected_result = "\n";
+		ensure_equals("get_line: Just newline", actual_result, expected_result);
+	}
+
+
+	//testcases for get_line(std::string& output_string, std::istream& input_stream, int n)
+	template<> template<>
+	void streamtools_object::test<14>()
+	{
+		std::string str;
+		std::string expected_result;
+		std::string actual_result;
+		std::istringstream is;
+		bool ret;
+
+		is.clear();
+		is.str(str = "First Line.\nSecond Line.\n");
+		actual_result = "";
+		ret = get_line(actual_result, is, 255);
+		expected_result = "First Line.\n";
+		ensure_equals("get_line: Basic Operation", actual_result, expected_result);
+
+		actual_result = "";
+		ret = get_line(actual_result, is, sizeof("Second")-1);
+		expected_result = "Second\n";
+		ensure_equals("get_line: Insufficient length 1", actual_result, expected_result);
+
+		actual_result = "";
+		ret = get_line(actual_result, is, 255);
+		expected_result = " Line.\n";
+		ensure_equals("get_line: Remainder after earlier insufficient length", actual_result, expected_result);
+
+		is.clear();
+		is.str(str = "One Line only with no newline with limited length");
+		actual_result = "";
+		ret = get_line(actual_result, is, sizeof("One Line only with no newline with limited length")-1);
+		expected_result = "One Line only with no newline with limited length\n";
+		ensure_equals("get_line: No newline with limited length", actual_result, expected_result);
+
+		is.clear();
+		is.str(str = "One Line only with no newline");
+		actual_result = "";
+		ret = get_line(actual_result, is, 255);
+		expected_result = "One Line only with no newline";
+		ensure_equals("get_line: No newline", actual_result, expected_result);
+	}
+
+	//testcases for get_line(std::string& output_string, std::istream& input_stream, int n)
+	template<> template<>
+	void streamtools_object::test<15>()
+	{
+		std::string str;
+		std::string expected_result;
+		std::string actual_result;
+		std::istringstream is;
+		bool ret;
+
+		is.clear();
+		is.str(str = "One Line only with no newline");
+		actual_result = "";
+		ret = get_line(actual_result, is, 255);
+		expected_result = "One Line only with no newline";
+		ensure_equals("get_line: No newline", actual_result, expected_result);
+		ensure_equals("return value is good state of stream", ret, is.good());
+	}
+
+	//testcases for remove_last_char()
+	template<> template<>
+	void streamtools_object::test<16>()
+	{
+		std::string str;
+		std::string expected_result;
+		bool ret;
+
+		str = "SecondLife is a 3D World";
+
+		ret = remove_last_char('d',str);
+		expected_result = "SecondLife is a 3D Worl";
+		ensure_equals("remove_last_char: should remove last char", str, expected_result);
+
+		str = "SecondLife is a 3D World";
+		ret = remove_last_char('W',str);
+		expected_result = "SecondLife is a 3D World";
+		ensure_equals("remove_last_char: should not remove as it is not last char", str, expected_result);
+		ensure("remove_last_char: should return false", ret == false);
+
+		str = "SecondLife is a 3D World\n";
+		ret = remove_last_char('\n',str);
+		expected_result = "SecondLife is a 3D World";
+		ensure_equals("remove_last_char: should remove last newline", str, expected_result);
+		ensure("remove_last_char: should remove newline and return true", ret == true);
+	}
+
+
+	//testcases for unescaped_string()
+	template<> template<>
+	void streamtools_object::test<17>()
+	{
+		std::string str;
+		std::string expected_result;
+
+		str = "SecondLife is a 3D world \\n";
+		unescape_string(str);
+		expected_result = "SecondLife is a 3D world \n";
+		ensure_equals("unescape_string: newline", str, expected_result);
+
+		str = "SecondLife is a 3D world \\\\t \\n";
+		unescape_string(str);
+		expected_result = "SecondLife is a 3D world \\t \n";
+		ensure_equals("unescape_string: backslash and newline", str, expected_result);
+
+		str = "SecondLife is a 3D world \\ ";
+		unescape_string(str);
+		expected_result = "SecondLife is a 3D world \\ ";
+		ensure_equals("unescape_string: insufficient to unescape", str, expected_result);
+
+		str = "SecondLife is a 3D world \\n \\n \\n \\\\\\n";
+		unescape_string(str);
+		expected_result = "SecondLife is a 3D world \n \n \n \\\n";
+		ensure_equals("unescape_string: multipel newline and backslash", str, expected_result);
+
+		str = "SecondLife is a 3D world \\t";
+		unescape_string(str);
+		expected_result = "SecondLife is a 3D world \\t";
+		ensure_equals("unescape_string: leaves tab as is", str, expected_result);
+
+		str = "\\n";
+		unescape_string(str);
+		expected_result = "\n";
+		ensure_equals("unescape_string: only a newline", str, expected_result);
+	}
+
+	//testcases for escape_string()
+	template<> template<>
+	void streamtools_object::test<18>()
+	{
+		std::string str;
+		std::string expected_result;
+
+		str = "SecondLife is a 3D world \n";
+		escape_string(str);
+		expected_result = "SecondLife is a 3D world \\n";
+		ensure_equals("escape_string: newline", str, expected_result);
+
+		str = "SecondLife is a 3D world \\t \n";
+		escape_string(str);
+		expected_result = "SecondLife is a 3D world \\\\t \\n";
+		ensure_equals("escape_string: backslash and newline", str, expected_result);
+
+		str = "SecondLife is a 3D world \n \n \n \\\n";
+		escape_string(str);
+		expected_result = "SecondLife is a 3D world \\n \\n \\n \\\\\\n";
+		ensure_equals("escape_string: multipel newline and backslash", str, expected_result);
+
+		str = "SecondLife is a 3D world \t";
+		escape_string(str);
+		expected_result = "SecondLife is a 3D world \t";
+		ensure_equals("unescape_string: leaves tab as is", str, expected_result);
+
+		str = "\n";
+		escape_string(str);
+		expected_result = "\\n";
+		ensure_equals("unescape_string: only a newline", str, expected_result);
+
+		// serialization/deserialization escape->unescape
+		str = "SecondLife is a 3D world \n \n \n \\\n";
+		escape_string(str);
+		unescape_string(str);
+		expected_result = "SecondLife is a 3D world \n \n \n \\\n";
+		ensure_equals("escape_string: should preserve with escape/unescape", str, expected_result);
+
+		// serialization/deserialization  unescape->escape
+		str = "SecondLife is a 3D world \\n \\n \\n \\\\";
+		unescape_string(str);
+		escape_string(str);
+		expected_result = "SecondLife is a 3D world \\n \\n \\n \\\\";
+		ensure_equals("escape_string: should preserve with unescape/escape", str, expected_result);
+	}
+
+	// testcases for replace_newlines_with_whitespace()
+	template<> template<>
+	void streamtools_object::test<19>()
+	{
+		std::string str;
+		std::string expected_result;
+
+		str = "SecondLife is a 3D \n\nworld\n";
+		replace_newlines_with_whitespace(str);
+		expected_result = "SecondLife is a 3D   world ";
+		ensure_equals("replace_newlines_with_whitespace: replace all newline", str, expected_result);
+
+		str = "\nSecondLife is a 3D world\n";
+		replace_newlines_with_whitespace(str);
+		expected_result = " SecondLife is a 3D world ";
+		ensure_equals("replace_newlines_with_whitespace: begin and newline", str, expected_result);
+
+		str = "SecondLife is a 3D world\r\t";
+		replace_newlines_with_whitespace(str);
+		expected_result = "SecondLife is a 3D world\r\t";
+		ensure_equals("replace_newlines_with_whitespace: should only replace newline", str, expected_result);
+
+		str = "";
+		replace_newlines_with_whitespace(str);
+		expected_result = "";
+		ensure_equals("replace_newlines_with_whitespace: empty string", str, expected_result);
+	}
+
+	//testcases for remove_double_quotes()
+	template<> template<>
+	void streamtools_object::test<20>()
+	{
+		std::string str;
+		std::string expected_result;
+
+		str = "SecondLife is a \"\"3D world";
+		remove_double_quotes(str);
+		expected_result = "SecondLife is a 3D world";
+		ensure_equals("remove_double_quotes: replace empty doube quotes", str, expected_result);
+
+		str = "SecondLife is a \"3D world";
+		remove_double_quotes(str);
+		expected_result = "SecondLife is a 3D world";
+		ensure_equals("remove_double_quotes: keep as is it matching quote not found", str, expected_result);
+	}
+
+	// testcases for get_brace_count()
+	template<> template<>
+	void streamtools_object::test<21>()
+	{
+		skip_fail("get_brace_count() has bugs.");
+
+		std::string str;
+		std::string expected_result;
+		int count;
+
+		str = "  {  ";
+		count = get_brace_count(str);
+		ensure("get_brace_count: 1 for {", count == 1);
+
+		str = "\t}\t\t   \n";
+		count = get_brace_count(str);
+		ensure("get_brace_count: 1 for {", count == -1);
+
+		str = "\t\t\t   \n";
+		count = get_brace_count(str);
+		ensure("get_brace_count: 0 for no braces", count == 0);
+
+		str = "{ Remaining line not empty\n";
+		count = get_brace_count(str);
+		ensure("get_brace_count: 0 for remainign line not empty", count == 0);
+
+		/* shouldn't this return 1? */
+		str = "{ /*Remaining line in comment*/\n";
+		count = get_brace_count(str);
+		ensure("get_brace_count: 1 for { with remaining line in comment", count == 1);
+
+		/* shouldn't this return -1? */
+		str = "  } //Remaining line in comment  \n";
+		count = get_brace_count(str);
+		ensure("get_brace_count: -1 for } with remaining line in comment", count == -1);
+	}
+
+	//testcases for get_keyword_and_value()
+	template<> template<>
+	void streamtools_object::test<22>()
+	{
+		std::string s = "SecondLife is a 3D World";
+		std::string keyword;
+		std::string value;
+		get_keyword_and_value(keyword, value, s);
+		ensure("get_keyword_and_value: Unable to get Keyword and Value", ((keyword == "SecondLife") && (value == "is a 3D World")));
+
+		s = "SecondLife";
+		get_keyword_and_value(keyword, value, s);
+		ensure("get_keyword_and_value: value should be empty", ((keyword == "SecondLife") && (value == "")));
+
+		s = "SecondLife \t  is cool!     \n";
+		get_keyword_and_value(keyword, value, s);
+		ensure("get_keyword_and_value: remove space before value but not after", ((keyword == "SecondLife") && (value == "is cool!     ")));
+	}
+
+	//testcases for get_keyword_and_value()
+	template<> template<>
+	void streamtools_object::test<23>()
+	{
+		skip_fail("get_keyword_and_value() has bugs.");
+
+		std::string s;
+		std::string keyword = "SOME PRIOR KEYWORD";
+		std::string value = "SOME PRIOR VALUE";
+
+		s = "SecondLife\n";
+		get_keyword_and_value(keyword, value, s);
+		ensure("get_keyword_and_value: terminated with newline. value should be empty", ((keyword == "SecondLife") && (value == "")));
+	}
+
+	//testcases for get_keyword_and_value()
+	template<> template<>
+	void streamtools_object::test<24>()
+	{
+		skip_fail("get_keyword_and_value() has bugs.");
+
+		std::string s;
+		std::string keyword = "SOME PRIOR KEYWORD";
+		std::string value = "SOME PRIOR VALUE";
+
+		s = "";
+		get_keyword_and_value(keyword, value, s);
+		ensure("get_keyword_and_value: empty string. keyword value should empty", ((keyword == "") && (value == "")));
+	}
+
+	//testcase for fullread()
+	template<> template<>
+	void streamtools_object::test<25>()
+	{
+		std::string str = "First Line.\nSecond Line\n";
+		std::istringstream is(str);
+		char buf[255] = {0};
+		
+		fullread(is, buf, 255);
+		ensure_memory_matches("fullread: read with newlines", (void*) buf,  str.size()-1, (void*) str.c_str(), str.size()-1);
+
+		is.clear();
+		is.str(str = "First Line.\nSecond Line\n");
+		memset(buf, 0, 255);
+		
+		char expected_string[] = "First Line.\nSecond";
+		int len = sizeof(expected_string)-1;
+		fullread(is, buf, len);
+		ensure_memory_matches("fullread: read with newlines", (void*) buf, len, (void*) &expected_string, len);
+	}
+
+
+//   testcases for operator >>
+
+	template<> template<>
+	void streamtools_object::test<26>()
+	{
+		char arr[255];
+		std::string str;
+		std::string toCheck = "SecondLife" ;
+		std::string expected_result;
+		std::istringstream stream("SecondLife is a 3D World");
+		stream >> toCheck.c_str();
+		stream.get(arr, 255, '\0');
+		expected_result = " is a 3D World"; 
+		ensure_equals("istream << operator", arr, expected_result);
+
+		stream.clear();
+		stream.str(str = "SecondLife is a 3D World");
+		toCheck = "is";
+		stream >> toCheck.c_str();
+		ensure("istream << operator should have failed", stream.good() == false);
+	}
+}
diff --git a/indra/test/lltemplatemessagebuilder_tut.cpp b/indra/test/lltemplatemessagebuilder_tut.cpp
new file mode 100644
index 0000000000..67ca9320ba
--- /dev/null
+++ b/indra/test/lltemplatemessagebuilder_tut.cpp
@@ -0,0 +1,944 @@
+/**
+ * @file lltemplatemessagebuilder_tut.cpp
+ * @date 2007-04
+ * @brief Tests for building messages.
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include <tut/tut.h>
+#include "lltut.h"
+
+#include "llapr.h"
+#include "llmessagetemplate.h"
+#include "llquaternion.h"
+#include "lltemplatemessagebuilder.h"
+#include "lltemplatemessagereader.h"
+#include "llversion.h"
+#include "message_prehash.h"
+#include "u64.h"
+#include "v3dmath.h"
+#include "v3math.h"
+#include "v4math.h"
+
+namespace tut
+{	
+	static LLTemplateMessageBuilder::message_template_name_map_t nameMap;
+	static LLTemplateMessageReader::message_template_number_map_t numberMap;
+
+	struct LLTemplateMessageBuilderTestData 
+	{
+		static LLMessageTemplate defaultTemplate()
+		{
+			static bool init = false;
+			if(! init)
+			{
+				ll_init_apr();
+				start_messaging_system("notafile", 13035,
+									   LL_VERSION_MAJOR,
+									   LL_VERSION_MINOR,        
+									   LL_VERSION_PATCH,        
+									   FALSE,        
+									   "notasharedsecret");
+				init_prehash_data();
+				init = true;
+			}
+			return LLMessageTemplate(_PREHASH_TestMessage, 1, MFT_HIGH);
+		}
+
+		static LLMessageBlock* defaultBlock(const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
+		{
+			return createBlock(_PREHASH_Test0, type, size, block);
+		}
+
+		static LLMessageBlock* createBlock(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);
+			}
+			return result;
+		}
+
+		static LLTemplateMessageBuilder* defaultBuilder(LLMessageTemplate& messageTemplate, char* name = _PREHASH_Test0)
+		{
+			nameMap[_PREHASH_TestMessage] = &messageTemplate;
+			LLTemplateMessageBuilder* builder = new LLTemplateMessageBuilder(nameMap);
+			builder->newMessage(_PREHASH_TestMessage);
+			builder->nextBlock(name);
+			return builder;
+		}
+
+		/** Takes ownership of builder */
+		static LLTemplateMessageReader* setReader(
+			LLMessageTemplate& messageTemplate,
+			LLTemplateMessageBuilder* builder,
+			U8 offset = 0)
+		{
+			numberMap[1] = &messageTemplate;
+			const U32 bufferSize = 1024;
+			U8 buffer[bufferSize];
+			// zero out the packet ID field
+			memset(buffer, 0, LL_PACKET_ID_SIZE);
+			U32 builtSize = builder->buildMessage(buffer, bufferSize, offset);
+			delete builder;
+			LLTemplateMessageReader* reader = new LLTemplateMessageReader(numberMap);
+			reader->validateMessage(buffer, builtSize, LLHost());
+			reader->readMessage(buffer, LLHost());
+			return reader;
+		}
+
+	};
+	
+	typedef test_group<LLTemplateMessageBuilderTestData>	LLTemplateMessageBuilderTestGroup;
+	typedef LLTemplateMessageBuilderTestGroup::object		LLTemplateMessageBuilderTestObject;
+	LLTemplateMessageBuilderTestGroup templateMessageBuilderTestGroup("LLTemplateMessageBuilder");
+	
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<1>()
+		// construction and test of undefined
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock());
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		delete reader;
+	}
+	
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<2>()
+		 // BOOL
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_BOOL, 1));
+		BOOL outValue, inValue = TRUE;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addBOOL(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getBOOL(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure BOOL", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<3>()
+		 // U8
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_U8, 1));
+		U8 outValue, inValue = 2;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addU8(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getU8(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure U8", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<4>()
+		 // S16
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_S16, 2));
+		S16 outValue, inValue = 90;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addS16(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getS16(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure S16", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<5>()
+		 // U16
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_U16, 2));
+		U16 outValue, inValue = 3;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addU16(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getU16(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure U16", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<6>()
+		 // S32
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_S32, 4));
+		S32 outValue, inValue = 44;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addS32(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getS32(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure S32", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<7>()
+		 // F32
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_F32, 4));
+		F32 outValue, inValue = 121.44f;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addF32(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getF32(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure F32", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<8>()
+		 // U32
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_U32, 4));
+		U32 outValue, inValue = 88;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addU32(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure U32", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<9>()
+		 // U64
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_U64, 8));
+		U64 outValue, inValue = 121;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addU64(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getU64(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure U64", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<10>()
+		 // F64
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_F64, 8));
+		F64 outValue, inValue = 3232143.33;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addF64(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getF64(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure F64", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<11>()
+		 // Vector3
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_LLVector3, 12));
+		LLVector3 outValue, inValue = LLVector3(1,2,3);
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addVector3(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getVector3(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure LLVector3", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<12>()
+		 // Vector4
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_LLVector4, 16));
+		LLVector4 outValue, inValue = LLVector4(1,2,3,4);
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addVector4(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getVector4(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure LLVector4", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<13>()
+		 // Vector3d
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_LLVector3d, 24));
+		LLVector3d outValue, inValue = LLVector3d(1,2,3);
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addVector3d(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getVector3d(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure LLVector3d", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<14>()
+		 // Quaternion
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_LLQuaternion, 12));
+		LLQuaternion outValue, inValue = LLQuaternion(1,2,3,0);
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addQuat(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getQuat(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure LLQuaternion", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<15>()
+		 // UUID
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_LLUUID, 16));
+		LLUUID outValue, inValue;
+		inValue.generate();
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addUUID(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getUUID(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure UUID", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<16>()
+		 // IPAddr
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_IP_ADDR, 4));
+		U32 outValue, inValue = 12344556;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addIPAddr(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getIPAddr(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure IPAddr", inValue, outValue);
+		delete reader;
+	}
+
+	 template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<17>()
+		 // IPPort
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_IP_PORT, 2));
+		U16 outValue, inValue = 80;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addIPPort(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getIPPort(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure IPPort", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<18>()
+		// String
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_VARIABLE, 1));
+		std::string outValue, inValue = "testing";
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addString(_PREHASH_Test0, inValue.c_str());
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		char buffer[MAX_STRING];
+		reader->getString(_PREHASH_Test0, _PREHASH_Test0, MAX_STRING, buffer);
+		outValue = buffer;
+		ensure_equals("Ensure String", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<19>()
+		// block name !-> binary order
+	{
+		U8 buffer1[MAX_BUFFER_SIZE];
+		memset(buffer1, 0, MAX_BUFFER_SIZE);
+		U8 buffer2[MAX_BUFFER_SIZE];
+		memset(buffer2, 0, MAX_BUFFER_SIZE);
+		U32 bufferSize1, bufferSize2;
+
+		// 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));
+
+		// build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, _PREHASH_Test0);
+		builder->addU32(_PREHASH_Test0, 0xaaaa);
+		builder->nextBlock(_PREHASH_Test1);
+		builder->addU32(_PREHASH_Test0, 0xbbbb);
+		bufferSize1 = builder->buildMessage(buffer1, MAX_BUFFER_SIZE, 0);
+		delete builder;
+
+		// 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));
+
+		// build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
+		builder = defaultBuilder(messageTemplate, _PREHASH_Test1);
+		builder->addU32(_PREHASH_Test0, 0xaaaa);
+		builder->nextBlock(_PREHASH_Test0);
+		builder->addU32(_PREHASH_Test0, 0xbbbb);
+		bufferSize2 = builder->buildMessage(buffer2, MAX_BUFFER_SIZE, 0);
+		delete builder;
+
+		ensure_equals("Ensure Buffer Sizes Equal", bufferSize1, bufferSize2);
+		ensure_equals("Ensure Buffer Contents Equal", memcmp(buffer1, buffer2, bufferSize1), 0);
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<20>()
+		// block build order !-> binary order
+	{
+		U8 buffer1[MAX_BUFFER_SIZE];
+		memset(buffer1, 0, MAX_BUFFER_SIZE);
+		U8 buffer2[MAX_BUFFER_SIZE];
+		memset(buffer2, 0, MAX_BUFFER_SIZE);
+		U32 bufferSize1, bufferSize2;
+
+		// 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));
+
+		// build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, _PREHASH_Test0);
+		builder->addU32(_PREHASH_Test0, 0xaaaa);
+		builder->nextBlock(_PREHASH_Test1);
+		builder->addU32(_PREHASH_Test0, 0xbbbb);
+		bufferSize1 = builder->buildMessage(buffer1, MAX_BUFFER_SIZE, 0);
+		delete builder;
+
+		// build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
+		builder = defaultBuilder(messageTemplate, _PREHASH_Test1);
+		builder->addU32(_PREHASH_Test0, 0xbbbb);
+		builder->nextBlock(_PREHASH_Test0);
+		builder->addU32(_PREHASH_Test0, 0xaaaa);
+		bufferSize2 = builder->buildMessage(buffer2, MAX_BUFFER_SIZE, 0);
+		delete builder;
+
+		ensure_equals("Ensure Buffer Sizes Equal", bufferSize1, bufferSize2);
+		ensure_equals("Ensure Buffer Contents Equal", memcmp(buffer1, buffer2, bufferSize1), 0);
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<21>()
+		// block appended in declaration -> data appended in binary
+	{
+		U8 buffer1[MAX_BUFFER_SIZE];
+		memset(buffer1, 0, MAX_BUFFER_SIZE);
+		U8 buffer2[MAX_BUFFER_SIZE];
+		memset(buffer2, 0, MAX_BUFFER_SIZE);
+		U32 bufferSize1, bufferSize2;
+
+		// Build template: Test0 only
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4, MBT_SINGLE));
+
+		// Build message
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, _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));
+
+		// Build message
+		builder = defaultBuilder(messageTemplate, _PREHASH_Test0);
+		builder->addU32(_PREHASH_Test0, 0xaaaa);
+		builder->nextBlock(_PREHASH_Test1);
+		builder->addU32(_PREHASH_Test0, 0xbbbb);
+		bufferSize2 = builder->buildMessage(buffer2, MAX_BUFFER_SIZE, 0);
+		delete builder;
+
+		ensure_not_equals("Ensure Buffer Sizes Not Equal", bufferSize1, bufferSize2);
+		ensure_equals("Ensure Buffer Prefix Equal", memcmp(buffer1, buffer2, bufferSize1), 0);
+		ensure_not_equals("Ensure Buffer Contents Not Equal", memcmp(buffer1, buffer2, bufferSize2), 0);
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<22>()
+		// repeated penultimate block (crashes when data in LLDynamicArrayIndexed)
+	{
+		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));
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addU32(_PREHASH_Test0, inTest00);
+		builder->nextBlock(_PREHASH_Test0);
+		builder->addU32(_PREHASH_Test0, inTest01);
+		builder->nextBlock(_PREHASH_Test1);
+		builder->addU32(_PREHASH_Test0, inTest1);
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+		reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outTest00, 0);
+		reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outTest01, 1);
+		reader->getU32(_PREHASH_Test1, _PREHASH_Test0, outTest1);
+		ensure_equals("Ensure Test0[0]", inTest00, outTest00);
+		ensure_equals("Ensure Test0[1]", inTest01, outTest01);
+		ensure_equals("Ensure Test1", inTest1, outTest1);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<23>()
+		// variable repeated block name never accessed
+	{
+		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));
+
+		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);
+		ensure_equals("Ensure block count", blockCount, 0);
+		ensure_equals("Ensure Test0", inTest, outTest);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<24>()
+		// forwarding message
+	{
+		// build template
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4));
+
+		// build message
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addU32(_PREHASH_Test0, 42);
+
+		// read message
+		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+
+		// forward message
+		builder = defaultBuilder(messageTemplate);
+		builder->newMessage(_PREHASH_TestMessage);
+		reader->copyToBuilder(*builder);
+		U8 buffer[MAX_BUFFER_SIZE];
+		builder->buildMessage(buffer, MAX_BUFFER_SIZE, 0);
+
+		delete builder;
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<25>()
+		// non-zero offset with undefined
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock());
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 10);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<26>()
+		 // non-zero offset with BOOL
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_BOOL, 1));
+		BOOL outValue, inValue = TRUE;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addBOOL(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 1);
+		reader->getBOOL(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure BOOL", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<27>()
+		 // non-zero offset with U8
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_U8, 1));
+		U8 outValue, inValue = 2;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addU8(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 255);
+		reader->getU8(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure U8", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<28>()
+		 // non-zero offset with S16
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_S16, 2));
+		S16 outValue, inValue = 90;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addS16(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 2);
+		reader->getS16(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure S16", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<29>()
+		 // non-zero offset with U16
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_U16, 2));
+		U16 outValue, inValue = 3;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addU16(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 4);
+		reader->getU16(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure U16", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<30>()
+		 // non-zero offset with S32
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_S32, 4));
+		S32 outValue, inValue = 44;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addS32(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 4);
+		reader->getS32(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure S32", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<31>()
+		 // non-zero offset with F32
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_F32, 4));
+		F32 outValue, inValue = 121.44f;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addF32(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 16);
+		reader->getF32(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure F32", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<32>()
+		 // non-zero offset with U32
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_U32, 4));
+		U32 outValue, inValue = 88;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addU32(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 127);
+		reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure U32", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<33>()
+		 // non-zero offset with U64
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_U64, 8));
+		U64 outValue, inValue = 121;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addU64(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 32);
+		reader->getU64(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure U64", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<34>()
+		 // non-zero offset with F64
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_F64, 8));
+		F64 outValue, inValue = 3232143.33;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addF64(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 128);
+		reader->getF64(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure F64", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<35>()
+		 // non-zero offset with Vector3
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_LLVector3, 12));
+		LLVector3 outValue, inValue = LLVector3(1,2,3);
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addVector3(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 63);
+		reader->getVector3(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure LLVector3", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<36>()
+		 // non-zero offset with Vector4
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_LLVector4, 16));
+		LLVector4 outValue, inValue = LLVector4(1,2,3,4);
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addVector4(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 64);
+		reader->getVector4(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure LLVector4", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<37>()
+		 // non-zero offset with Vector3d
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_LLVector3d, 24));
+		LLVector3d outValue, inValue = LLVector3d(1,2,3);
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addVector3d(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 64);
+		reader->getVector3d(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure LLVector3d", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<38>()
+		 // non-zero offset with Quaternion
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_LLQuaternion, 12));
+		LLQuaternion outValue, inValue = LLQuaternion(1,2,3,0);
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addQuat(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 12);
+		reader->getQuat(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure LLQuaternion", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<39>()
+		 // non-zero offset with UUID
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_LLUUID, 16));
+		LLUUID outValue, inValue;
+		inValue.generate();
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addUUID(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 31);
+		reader->getUUID(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure UUID", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<40>()
+		 // non-zero offset with IPAddr
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_IP_ADDR, 4));
+		U32 outValue, inValue = 12344556;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addIPAddr(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 32);
+		reader->getIPAddr(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure IPAddr", inValue, outValue);
+		delete reader;
+	}
+
+	 template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<41>()
+		 // non-zero offset with IPPort
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_IP_PORT, 2));
+		U16 outValue, inValue = 80;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addIPPort(_PREHASH_Test0, inValue);
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 6);
+		reader->getIPPort(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		ensure_equals("Ensure IPPort", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<42>()
+		// non-zero offset with String
+	{
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_VARIABLE, 1));
+		std::string outValue, inValue = "testing";
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addString(_PREHASH_Test0, inValue.c_str());
+		LLTemplateMessageReader* reader = setReader(
+			messageTemplate, builder, 255);
+		char buffer[MAX_STRING];
+		reader->getString(_PREHASH_Test0, _PREHASH_Test0, MAX_STRING, buffer);
+		outValue = buffer;
+		ensure_equals("Ensure String", inValue, outValue);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<43>()
+		// read past end of message -> default values (forward compatibility)
+	{
+		// build message with single block
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_U32, 4, MBT_SINGLE));
+		U32 outValue, outValue2, inValue = 0xbbbbbbbb;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addU32(_PREHASH_Test0, inValue);
+		const U32 bufferSize = 1024;
+		U8 buffer[bufferSize];
+		memset(buffer, 0xaa, bufferSize);
+		memset(buffer, 0, LL_PACKET_ID_SIZE);
+		U32 builtSize = builder->buildMessage(buffer, bufferSize, 0);
+		delete builder;
+
+		// add block to reader template
+		messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4, MBT_SINGLE));
+
+		// read message value and default value
+		numberMap[1] = &messageTemplate;
+		LLTemplateMessageReader* reader = 
+			new LLTemplateMessageReader(numberMap);
+		reader->validateMessage(buffer, builtSize, LLHost());
+		reader->readMessage(buffer, LLHost());
+		reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		reader->getU32(_PREHASH_Test1, _PREHASH_Test0, outValue2);
+		ensure_equals("Ensure present value ", outValue, inValue);
+		ensure_equals("Ensure default value ", outValue2, 0);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<44>()
+		// read variable block past end of message -> 0 repeats
+	{
+		// build message with single block
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_U32, 4, MBT_SINGLE));
+		U32 outValue, outValue2, inValue = 0xbbbbbbbb;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addU32(_PREHASH_Test0, inValue);
+		const U32 bufferSize = 1024;
+		U8 buffer[bufferSize];
+		memset(buffer, 0xaa, bufferSize);
+		memset(buffer, 0, LL_PACKET_ID_SIZE);
+		U32 builtSize = builder->buildMessage(buffer, bufferSize, 0);
+		delete builder;
+
+		// add variable block to reader template
+		messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4));
+
+		// read message value and check block repeat count
+		numberMap[1] = &messageTemplate;
+		LLTemplateMessageReader* reader = 
+			new LLTemplateMessageReader(numberMap);
+		reader->validateMessage(buffer, builtSize, LLHost());
+		reader->readMessage(buffer, LLHost());
+		reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		outValue2 = reader->getNumberOfBlocks(_PREHASH_Test1);
+		ensure_equals("Ensure present value ", outValue, inValue);
+		ensure_equals("Ensure 0 repeats ", outValue2, 0);
+		delete reader;
+	}
+
+	template<> template<>
+	void LLTemplateMessageBuilderTestObject::test<45>()
+		// read variable length data past end of message -> 0 length
+	{
+		// build message with single block
+		LLMessageTemplate messageTemplate = defaultTemplate();
+		messageTemplate.addBlock(defaultBlock(MVT_U32, 4, MBT_SINGLE));
+		U32 outValue, outValue2, inValue = 0xbbbbbbbb;
+		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+		builder->addU32(_PREHASH_Test0, inValue);
+		const U32 bufferSize = 1024;
+		U8 buffer[bufferSize];
+		memset(buffer, 0xaa, bufferSize);
+		memset(buffer, 0, LL_PACKET_ID_SIZE);
+		U32 builtSize = builder->buildMessage(buffer, bufferSize, 0);
+		delete builder;
+
+		// add variable block to reader template
+		messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_VARIABLE, 4, 
+											 MBT_SINGLE));
+
+		// read message value and default string
+		numberMap[1] = &messageTemplate;
+		LLTemplateMessageReader* reader = 
+			new LLTemplateMessageReader(numberMap);
+		reader->validateMessage(buffer, builtSize, LLHost());
+		reader->readMessage(buffer, LLHost());
+		reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		char outBuffer[bufferSize];
+		memset(buffer, 0xcc, bufferSize);
+		reader->getString(_PREHASH_Test1, _PREHASH_Test0, bufferSize, 
+						  outBuffer);
+		outValue2 = reader->getNumberOfBlocks(_PREHASH_Test1);
+		ensure_equals("Ensure present value ", outValue, inValue);
+		ensure_equals("Ensure unchanged buffer ", strlen(outBuffer), 0);
+		delete reader;
+	}
+}
+
diff --git a/indra/test/lltut.h b/indra/test/lltut.h
index 6f1fee2b2f..58de355453 100644
--- a/indra/test/lltut.h
+++ b/indra/test/lltut.h
@@ -8,12 +8,6 @@
  * $License$
  */
 
-/** 
- *
- * THOROUGH_DESCRIPTION
- *
- */
-
 #ifndef LL_LLTUT_H
 #define LL_LLTUT_H
 
diff --git a/indra/test/lluuidhashmap_tut.cpp b/indra/test/lluuidhashmap_tut.cpp
new file mode 100644
index 0000000000..c9736d4d4b
--- /dev/null
+++ b/indra/test/lluuidhashmap_tut.cpp
@@ -0,0 +1,339 @@
+/** 
+ * @file lluuidhashmap_tut.cpp
+ * @author Adroit
+ * @date 2007-02
+ * @brief Test cases for LLUUIDHashMap
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include <tut/tut.h>
+#include "linden_common.h"
+#include "lluuidhashmap.h"
+#include "llsdserialize.h"
+
+namespace tut
+{
+	class UUIDTableEntry
+	{
+	public:
+		UUIDTableEntry()
+		{
+			mID.setNull();
+			mValue = 0;
+		}
+		
+		UUIDTableEntry(const LLUUID& id, U32 value)
+		{
+			mID = id;
+			mValue = value;
+		}
+
+		~UUIDTableEntry(){};
+
+		static BOOL uuidEq(const LLUUID &uuid, const UUIDTableEntry &id_pair)
+		{
+			if (uuid == id_pair.mID)
+			{
+				return TRUE;
+			}
+			return FALSE;
+		}
+
+		const LLUUID& getID() { return mID; }
+		const U32& getValue() { return mValue; }
+
+	protected:
+		LLUUID	mID;
+		U32  mValue;
+	};
+
+	struct hashmap_test
+	{
+	};
+
+	typedef test_group<hashmap_test> hash_index_t;
+	typedef hash_index_t::object hash_index_object_t;
+	tut::hash_index_t tut_hash_index("hashmap_test");
+
+	// stress test
+	template<> template<>
+	void hash_index_object_t::test<1>()
+	{
+		LLUUIDHashMap<UUIDTableEntry, 32>	hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
+		const int numElementsToCheck = 32*256*32;
+		std::vector<LLUUID> idList(numElementsToCheck);
+		int i;
+		
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID id;
+			id.generate();
+			UUIDTableEntry entry(id, i);
+			hashTable.set(id, entry);
+			idList[i] = id;
+		}
+
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID idToCheck = idList[i];
+			UUIDTableEntry entryToCheck = hashTable.get(idToCheck);
+			ensure("set/get did not work", entryToCheck.getID() == idToCheck && entryToCheck.getValue() == (size_t)i);
+		}
+
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID idToCheck = idList[i];
+			if (i % 2 != 0)
+			{
+				hashTable.remove(idToCheck);
+			}
+		}
+
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID idToCheck = idList[i];
+			ensure("remove or check did not work", (i % 2 == 0 && hashTable.check(idToCheck)) || (i % 2 != 0 && !hashTable.check(idToCheck)));
+		}
+	}
+
+	// test removing all but one element. 
+	template<> template<>
+	void hash_index_object_t::test<2>()
+	{
+		LLUUIDHashMap<UUIDTableEntry, 2>	hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
+		const int numElementsToCheck = 5;
+		std::vector<LLUUID> idList(numElementsToCheck*10);
+		int i;
+		
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID id;
+			id.generate();
+			UUIDTableEntry entry(id, i);
+			hashTable.set(id, entry);
+			idList[i] = id;
+		}
+
+		ensure("getLength failed", hashTable.getLength() == numElementsToCheck);
+
+		// remove all but the last element
+		for (i = 0; i < numElementsToCheck-1; i++)
+		{
+			LLUUID idToCheck = idList[i];
+			hashTable.remove(idToCheck);
+		}
+
+		// there should only be one element left now.
+		ensure("getLength failed", hashTable.getLength() == 1);
+
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID idToCheck = idList[i];
+			if (i != numElementsToCheck - 1)
+			{
+				ensure("remove did not work", hashTable.check(idToCheck)  == FALSE);
+			}
+			else
+			{
+				UUIDTableEntry entryToCheck = hashTable.get(idToCheck);
+				ensure("remove did not work", entryToCheck.getID() == idToCheck && entryToCheck.getValue() == (size_t)i);
+			}
+		}
+	}
+
+	// test overriding of value already set. 
+	template<> template<>
+	void hash_index_object_t::test<3>()
+	{
+		LLUUIDHashMap<UUIDTableEntry, 5>	hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
+		const int numElementsToCheck = 10;
+		std::vector<LLUUID> idList(numElementsToCheck);
+		int i;
+		
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID id;
+			id.generate();
+			UUIDTableEntry entry(id, i);
+			hashTable.set(id, entry);
+			idList[i] = id;
+		}
+
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID id = idList[i];
+			// set new entry with value = i+numElementsToCheck
+			UUIDTableEntry entry(id, i+numElementsToCheck);
+			hashTable.set(id, entry);
+		}
+
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID idToCheck = idList[i];
+			UUIDTableEntry entryToCheck = hashTable.get(idToCheck);
+			ensure("set/get did not work", entryToCheck.getID() == idToCheck && entryToCheck.getValue() == (size_t)(i+numElementsToCheck));
+		}
+	}
+
+	// test removeAll() 
+	template<> template<>
+	void hash_index_object_t::test<4>()
+	{
+		LLUUIDHashMap<UUIDTableEntry, 5>	hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
+		const int numElementsToCheck = 10;
+		std::vector<LLUUID> idList(numElementsToCheck);
+		int i;
+		
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID id;
+			id.generate();
+			UUIDTableEntry entry(id, i);
+			hashTable.set(id, entry);
+			idList[i] = id;
+		}
+
+		hashTable.removeAll();
+		ensure("removeAll failed", hashTable.getLength() == 0);
+	}
+
+
+	// test sparse map - force it by creating 256 entries that fall into 256 different nodes 
+	template<> template<>
+	void hash_index_object_t::test<5>()
+	{
+		LLUUIDHashMap<UUIDTableEntry, 2>	hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
+		const int numElementsToCheck = 256;
+		std::vector<LLUUID> idList(numElementsToCheck);
+		int i;
+		
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID id;
+			id.generate();
+			// LLUUIDHashMap uses mData[0] to pick the bucket
+			// overwrite mData[0] so that it ranges from 0 to 255
+			id.mData[0] = i; 
+			UUIDTableEntry entry(id, i);
+			hashTable.set(id, entry);
+			idList[i] = id;
+		}
+
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID idToCheck = idList[i];
+			UUIDTableEntry entryToCheck = hashTable.get(idToCheck);
+			ensure("set/get did not work for sparse map", entryToCheck.getID() == idToCheck && entryToCheck.getValue() == (size_t)i);
+		}
+
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID idToCheck = idList[i];
+			if (i % 2 != 0)
+			{
+				hashTable.remove(idToCheck);
+			}
+		}
+
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID idToCheck = idList[i];
+			ensure("remove or check did not work for sparse map", (i % 2 == 0 && hashTable.check(idToCheck)) || (i % 2 != 0 && !hashTable.check(idToCheck)));
+		}
+	}
+
+	// iterator
+	template<> template<>
+	void hash_index_object_t::test<6>()
+	{
+		LLUUIDHashMap<UUIDTableEntry, 2>	hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
+		LLUUIDHashMapIter<UUIDTableEntry, 2> hashIter(&hashTable);
+		const int numElementsToCheck = 256;
+		std::vector<LLUUID> idList(numElementsToCheck);
+		int i;
+		
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID id;
+			id.generate();
+			// LLUUIDHashMap uses mData[0] to pick the bucket
+			// overwrite mData[0] so that it ranges from 0 to 255
+			// to create a sparse map
+			id.mData[0] = i; 
+			UUIDTableEntry entry(id, i);
+			hashTable.set(id, entry);
+			idList[i] = id;
+		}
+
+		hashIter.first();
+		int numElementsIterated = 0;
+		while(!hashIter.done())
+		{
+			numElementsIterated++;
+			UUIDTableEntry tableEntry = *hashIter;
+			LLUUID id = tableEntry.getID();
+			hashIter.next();
+			ensure("Iteration failed for sparse map", tableEntry.getValue() < (size_t)numElementsToCheck && idList[tableEntry.getValue()] ==  tableEntry.getID());
+		}
+
+		ensure("iteration count failed", numElementsIterated == numElementsToCheck);
+	}
+
+	// remove after middle of iteration
+	template<> template<>
+	void hash_index_object_t::test<7>()
+	{
+		LLUUIDHashMap<UUIDTableEntry, 2>	hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
+		LLUUIDHashMapIter<UUIDTableEntry, 2> hashIter(&hashTable);
+		const int numElementsToCheck = 256;
+		std::vector<LLUUID> idList(numElementsToCheck);
+		int i;
+		
+		LLUUID uuidtoSearch;
+		for (i = 0; i < numElementsToCheck; i++)
+		{
+			LLUUID id;
+			id.generate();
+			// LLUUIDHashMap uses mData[0] to pick the bucket
+			// overwrite mData[0] so that it ranges from 0 to 255
+			// to create a sparse map
+			id.mData[0] = i; 
+			UUIDTableEntry entry(id, i);
+			hashTable.set(id, entry);
+			idList[i] = id;
+
+			// pick uuid somewhere in the middle
+			if (i == 5)
+			{
+				uuidtoSearch = id;
+			}
+		}
+
+		hashIter.first();
+		int numElementsIterated = 0;
+		while(!hashIter.done())
+		{
+			numElementsIterated++;
+			UUIDTableEntry tableEntry = *hashIter;
+			LLUUID id = tableEntry.getID();
+			if (uuidtoSearch == id)
+			{
+				break;
+			}
+			hashIter.next();
+		}
+
+		// current iterator implementation will not allow any remove operations
+		// until ALL elements have been iterated over. this seems to be 
+		// an unnecessary restriction. Iterator should have a method to
+		// reset() its state so that further operations (inckuding remove)
+		// can be performed on the HashMap without having to iterate thru 
+		// all the remaining nodes. 
+		
+//		 hashIter.reset();
+//		 hashTable.remove(uuidtoSearch);
+//		 ensure("remove after iteration reset failed", hashTable.check(uuidtoSearch) == FALSE);
+	}
+}
diff --git a/indra/test/llxorcipher_tut.cpp b/indra/test/llxorcipher_tut.cpp
new file mode 100644
index 0000000000..6fe5176cb0
--- /dev/null
+++ b/indra/test/llxorcipher_tut.cpp
@@ -0,0 +1,113 @@
+/**
+ * @file llxorcipher_tut.cpp
+ * @author Adroit
+ * @date 2007-03
+ * @brief llxorcipher, llnullcipher test cases.
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+ 
+#include <tut/tut.h>
+#include "lltut.h"
+#include "llxorcipher.h"
+#include "llnullcipher.h"
+
+namespace tut
+{
+	struct cipher
+	{
+	};
+	typedef test_group<cipher> cipher_t;
+	typedef cipher_t::object cipher_object_t;
+	tut::cipher_t tut_cipher("cipher");
+
+	//encrypt->decrypt
+	template<> template<>
+	void cipher_object_t::test<1>()
+	{
+		const U32 len = 3;
+		const U8 pad[] = "abc";
+		const char str[] = "SecondLife";
+		const S32 str_len = sizeof(str);
+		U8 encrypted[str_len];
+		U8 decrypted[str_len];
+		LLXORCipher xorCipher(pad, len);
+		LLXORCipher xorCipher1(pad, len);
+
+		U32 length = xorCipher.requiredEncryptionSpace(50);
+		ensure("requiredEncryptionSpace() function failed", (length == 50));
+
+		U32 lenEncrypted = xorCipher.encrypt((U8 *) str, str_len, encrypted, str_len);
+		ensure("Encryption failed", (lenEncrypted == str_len));
+		U32 lenDecrypted = xorCipher1.decrypt(encrypted, str_len, decrypted, str_len);
+		ensure("Decryption failed", (lenDecrypted == str_len));
+		ensure_memory_matches("LLXORCipher Encrypt/Decrypt failed", str, str_len, decrypted, lenDecrypted);	
+	}
+
+	// operator=
+	template<> template<>
+	void cipher_object_t::test<2>()
+	{
+		const U8 pad[] = "ABCDEFGHIJKLMNOPQ"; // pad len longer than data to be ciphered
+		const U32 pad_len = sizeof(pad);
+		const U8 pad1[] = "SecondLife";
+		const U32 pad_len1 = sizeof(pad1);
+		const char str[] = "To Be Ciphered";
+		const S32 str_len = sizeof(str);
+		U8 encrypted[str_len];
+		U8 decrypted[str_len];
+
+		LLXORCipher xorCipher(pad, pad_len);
+		LLXORCipher xorCipher1(pad1, pad_len1);
+
+		xorCipher.encrypt((U8 *) str, str_len, encrypted, str_len);
+		// make xorCipher1 same as xorCipher..so that xorCipher1 can decrypt what was 
+		// encrypted using xorCipher
+		xorCipher1 = xorCipher;
+		U32 lenDecrypted = xorCipher1.decrypt(encrypted, str_len, decrypted, str_len);
+		ensure_memory_matches("LLXORCipher operator= failed", str, str_len, decrypted, lenDecrypted);	
+	}
+	
+	//in place encrypt->decrypt
+	template<> template<>
+	void cipher_object_t::test<3>()
+	{
+		U32 padNum = 0x12349087;
+		const U8* pad = (U8*) &padNum;
+		const U32 pad_len = sizeof(U32);
+		char str[] = "To Be Ciphered a long string.........!!!.";
+		char str1[] = "To Be Ciphered a long string.........!!!."; // same as str
+		const S32 str_len = sizeof(str);
+
+		LLXORCipher xorCipher(pad, pad_len);
+		LLXORCipher xorCipher1(pad, pad_len);
+		xorCipher.encrypt((U8 *) str, str_len);
+		// it should not be the same as original data!
+		ensure("LLXORCipher: In Place encrypt failed", memcmp(str, str1, str_len) != 0);
+		xorCipher1.decrypt((U8 *) str, str_len);
+		// it should not be the same as original data!
+		ensure_memory_matches("LLXORCipher: In Place decrypt failed", str, str_len, str1, str_len);
+	}
+
+	//LLNullCipher encrypt->decrypt
+	template<> template<>
+	void cipher_object_t::test<4>()
+	{
+		const char str[] = "SecondLife";
+		const S32 str_len = sizeof(str);
+		U8 encrypted[str_len];
+		U8 decrypted[str_len];
+		LLNullCipher nullCipher;
+		LLNullCipher nullCipher1;
+
+		U32 length = nullCipher.requiredEncryptionSpace(50);
+		ensure("LLNullCipher::requiredEncryptionSpace() function failed", (length == 50));
+
+		U32 len1 = nullCipher.encrypt((U8 *) str, str_len, encrypted, str_len);
+		ensure_memory_matches("LLNullCipher - Source transformed during encryption.", encrypted, len1, str, str_len);
+		
+		U32 len2 = nullCipher1.decrypt(encrypted, str_len, decrypted, str_len);
+		ensure_memory_matches("LLNullCipher - Decryption failed", decrypted, len2, str, str_len);
+	}
+}
diff --git a/indra/test/message_tut.cpp b/indra/test/message_tut.cpp
new file mode 100644
index 0000000000..a08c3130f1
--- /dev/null
+++ b/indra/test/message_tut.cpp
@@ -0,0 +1,77 @@
+/**
+ * @file lldatapacker_tut.cpp
+ * @date 2007-04
+ * @brief LLDataPacker test cases.
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include <tut/tut.h>
+#include "lltut.h"
+
+#include "llapr.h"
+#include "llversion.h"
+#include "message.h"
+#include "message_prehash.h"
+
+namespace
+{
+	struct Response : public LLHTTPNode::Response
+	{
+		virtual void result(const LLSD&) {}
+		virtual void status(S32 code, const std::string& message) 
+		{
+			mStatus = code;
+		}
+		S32 mStatus;
+	};
+}
+
+namespace tut
+{	
+	struct LLMessageSystemTestData 
+	{
+		LLMessageSystemTestData()
+		{
+			static bool init = false;
+			if(! init)
+			{
+				ll_init_apr();
+				init_prehash_data();
+				init = true;
+			}
+
+			// currently test disconnected message system
+			start_messaging_system("notafile", 13035,
+								   LL_VERSION_MAJOR,
+								   LL_VERSION_MINOR,        
+								   LL_VERSION_PATCH,        
+								   FALSE,        
+								   "notasharedsecret");
+		}
+
+		~LLMessageSystemTestData()
+		{
+			// not end_messaging_system()
+			delete gMessageSystem;
+			gMessageSystem = NULL;
+		}
+	};
+	
+	typedef test_group<LLMessageSystemTestData>	LLMessageSystemTestGroup;
+	typedef LLMessageSystemTestGroup::object		LLMessageSystemTestObject;
+	LLMessageSystemTestGroup messageTestGroup("LLMessageSystem");
+	
+	template<> template<>
+	void LLMessageSystemTestObject::test<1>()
+		// dispatch unknown message
+	{
+		const char* name = "notamessasge";
+		const LLSD message;
+		const LLPointer<Response> response = new Response();
+		gMessageSystem->dispatch(name, message, response);
+		ensure_equals(response->mStatus, 404);
+	}
+}
+
diff --git a/indra/test/test.cpp b/indra/test/test.cpp
index b60abdf587..24a0c27a5e 100644
--- a/indra/test/test.cpp
+++ b/indra/test/test.cpp
@@ -44,7 +44,8 @@ public:
 		mTotalTests(0),
 		mPassedTests(0),
 		mFailedTests(0),
-		mSkippedTests(0)
+		mSkippedTests(0),
+		mSkipedFailTests(0)
 	{
 	}
 
@@ -66,7 +67,7 @@ public:
 			break;
 		case tut::test_result::fail:
 			++mFailedTests;
-			out << "fail '" << tr.message << "'";
+			out << "fail";
 			break;
 		case tut::test_result::ex:
 			++mFailedTests;
@@ -84,12 +85,20 @@ public:
 			++mSkippedTests;
 			out << "skipped";
 			break;
+		case tut::test_result::skip_fail:
+			++mSkipedFailTests;
+			out << "skipped known failure";
+			break;
 		default:
 			++mFailedTests;
 			out << "unknown";
 		}
 		if(mVerboseMode || (tr.result != tut::test_result::ok))
 		{
+			if(!tr.message.empty())
+			{
+				out << ": '" << tr.message << "'";
+			}
 			std::cout << out.str() << std::endl;
 		}
 	}
@@ -98,11 +107,17 @@ public:
 	{
 		std::cout << std::endl;
 		std::cout << "Total Tests:   " << mTotalTests << std::endl;
-		std::cout << "Passed Tests : " << mPassedTests << std::endl;
+		std::cout << "Passed Tests: " << mPassedTests << std::endl;
 		
 		if (mSkippedTests > 0)
 		{
-			std::cout << "Skipped Tests : " << mSkippedTests << std::endl;
+			std::cout << "Skipped Tests: " << mSkippedTests << std::endl;
+		}
+
+		if (mSkipedFailTests > 0)
+		{
+			std::cout << "Skipped known failures: " << mSkipedFailTests
+				<< std::endl;
 		}
 
 		if(mFailedTests > 0)
@@ -117,10 +132,11 @@ public:
 
 protected:
 	bool mVerboseMode;
-	S32 mTotalTests;
-	S32 mPassedTests;
-	S32 mFailedTests;
-	S32 mSkippedTests;
+	int mTotalTests;
+	int mPassedTests;
+	int mFailedTests;
+	int mSkippedTests;
+	int mSkipedFailTests;
 };
 
 static const apr_getopt_option_t TEST_CL_OPTIONS[] =