Merge DRTVWR-591-maint-X to main on promotion of secondlife/viewer #705: Maintenance X

46 files changed, 10500 insertions, 10500 deletions

diff --git a/indra/test/catch_and_store_what_in.h b/indra/test/catch_and_store_what_in.h
index 5beba06024..d3dada2acf 100644
--- a/indra/test/catch_and_store_what_in.h
+++ b/indra/test/catch_and_store_what_in.h
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2012-02-15
  * @brief  catch_what() template function, CATCH_AND_STORE_WHAT_IN() macro
- * 
+ *
  * $LicenseInfo:firstyear=2012&license=viewerlgpl$
  * Copyright (c) 2012, Linden Research, Inc.
  * $/LicenseInfo$
@@ -64,45 +64,45 @@ std::string catch_what(FUNC func)
  * ensure("some_call_that_should_throw_Foo() didn't throw", ! threw.empty());
  * @endcode
  */
-#define CATCH_AND_STORE_WHAT_IN(THREW, EXCEPTION)	\
-catch (const EXCEPTION& ex)							\
-{													\
-	(THREW) = ex.what();							\
-}													\
+#define CATCH_AND_STORE_WHAT_IN(THREW, EXCEPTION)   \
+catch (const EXCEPTION& ex)                         \
+{                                                   \
+    (THREW) = ex.what();                            \
+}                                                   \
 CATCH_MISSED_LINUX_EXCEPTION(THREW, EXCEPTION)
 
 #ifndef LL_LINUX
-#define CATCH_MISSED_LINUX_EXCEPTION(THREW, EXCEPTION)					\
-	/* only needed on Linux */
+#define CATCH_MISSED_LINUX_EXCEPTION(THREW, EXCEPTION)                  \
+    /* only needed on Linux */
 #else // LL_LINUX
 
-#define CATCH_MISSED_LINUX_EXCEPTION(THREW, EXCEPTION)					\
-catch (const std::runtime_error& ex)									\
-{																		\
-	/* This clause is needed on Linux, on the viewer side, because	*/	\
-	/* the exception isn't caught by catch (const EXCEPTION&).		*/	\
-	/* But if the expected exception was thrown, allow the test to	*/	\
-	/* succeed anyway. Not sure how else to handle this odd case.	*/	\
-	if (std::string(typeid(ex).name()) == typeid(EXCEPTION).name())		\
-	{																	\
-		/* std::cerr << "Caught " << typeid(ex).name() */				\
-		/*			 << " with Linux workaround" << std::endl; */		\
-		(THREW) = ex.what();											\
-		/*std::cout << ex.what() << std::endl;*/						\
-	}																	\
-	else																\
-	{																	\
-		/* We don't even recognize this exception. Let it propagate	*/	\
-		/* out to TUT to fail the test.								*/	\
-		throw;															\
-	}																	\
-}																		\
-catch (...)																\
-{																		\
-	std::cerr << "Failed to catch expected exception "					\
-			  << #EXCEPTION << "!" << std::endl;						\
-	/* This indicates a problem in the test that should be addressed. */ \
-	throw;																\
+#define CATCH_MISSED_LINUX_EXCEPTION(THREW, EXCEPTION)                  \
+catch (const std::runtime_error& ex)                                    \
+{                                                                       \
+    /* This clause is needed on Linux, on the viewer side, because  */  \
+    /* the exception isn't caught by catch (const EXCEPTION&).      */  \
+    /* But if the expected exception was thrown, allow the test to  */  \
+    /* succeed anyway. Not sure how else to handle this odd case.   */  \
+    if (std::string(typeid(ex).name()) == typeid(EXCEPTION).name())     \
+    {                                                                   \
+        /* std::cerr << "Caught " << typeid(ex).name() */               \
+        /*           << " with Linux workaround" << std::endl; */       \
+        (THREW) = ex.what();                                            \
+        /*std::cout << ex.what() << std::endl;*/                        \
+    }                                                                   \
+    else                                                                \
+    {                                                                   \
+        /* We don't even recognize this exception. Let it propagate */  \
+        /* out to TUT to fail the test.                             */  \
+        throw;                                                          \
+    }                                                                   \
+}                                                                       \
+catch (...)                                                             \
+{                                                                       \
+    std::cerr << "Failed to catch expected exception "                  \
+              << #EXCEPTION << "!" << std::endl;                        \
+    /* This indicates a problem in the test that should be addressed. */ \
+    throw;                                                              \
 }
 
 #endif // LL_LINUX
diff --git a/indra/test/chained_callback.h b/indra/test/chained_callback.h
index 05929e33ad..984e2f1dbc 100644
--- a/indra/test/chained_callback.h
+++ b/indra/test/chained_callback.h
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2020-01-03
  * @brief  Subclass of tut::callback used for chaining callbacks.
- * 
+ *
  * $LicenseInfo:firstyear=2020&license=viewerlgpl$
  * Copyright (c) 2020, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/test/debug.h b/indra/test/debug.h
index 76dbb973b2..1579bb9c86 100644
--- a/indra/test/debug.h
+++ b/indra/test/debug.h
@@ -3,25 +3,25 @@
  * @author Nat Goodspeed
  * @date   2009-05-28
  * @brief  Debug output for unit test code
- * 
+ *
  * $LicenseInfo:firstyear=2009&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
diff --git a/indra/test/hexdump.h b/indra/test/hexdump.h
index dd7cbaaa3c..95f1e297c3 100644
--- a/indra/test/hexdump.h
+++ b/indra/test/hexdump.h
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2023-09-08
  * @brief  Provide hexdump() and hexmix() ostream formatters
- * 
+ *
  * $LicenseInfo:firstyear=2023&license=viewerlgpl$
  * Copyright (c) 2023, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/test/io.cpp b/indra/test/io.cpp
index 99b49c8b29..412f9ca1d2 100644
--- a/indra/test/io.cpp
+++ b/indra/test/io.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file io.cpp
  * @author Phoenix
  * @date 2005-10-02
@@ -7,21 +7,21 @@
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -48,1132 +48,1132 @@
 
 namespace tut
 {
-	struct heap_buffer_data
-	{
-		heap_buffer_data() : mBuffer(NULL) {}
-		~heap_buffer_data() { if(mBuffer) delete mBuffer; }
-		LLHeapBuffer* mBuffer;
-	};
-	typedef test_group<heap_buffer_data> heap_buffer_test;
-	typedef heap_buffer_test::object heap_buffer_object;
-	tut::heap_buffer_test thb("heap_buffer");
-
-	template<> template<>
-	void heap_buffer_object::test<1>()
-	{
-		const S32 BUF_SIZE = 100;
-		mBuffer = new LLHeapBuffer(BUF_SIZE);
-		ensure_equals("empty buffer capacity", mBuffer->capacity(), BUF_SIZE);
-		const S32 SEGMENT_SIZE = 50;
-		LLSegment segment;
-		mBuffer->createSegment(0, SEGMENT_SIZE, segment);
-		ensure_equals("used buffer capacity", mBuffer->capacity(), BUF_SIZE);
-	}
-
-	template<> template<>
-	void heap_buffer_object::test<2>()
-	{
-		const S32 BUF_SIZE = 10;
-		mBuffer = new LLHeapBuffer(BUF_SIZE);
-		LLSegment segment;
-		mBuffer->createSegment(0, BUF_SIZE, segment);
-		ensure("segment is in buffer", mBuffer->containsSegment(segment));
-		ensure_equals("buffer consumed", mBuffer->bytesLeft(), 0);
-		bool  created;
-		created = mBuffer->createSegment(0, 0, segment);
-		ensure("Create zero size segment fails", !created);
-		created = mBuffer->createSegment(0, BUF_SIZE, segment);
-		ensure("Create segment fails", !created);
-	}
-
-	template<> template<>
-	void heap_buffer_object::test<3>()
-	{
-		const S32 BUF_SIZE = 10;
-		mBuffer = new LLHeapBuffer(BUF_SIZE);
-		LLSegment segment;
-		mBuffer->createSegment(0, BUF_SIZE, segment);
-		ensure("segment is in buffer", mBuffer->containsSegment(segment));
-		ensure_equals("buffer consumed", mBuffer->bytesLeft(), 0);
-		bool reclaimed = mBuffer->reclaimSegment(segment);
-		ensure("buffer reclaimed.", reclaimed);
-		ensure_equals("buffer available", mBuffer->bytesLeft(), BUF_SIZE);
-		bool  created;
-		created = mBuffer->createSegment(0, 0, segment);
-		ensure("Create zero size segment fails", !created);
-		created = mBuffer->createSegment(0, BUF_SIZE, segment);
-		ensure("Create another segment succeeds", created);
-	}
-
-	template<> template<>
-	void heap_buffer_object::test<4>()
-	{
-		const S32 BUF_SIZE = 10;
-		const S32 SEGMENT_SIZE = 4;
-		mBuffer = new LLHeapBuffer(BUF_SIZE);
-		LLSegment seg1;
-		mBuffer->createSegment(0, SEGMENT_SIZE, seg1);
-		ensure("segment is in buffer", mBuffer->containsSegment(seg1));
-		LLSegment seg2;
-		mBuffer->createSegment(0, SEGMENT_SIZE, seg2);
-		ensure("segment is in buffer", mBuffer->containsSegment(seg2));
-		LLSegment seg3;
-		mBuffer->createSegment(0, SEGMENT_SIZE, seg3);
-		ensure("segment is in buffer", mBuffer->containsSegment(seg3));
-		ensure_equals("segment is truncated", seg3.size(), 2);
-		LLSegment seg4;
-		bool created;
-		created = mBuffer->createSegment(0, SEGMENT_SIZE, seg4);
-		ensure("Create segment fails", !created);
-		bool reclaimed;
-		reclaimed = mBuffer->reclaimSegment(seg1);
-		ensure("buffer reclaim succeed.", reclaimed);
-		ensure_equals("no buffer available", mBuffer->bytesLeft(), 0);
-		reclaimed = mBuffer->reclaimSegment(seg2);
-		ensure("buffer reclaim succeed.", reclaimed);
-		ensure_equals("buffer reclaimed", mBuffer->bytesLeft(), 0);
-		reclaimed = mBuffer->reclaimSegment(seg3);
-		ensure("buffer reclaim succeed.", reclaimed);
-		ensure_equals("buffer reclaimed", mBuffer->bytesLeft(), BUF_SIZE);
-		created = mBuffer->createSegment(0, SEGMENT_SIZE, seg1);
-		ensure("segment is in buffer", mBuffer->containsSegment(seg1));
-		ensure("Create segment succeds", created);
-	}
+    struct heap_buffer_data
+    {
+        heap_buffer_data() : mBuffer(NULL) {}
+        ~heap_buffer_data() { if(mBuffer) delete mBuffer; }
+        LLHeapBuffer* mBuffer;
+    };
+    typedef test_group<heap_buffer_data> heap_buffer_test;
+    typedef heap_buffer_test::object heap_buffer_object;
+    tut::heap_buffer_test thb("heap_buffer");
+
+    template<> template<>
+    void heap_buffer_object::test<1>()
+    {
+        const S32 BUF_SIZE = 100;
+        mBuffer = new LLHeapBuffer(BUF_SIZE);
+        ensure_equals("empty buffer capacity", mBuffer->capacity(), BUF_SIZE);
+        const S32 SEGMENT_SIZE = 50;
+        LLSegment segment;
+        mBuffer->createSegment(0, SEGMENT_SIZE, segment);
+        ensure_equals("used buffer capacity", mBuffer->capacity(), BUF_SIZE);
+    }
+
+    template<> template<>
+    void heap_buffer_object::test<2>()
+    {
+        const S32 BUF_SIZE = 10;
+        mBuffer = new LLHeapBuffer(BUF_SIZE);
+        LLSegment segment;
+        mBuffer->createSegment(0, BUF_SIZE, segment);
+        ensure("segment is in buffer", mBuffer->containsSegment(segment));
+        ensure_equals("buffer consumed", mBuffer->bytesLeft(), 0);
+        bool  created;
+        created = mBuffer->createSegment(0, 0, segment);
+        ensure("Create zero size segment fails", !created);
+        created = mBuffer->createSegment(0, BUF_SIZE, segment);
+        ensure("Create segment fails", !created);
+    }
+
+    template<> template<>
+    void heap_buffer_object::test<3>()
+    {
+        const S32 BUF_SIZE = 10;
+        mBuffer = new LLHeapBuffer(BUF_SIZE);
+        LLSegment segment;
+        mBuffer->createSegment(0, BUF_SIZE, segment);
+        ensure("segment is in buffer", mBuffer->containsSegment(segment));
+        ensure_equals("buffer consumed", mBuffer->bytesLeft(), 0);
+        bool reclaimed = mBuffer->reclaimSegment(segment);
+        ensure("buffer reclaimed.", reclaimed);
+        ensure_equals("buffer available", mBuffer->bytesLeft(), BUF_SIZE);
+        bool  created;
+        created = mBuffer->createSegment(0, 0, segment);
+        ensure("Create zero size segment fails", !created);
+        created = mBuffer->createSegment(0, BUF_SIZE, segment);
+        ensure("Create another segment succeeds", created);
+    }
+
+    template<> template<>
+    void heap_buffer_object::test<4>()
+    {
+        const S32 BUF_SIZE = 10;
+        const S32 SEGMENT_SIZE = 4;
+        mBuffer = new LLHeapBuffer(BUF_SIZE);
+        LLSegment seg1;
+        mBuffer->createSegment(0, SEGMENT_SIZE, seg1);
+        ensure("segment is in buffer", mBuffer->containsSegment(seg1));
+        LLSegment seg2;
+        mBuffer->createSegment(0, SEGMENT_SIZE, seg2);
+        ensure("segment is in buffer", mBuffer->containsSegment(seg2));
+        LLSegment seg3;
+        mBuffer->createSegment(0, SEGMENT_SIZE, seg3);
+        ensure("segment is in buffer", mBuffer->containsSegment(seg3));
+        ensure_equals("segment is truncated", seg3.size(), 2);
+        LLSegment seg4;
+        bool created;
+        created = mBuffer->createSegment(0, SEGMENT_SIZE, seg4);
+        ensure("Create segment fails", !created);
+        bool reclaimed;
+        reclaimed = mBuffer->reclaimSegment(seg1);
+        ensure("buffer reclaim succeed.", reclaimed);
+        ensure_equals("no buffer available", mBuffer->bytesLeft(), 0);
+        reclaimed = mBuffer->reclaimSegment(seg2);
+        ensure("buffer reclaim succeed.", reclaimed);
+        ensure_equals("buffer reclaimed", mBuffer->bytesLeft(), 0);
+        reclaimed = mBuffer->reclaimSegment(seg3);
+        ensure("buffer reclaim succeed.", reclaimed);
+        ensure_equals("buffer reclaimed", mBuffer->bytesLeft(), BUF_SIZE);
+        created = mBuffer->createSegment(0, SEGMENT_SIZE, seg1);
+        ensure("segment is in buffer", mBuffer->containsSegment(seg1));
+        ensure("Create segment succeds", created);
+    }
 }
 
 namespace tut
 {
-	struct buffer_data
-	{
-		LLBufferArray mBuffer;
-	};
-	typedef test_group<buffer_data> buffer_test;
-	typedef buffer_test::object buffer_object;
-	tut::buffer_test tba("buffer_array");
-
-	template<> template<>
-	void buffer_object::test<1>()
-	{
-		const char HELLO_WORLD[] = "hello world";
-		const S32 str_len = strlen(HELLO_WORLD);
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		mBuffer.append(ch.in(), (U8*)HELLO_WORLD, str_len);
-		S32 count = mBuffer.countAfter(ch.in(), NULL);
-		ensure_equals("total append size", count, str_len);
-		LLBufferArray::segment_iterator_t it = mBuffer.beginSegment();
-		U8* first = (*it).data();
-		count = mBuffer.countAfter(ch.in(), first);
-		ensure_equals("offset append size", count, str_len - 1);
-	}
-
-	template<> template<>
-	void buffer_object::test<2>()
-	{
-		const char HELLO_WORLD[] = "hello world";
-		const S32 str_len = strlen(HELLO_WORLD);		/* Flawfinder: ignore */
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		mBuffer.append(ch.in(), (U8*)HELLO_WORLD, str_len);
-		mBuffer.append(ch.in(), (U8*)HELLO_WORLD, str_len);
-		S32 count = mBuffer.countAfter(ch.in(), NULL);
-		ensure_equals("total append size", count, 2 * str_len);
-		LLBufferArray::segment_iterator_t it = mBuffer.beginSegment();
-		U8* first = (*it).data();
-		count = mBuffer.countAfter(ch.in(), first);
-		ensure_equals("offset append size", count, (2 * str_len) - 1);
-	}
-
-	template<> template<>
-	void buffer_object::test<3>()
-	{
-		const char ONE[] = "one";
-		const char TWO[] = "two";
-		std::string expected(ONE);
-		expected.append(TWO);
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		mBuffer.append(ch.in(), (U8*)ONE, 3);
-		mBuffer.append(ch.in(), (U8*)TWO, 3);
-		char buffer[255];	/* Flawfinder: ignore */
-		S32 len = 6;
-		mBuffer.readAfter(ch.in(), NULL, (U8*)buffer, len);
-		ensure_equals(len, 6);
-		buffer[len] = '\0';
-		std::string actual(buffer);
-		ensure_equals("read", actual, expected);
-	}
-
-	template<> template<>
-	void buffer_object::test<4>()
-	{
-		const char ONE[] = "one";
-		const char TWO[] = "two";
-		std::string expected(ONE);
-		expected.append(TWO);
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		mBuffer.append(ch.in(), (U8*)TWO, 3);
-		mBuffer.prepend(ch.in(), (U8*)ONE, 3);
-		char buffer[255];	/* Flawfinder: ignore */
-		S32 len = 6;
-		mBuffer.readAfter(ch.in(), NULL, (U8*)buffer, len);
-		ensure_equals(len, 6);
-		buffer[len] = '\0';
-		std::string actual(buffer);
-		ensure_equals("read", actual, expected);
-	}
-
-	template<> template<>
-	void buffer_object::test<5>()
-	{
-		const char ONE[] = "one";
-		const char TWO[] = "two";
-		std::string expected("netwo");
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		mBuffer.append(ch.in(), (U8*)TWO, 3);
-		mBuffer.prepend(ch.in(), (U8*)ONE, 3);
-		char buffer[255];	/* Flawfinder: ignore */
-		S32 len = 5;
-		LLBufferArray::segment_iterator_t it = mBuffer.beginSegment();
-		U8* addr = (*it).data();
-		mBuffer.readAfter(ch.in(), addr, (U8*)buffer, len);
-		ensure_equals(len, 5);
-		buffer[len] = '\0';
-		std::string actual(buffer);
-		ensure_equals("read", actual, expected);
-	}
-
-	template<> template<>
-	void buffer_object::test<6>()
-	{
-		std::string request("The early bird catches the worm.");
-		std::string response("If you're a worm, sleep late.");
-		std::ostringstream expected;
-		expected << "ContentLength: " << response.length() << "\r\n\r\n"
-				 << response;
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		mBuffer.append(ch.in(), (U8*)request.c_str(), request.length());
-		mBuffer.append(ch.out(), (U8*)response.c_str(), response.length());
-		S32 count = mBuffer.countAfter(ch.out(), NULL);
-		std::ostringstream header;
-		header << "ContentLength: " << count << "\r\n\r\n";
-		std::string head(header.str());
-		mBuffer.prepend(ch.out(), (U8*)head.c_str(), head.length());
-		char buffer[1024];	/* Flawfinder: ignore */
-		S32 len = response.size() + head.length();
-		ensure_equals("same length", len, (S32)expected.str().length());
-		mBuffer.readAfter(ch.out(), NULL, (U8*)buffer, len);
-		buffer[len] = '\0';
-		std::string actual(buffer);
-		ensure_equals("threaded writes", actual, expected.str());
-	}
-
-	template<> template<>
-	void buffer_object::test<7>()
-	{
-		const S32 LINE_COUNT = 3;
-		std::string lines[LINE_COUNT] =
-			{
-				std::string("GET /index.htm HTTP/1.0\r\n"),
-				std::string("User-Agent: Wget/1.9.1\r\n"),
-				std::string("Host: localhost:8008\r\n")
-			};
-		std::string text;
-		S32 i;
-		for(i = 0; i < LINE_COUNT; ++i)
-		{
-			text.append(lines[i]);
-		}
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		mBuffer.append(ch.in(), (U8*)text.c_str(), text.length());
-		const S32 BUFFER_LEN = 1024;
-		char buf[BUFFER_LEN];
-		S32 len;
-		U8* last = NULL;
-		std::string last_line;
-		for(i = 0; i < LINE_COUNT; ++i)
-		{
-			len = BUFFER_LEN;
-			last = mBuffer.readAfter(ch.in(), last, (U8*)buf, len);
-			char* newline = strchr((char*)buf, '\n');
-			S32 offset = -((len - 1) - (newline - buf));
-			++newline;
-			*newline = '\0';
-			last_line.assign(buf);
-			std::ostringstream message;
-			message << "line reads in line["	 << i << "]";
-			ensure_equals(message.str().c_str(), last_line, lines[i]);
-			last = mBuffer.seek(ch.in(), last, offset);
-		}
-	}
-
-	template<> template<>
-	void buffer_object::test<8>()
-	{
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		mBuffer.append(ch.in(), (U8*)"1", 1);
-		LLBufferArray buffer;
-		buffer.append(ch.in(), (U8*)"2", 1);
-		mBuffer.takeContents(buffer);
-		mBuffer.append(ch.in(), (U8*)"3", 1);
-		S32 count = mBuffer.countAfter(ch.in(), NULL);
-		ensure_equals("buffer size", count, 3);
-		U8* temp = new U8[count];
-		mBuffer.readAfter(ch.in(), NULL, temp, count);
-		ensure("buffer content", (0 == memcmp(temp, (void*)"123", 3)));
-		delete[] temp;
-	}
-
-	template<> template<>
-	void buffer_object::test<9>()
-	{
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		mBuffer.append(ch.in(), (U8*)"1", 1);
-		S32 capacity = mBuffer.capacity();
-		ensure("has capacity", capacity > 0);
-		U8* temp = new U8[capacity - 1];
-		mBuffer.append(ch.in(), temp, capacity - 1);
-		capacity = mBuffer.capacity();
-		ensure("has capacity when full", capacity > 0);
-		S32 used = mBuffer.countAfter(ch.in(), NULL);
-		ensure_equals("used equals capacity", used, capacity);
-
-		LLBufferArray::segment_iterator_t iter = mBuffer.beginSegment();
-		while(iter != mBuffer.endSegment())
-		{
-			mBuffer.eraseSegment(iter++);
-		}
-
-		used = mBuffer.countAfter(ch.in(), NULL);
-		ensure_equals("used is zero", used, 0);
-		S32 capacity2 = mBuffer.capacity();
-		ensure_equals("capacity the same after erase", capacity2, capacity);
-		mBuffer.append(ch.in(), temp, capacity - 1);
-		capacity2 = mBuffer.capacity();
-		ensure_equals("capacity the same after append", capacity2, capacity);
-
-		delete[] temp;
-	}
+    struct buffer_data
+    {
+        LLBufferArray mBuffer;
+    };
+    typedef test_group<buffer_data> buffer_test;
+    typedef buffer_test::object buffer_object;
+    tut::buffer_test tba("buffer_array");
+
+    template<> template<>
+    void buffer_object::test<1>()
+    {
+        const char HELLO_WORLD[] = "hello world";
+        const S32 str_len = strlen(HELLO_WORLD);
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        mBuffer.append(ch.in(), (U8*)HELLO_WORLD, str_len);
+        S32 count = mBuffer.countAfter(ch.in(), NULL);
+        ensure_equals("total append size", count, str_len);
+        LLBufferArray::segment_iterator_t it = mBuffer.beginSegment();
+        U8* first = (*it).data();
+        count = mBuffer.countAfter(ch.in(), first);
+        ensure_equals("offset append size", count, str_len - 1);
+    }
+
+    template<> template<>
+    void buffer_object::test<2>()
+    {
+        const char HELLO_WORLD[] = "hello world";
+        const S32 str_len = strlen(HELLO_WORLD);        /* Flawfinder: ignore */
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        mBuffer.append(ch.in(), (U8*)HELLO_WORLD, str_len);
+        mBuffer.append(ch.in(), (U8*)HELLO_WORLD, str_len);
+        S32 count = mBuffer.countAfter(ch.in(), NULL);
+        ensure_equals("total append size", count, 2 * str_len);
+        LLBufferArray::segment_iterator_t it = mBuffer.beginSegment();
+        U8* first = (*it).data();
+        count = mBuffer.countAfter(ch.in(), first);
+        ensure_equals("offset append size", count, (2 * str_len) - 1);
+    }
+
+    template<> template<>
+    void buffer_object::test<3>()
+    {
+        const char ONE[] = "one";
+        const char TWO[] = "two";
+        std::string expected(ONE);
+        expected.append(TWO);
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        mBuffer.append(ch.in(), (U8*)ONE, 3);
+        mBuffer.append(ch.in(), (U8*)TWO, 3);
+        char buffer[255];   /* Flawfinder: ignore */
+        S32 len = 6;
+        mBuffer.readAfter(ch.in(), NULL, (U8*)buffer, len);
+        ensure_equals(len, 6);
+        buffer[len] = '\0';
+        std::string actual(buffer);
+        ensure_equals("read", actual, expected);
+    }
+
+    template<> template<>
+    void buffer_object::test<4>()
+    {
+        const char ONE[] = "one";
+        const char TWO[] = "two";
+        std::string expected(ONE);
+        expected.append(TWO);
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        mBuffer.append(ch.in(), (U8*)TWO, 3);
+        mBuffer.prepend(ch.in(), (U8*)ONE, 3);
+        char buffer[255];   /* Flawfinder: ignore */
+        S32 len = 6;
+        mBuffer.readAfter(ch.in(), NULL, (U8*)buffer, len);
+        ensure_equals(len, 6);
+        buffer[len] = '\0';
+        std::string actual(buffer);
+        ensure_equals("read", actual, expected);
+    }
+
+    template<> template<>
+    void buffer_object::test<5>()
+    {
+        const char ONE[] = "one";
+        const char TWO[] = "two";
+        std::string expected("netwo");
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        mBuffer.append(ch.in(), (U8*)TWO, 3);
+        mBuffer.prepend(ch.in(), (U8*)ONE, 3);
+        char buffer[255];   /* Flawfinder: ignore */
+        S32 len = 5;
+        LLBufferArray::segment_iterator_t it = mBuffer.beginSegment();
+        U8* addr = (*it).data();
+        mBuffer.readAfter(ch.in(), addr, (U8*)buffer, len);
+        ensure_equals(len, 5);
+        buffer[len] = '\0';
+        std::string actual(buffer);
+        ensure_equals("read", actual, expected);
+    }
+
+    template<> template<>
+    void buffer_object::test<6>()
+    {
+        std::string request("The early bird catches the worm.");
+        std::string response("If you're a worm, sleep late.");
+        std::ostringstream expected;
+        expected << "ContentLength: " << response.length() << "\r\n\r\n"
+                 << response;
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        mBuffer.append(ch.in(), (U8*)request.c_str(), request.length());
+        mBuffer.append(ch.out(), (U8*)response.c_str(), response.length());
+        S32 count = mBuffer.countAfter(ch.out(), NULL);
+        std::ostringstream header;
+        header << "ContentLength: " << count << "\r\n\r\n";
+        std::string head(header.str());
+        mBuffer.prepend(ch.out(), (U8*)head.c_str(), head.length());
+        char buffer[1024];  /* Flawfinder: ignore */
+        S32 len = response.size() + head.length();
+        ensure_equals("same length", len, (S32)expected.str().length());
+        mBuffer.readAfter(ch.out(), NULL, (U8*)buffer, len);
+        buffer[len] = '\0';
+        std::string actual(buffer);
+        ensure_equals("threaded writes", actual, expected.str());
+    }
+
+    template<> template<>
+    void buffer_object::test<7>()
+    {
+        const S32 LINE_COUNT = 3;
+        std::string lines[LINE_COUNT] =
+            {
+                std::string("GET /index.htm HTTP/1.0\r\n"),
+                std::string("User-Agent: Wget/1.9.1\r\n"),
+                std::string("Host: localhost:8008\r\n")
+            };
+        std::string text;
+        S32 i;
+        for(i = 0; i < LINE_COUNT; ++i)
+        {
+            text.append(lines[i]);
+        }
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        mBuffer.append(ch.in(), (U8*)text.c_str(), text.length());
+        const S32 BUFFER_LEN = 1024;
+        char buf[BUFFER_LEN];
+        S32 len;
+        U8* last = NULL;
+        std::string last_line;
+        for(i = 0; i < LINE_COUNT; ++i)
+        {
+            len = BUFFER_LEN;
+            last = mBuffer.readAfter(ch.in(), last, (U8*)buf, len);
+            char* newline = strchr((char*)buf, '\n');
+            S32 offset = -((len - 1) - (newline - buf));
+            ++newline;
+            *newline = '\0';
+            last_line.assign(buf);
+            std::ostringstream message;
+            message << "line reads in line["     << i << "]";
+            ensure_equals(message.str().c_str(), last_line, lines[i]);
+            last = mBuffer.seek(ch.in(), last, offset);
+        }
+    }
+
+    template<> template<>
+    void buffer_object::test<8>()
+    {
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        mBuffer.append(ch.in(), (U8*)"1", 1);
+        LLBufferArray buffer;
+        buffer.append(ch.in(), (U8*)"2", 1);
+        mBuffer.takeContents(buffer);
+        mBuffer.append(ch.in(), (U8*)"3", 1);
+        S32 count = mBuffer.countAfter(ch.in(), NULL);
+        ensure_equals("buffer size", count, 3);
+        U8* temp = new U8[count];
+        mBuffer.readAfter(ch.in(), NULL, temp, count);
+        ensure("buffer content", (0 == memcmp(temp, (void*)"123", 3)));
+        delete[] temp;
+    }
+
+    template<> template<>
+    void buffer_object::test<9>()
+    {
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        mBuffer.append(ch.in(), (U8*)"1", 1);
+        S32 capacity = mBuffer.capacity();
+        ensure("has capacity", capacity > 0);
+        U8* temp = new U8[capacity - 1];
+        mBuffer.append(ch.in(), temp, capacity - 1);
+        capacity = mBuffer.capacity();
+        ensure("has capacity when full", capacity > 0);
+        S32 used = mBuffer.countAfter(ch.in(), NULL);
+        ensure_equals("used equals capacity", used, capacity);
+
+        LLBufferArray::segment_iterator_t iter = mBuffer.beginSegment();
+        while(iter != mBuffer.endSegment())
+        {
+            mBuffer.eraseSegment(iter++);
+        }
+
+        used = mBuffer.countAfter(ch.in(), NULL);
+        ensure_equals("used is zero", used, 0);
+        S32 capacity2 = mBuffer.capacity();
+        ensure_equals("capacity the same after erase", capacity2, capacity);
+        mBuffer.append(ch.in(), temp, capacity - 1);
+        capacity2 = mBuffer.capacity();
+        ensure_equals("capacity the same after append", capacity2, capacity);
+
+        delete[] temp;
+    }
 
 #if 0
-	template<> template<>
-	void buffer_object::test<9>()
-	{
-		char buffer[1024];	/* Flawfinder: ignore */
-		S32 size = sprintf(buffer,
-						"%d|%d|%s|%s|%s|%s|%s|%x|%x|%x|%x|%x|%s|%s|%d|%d|%x",
-						7,
-						7,
-						"Hang Glider INFO",
-						"18e84d1e-04a4-4c0d-8cb6-6c73477f0a9a",
-						"0e346d8b-4433-4d66-a6b0-fd37083abc4c",
-						"0e346d8b-4433-4d66-a6b0-fd37083abc4c",
-						"00000000-0000-0000-0000-000000000000",
-						0x7fffffff,
-						0x7fffffff,
-						0,
-						0,
-						0x7fffffff,
-						"69e0d357-2e7c-8990-a2bc-7f61c868e5a3",
-						"2004-06-04 16:09:17 note card",
-						0,
-						10,
-						0) + 1;
-
-		//const char* expected = "7|7|Hang Glider INFO|18e84d1e-04a4-4c0d-8cb6-6c73477f0a9a|0e346d8b-4433-4d66-a6b0-fd37083abc4c|0e346d8b-4433-4d66-a6b0-fd37083abc4c|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|7fffffff|69e0d357-2e7c-8990-a2bc-7f61c868e5a3|2004-06-04 16:09:17 note card|0|10|0\0";
-		
-		LLSD* bin_bucket = LLIMInfo::buildSDfrombuffer((U8*)buffer,size);
-
-		char post_buffer[1024];
-		U32 post_size;
-		LLIMInfo::getBinaryBucket(bin_bucket,(U8*)post_buffer,post_size);
-		ensure_equals("Buffer sizes",size,(S32)post_size);
-		ensure("Buffer content",!strcmp(buffer,post_buffer));
-	}
+    template<> template<>
+    void buffer_object::test<9>()
+    {
+        char buffer[1024];  /* Flawfinder: ignore */
+        S32 size = sprintf(buffer,
+                        "%d|%d|%s|%s|%s|%s|%s|%x|%x|%x|%x|%x|%s|%s|%d|%d|%x",
+                        7,
+                        7,
+                        "Hang Glider INFO",
+                        "18e84d1e-04a4-4c0d-8cb6-6c73477f0a9a",
+                        "0e346d8b-4433-4d66-a6b0-fd37083abc4c",
+                        "0e346d8b-4433-4d66-a6b0-fd37083abc4c",
+                        "00000000-0000-0000-0000-000000000000",
+                        0x7fffffff,
+                        0x7fffffff,
+                        0,
+                        0,
+                        0x7fffffff,
+                        "69e0d357-2e7c-8990-a2bc-7f61c868e5a3",
+                        "2004-06-04 16:09:17 note card",
+                        0,
+                        10,
+                        0) + 1;
+
+        //const char* expected = "7|7|Hang Glider INFO|18e84d1e-04a4-4c0d-8cb6-6c73477f0a9a|0e346d8b-4433-4d66-a6b0-fd37083abc4c|0e346d8b-4433-4d66-a6b0-fd37083abc4c|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|7fffffff|69e0d357-2e7c-8990-a2bc-7f61c868e5a3|2004-06-04 16:09:17 note card|0|10|0\0";
+
+        LLSD* bin_bucket = LLIMInfo::buildSDfrombuffer((U8*)buffer,size);
+
+        char post_buffer[1024];
+        U32 post_size;
+        LLIMInfo::getBinaryBucket(bin_bucket,(U8*)post_buffer,post_size);
+        ensure_equals("Buffer sizes",size,(S32)post_size);
+        ensure("Buffer content",!strcmp(buffer,post_buffer));
+    }
 #endif
 
-	/*
-	template<> template<>
-	void buffer_object::test<>()
-	{
-	}
-	*/
+    /*
+    template<> template<>
+    void buffer_object::test<>()
+    {
+    }
+    */
 }
 
 namespace tut
 {
-	struct buffer_and_stream_data
-	{
-		LLBufferArray mBuffer;
-	};
-	typedef test_group<buffer_and_stream_data> bas_test;
-	typedef bas_test::object bas_object;
-	tut::bas_test tbs("buffer_stream");
-
-	template<> template<>
-	void bas_object::test<1>()
-	{
-		const char HELLO_WORLD[] = "hello world";
-		const S32 str_len = strlen(HELLO_WORLD);	/* Flawfinder: ignore */
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		LLBufferStream str(ch, &mBuffer);
-		mBuffer.append(ch.in(), (U8*)HELLO_WORLD, str_len);
-		std::string hello;
-		std::string world;
-		str >> hello >> world;
-		ensure_equals("first word", hello, std::string("hello"));
-		ensure_equals("second word", world, std::string("world"));
-	}
-
-	template<> template<>
-	void bas_object::test<2>()
-	{
-		std::string part1("Eat my shor");
-		std::string part2("ts ho");
-		std::string part3("mer");
-		std::string ignore("ignore me");
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		LLBufferStream str(ch, &mBuffer);
-		mBuffer.append(ch.in(), (U8*)part1.c_str(), part1.length());
-		mBuffer.append(ch.in(), (U8*)part2.c_str(), part2.length());
-		mBuffer.append(ch.out(), (U8*)ignore.c_str(), ignore.length());
-		mBuffer.append(ch.in(), (U8*)part3.c_str(), part3.length());
-		std::string eat;
-		std::string my;
-		std::string shorts;
-		std::string homer;
-		str >> eat >> my >> shorts >> homer;
-		ensure_equals("word1", eat, std::string("Eat"));
-		ensure_equals("word2", my, std::string("my"));
-		ensure_equals("word3", shorts, std::string("shorts"));
-		ensure_equals("word4", homer, std::string("homer"));
-	}
-
-	template<> template<>
-	void bas_object::test<3>()
-	{
-		std::string part1("junk in ");
-		std::string part2("the trunk");
-		const S32 CHANNEL = 0;
-		mBuffer.append(CHANNEL, (U8*)part1.c_str(), part1.length());
-		mBuffer.append(CHANNEL, (U8*)part2.c_str(), part2.length());
-		U8* last = 0;
-		const S32 BUF_LEN = 128;
-		char buf[BUF_LEN];
-		S32 len = 11;
-		last = mBuffer.readAfter(CHANNEL, last, (U8*)buf, len);
-		buf[len] = '\0';
-		std::string actual(buf);
-		ensure_equals("first read", actual, std::string("junk in the"));
-		last = mBuffer.seek(CHANNEL, last, -6);
-		len = 12;
-		last = mBuffer.readAfter(CHANNEL, last, (U8*)buf, len);
-		buf[len] = '\0';
-		actual.assign(buf);
-		ensure_equals("seek and read", actual, std::string("in the trunk"));
-	}
-
-	template<> template<>
-	void bas_object::test<4>()
-	{
-		std::string phrase("zippity do da!");
-		const S32 CHANNEL = 0;
-		mBuffer.append(CHANNEL, (U8*)phrase.c_str(), phrase.length());
-		const S32 BUF_LEN = 128;
-		char buf[BUF_LEN];
-		S32 len = 7;
-		U8* last = mBuffer.readAfter(CHANNEL, NULL, (U8*)buf, len);
-		mBuffer.splitAfter(last);
-		LLBufferArray::segment_iterator_t it = mBuffer.beginSegment();
-		LLBufferArray::segment_iterator_t end = mBuffer.endSegment();
-		std::string first((char*)((*it).data()), (*it).size());
-		ensure_equals("first part", first, std::string("zippity"));
-		++it;
-		std::string second((char*)((*it).data()), (*it).size());
-		ensure_equals("second part",	second, std::string(" do da!"));
-		++it;
-		ensure("iterators equal",	 (it == end));
-	}
-
-	template<> template<>
-	void bas_object::test<5>()
-	{
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		LLBufferStream str(ch, &mBuffer);
-		std::string h1("hello");
-		std::string h2(", how are you doing?");
-		std::string expected(h1);
-		expected.append(h2);
-		str << h1 << h2;
-		str.flush();
-		const S32 BUF_LEN = 128;
-		char buf[BUF_LEN];
-		S32 actual_len = BUF_LEN;
-		S32 expected_len = h1.size() + h2.size();
-		(void) mBuffer.readAfter(ch.out(), NULL, (U8*)buf, actual_len);
-		ensure_equals("streamed size", actual_len, expected_len);
-		buf[actual_len] = '\0';
-		std::string actual(buf);
-		ensure_equals("streamed to buf", actual, expected);
-	}
-
-	template<> template<>
-	void bas_object::test<6>()
-	{
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		LLBufferStream bstr(ch, &mBuffer);
-		std::ostringstream ostr;
-		std::vector<LLUUID> ids;
-		LLUUID id;
-		for(int i = 0; i < 5; ++i)
-		{
-			id.generate();
-			ids.push_back(id);
-		}
-		bstr << "SELECT concat(u.username, ' ', l.name) "
-			 << "FROM user u, user_last_name l "
-			 << "WHERE u.last_name_id = l.last_name_id"
-			 << " AND u.agent_id IN ('";
-		ostr << "SELECT concat(u.username, ' ', l.name) "
-			 << "FROM user u, user_last_name l "
-			 << "WHERE u.last_name_id = l.last_name_id"
-			 << " AND u.agent_id IN ('";
-		std::copy(
-			ids.begin(),
-			ids.end(),
-			std::ostream_iterator<LLUUID>(bstr, "','"));
-		std::copy(
-			ids.begin(),
-			ids.end(),
-			std::ostream_iterator<LLUUID>(ostr, "','"));
-		bstr.seekp(-2, std::ios::cur);
-		ostr.seekp(-2, std::ios::cur);
-		bstr << ") ";
-		ostr << ") ";
-		bstr.flush();
-		const S32 BUF_LEN = 512;
-		char buf[BUF_LEN];		/* Flawfinder: ignore */
-		S32 actual_len = BUF_LEN;
-		(void) mBuffer.readAfter(ch.out(), NULL, (U8*)buf, actual_len);
-		buf[actual_len] = '\0';
-		std::string actual(buf);
-		std::string expected(ostr.str());
-		ensure_equals("size of string in seek",actual.size(),expected.size());
-		ensure_equals("seek in ostream", actual, expected);
-	}
-
-	template<> template<>
-	void bas_object::test<7>()
-	{
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		LLBufferStream bstr(ch, &mBuffer);
-		bstr << "1";
-		bstr.flush();
-		S32 count = mBuffer.countAfter(ch.out(), NULL);
-		ensure_equals("buffer size 1", count, 1);
-		LLBufferArray buffer;
-		buffer.append(ch.out(), (U8*)"2", 1);
-		mBuffer.takeContents(buffer);
-		count = mBuffer.countAfter(ch.out(), NULL);
-		ensure_equals("buffer size 2", count, 2);
-		bstr << "3";
-		bstr.flush();
-		count = mBuffer.countAfter(ch.out(), NULL);
-		ensure_equals("buffer size 3", count, 3);
-		U8* temp = new U8[count];
-		mBuffer.readAfter(ch.out(), NULL, temp, count);
-		ensure("buffer content", (0 == memcmp(temp, (void*)"123", 3)));
-		delete[] temp;
-	}
-
-	template<> template<>
-	void bas_object::test<8>()
-	{
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		LLBufferStream ostr(ch, &mBuffer);
-		typedef std::vector<U8> buf_t;
-		typedef std::vector<buf_t> actual_t;
-		actual_t actual;
-		buf_t source;
-		bool need_comma = false;
-		ostr << "[";
-		S32 total_size = 1;
-		for(S32 i = 2000; i < 2003; ++i)
-		{
-			if(need_comma)
-			{
-				ostr << ",";
-				++total_size;
-			}
-			need_comma = true;
-			srand(69 + i);	/* Flawfinder: ignore */
-			S32 size = rand() % 1000 + 1000;
-			std::generate_n(
-				std::back_insert_iterator<buf_t>(source),
-				size,
-				rand);
-			actual.push_back(source);
-			ostr << "b(" << size << ")\"";
-			total_size += 8;
-			ostr.write((const char*)(&source[0]), size);
-			total_size += size;
-			source.clear();
-			ostr << "\"";
-			++total_size;
-		}
-		ostr << "]";
-		++total_size;
-		ostr.flush();
-
-		// now that we have a bunch of data on a stream, parse it all.
-		ch = mBuffer.nextChannel();
-		S32 count = mBuffer.countAfter(ch.in(), NULL);
-		ensure_equals("size of buffer", count, total_size);
-		LLBufferStream istr(ch, &mBuffer);
-		LLSD data;
-		count = LLSDSerialize::fromNotation(data, istr, total_size);
-		ensure("sd parsed", data.isDefined());
-
-		for(S32 j = 0; j < 3; ++j)
-		{
-			std::ostringstream name;
-			LLSD child(data[j]);
-			name << "found buffer " << j;
-			ensure(name.str(), child.isDefined());
-			source = child.asBinary();
-			name.str("");
-			name << "buffer " << j << " size";
-			ensure_equals(name.str().c_str(), source.size(), actual[j].size());
-			name.str("");
-			name << "buffer " << j << " contents";
-			ensure(
-				name.str(),
-				(0 == memcmp(&source[0], &actual[j][0], source.size())));
-		}
-	}
-
-	template<> template<>
-	void bas_object::test<9>()
-	{
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		LLBufferStream ostr(ch, &mBuffer);
-		typedef std::vector<U8> buf_t;
-		buf_t source;
-		bool need_comma = false;
-		ostr << "{";
-		S32 total_size = 1;
-		for(S32 i = 1000; i < 3000; ++i)
-		{
-			if(need_comma)
-			{
-				ostr << ",";
-				++total_size;
-			}
-			need_comma = true;
-			ostr << "'" << i << "':";
-			total_size += 7;
-			srand(69 + i);		/* Flawfinder: ignore */
-			S32 size = rand() % 1000 + 1000;
-			std::generate_n(
-				std::back_insert_iterator<buf_t>(source),
-				size,
-				rand);
-			ostr << "b(" << size << ")\"";
-			total_size += 8;
-			ostr.write((const char*)(&source[0]), size);
-			total_size += size;
-			source.clear();
-			ostr << "\"";
-			++total_size;
-		}
-		ostr << "}";
-		++total_size;
-		ostr.flush();
-
-		// now that we have a bunch of data on a stream, parse it all.
-		ch = mBuffer.nextChannel();
-		S32 count = mBuffer.countAfter(ch.in(), NULL);
-		ensure_equals("size of buffer", count, total_size);
-		LLBufferStream istr(ch, &mBuffer);
-		LLSD data;
-		count = LLSDSerialize::fromNotation(data, istr, total_size);
-		ensure("sd parsed", data.isDefined());
-	}
-
-	template<> template<>
-	void bas_object::test<10>()
-	{
+    struct buffer_and_stream_data
+    {
+        LLBufferArray mBuffer;
+    };
+    typedef test_group<buffer_and_stream_data> bas_test;
+    typedef bas_test::object bas_object;
+    tut::bas_test tbs("buffer_stream");
+
+    template<> template<>
+    void bas_object::test<1>()
+    {
+        const char HELLO_WORLD[] = "hello world";
+        const S32 str_len = strlen(HELLO_WORLD);    /* Flawfinder: ignore */
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        LLBufferStream str(ch, &mBuffer);
+        mBuffer.append(ch.in(), (U8*)HELLO_WORLD, str_len);
+        std::string hello;
+        std::string world;
+        str >> hello >> world;
+        ensure_equals("first word", hello, std::string("hello"));
+        ensure_equals("second word", world, std::string("world"));
+    }
+
+    template<> template<>
+    void bas_object::test<2>()
+    {
+        std::string part1("Eat my shor");
+        std::string part2("ts ho");
+        std::string part3("mer");
+        std::string ignore("ignore me");
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        LLBufferStream str(ch, &mBuffer);
+        mBuffer.append(ch.in(), (U8*)part1.c_str(), part1.length());
+        mBuffer.append(ch.in(), (U8*)part2.c_str(), part2.length());
+        mBuffer.append(ch.out(), (U8*)ignore.c_str(), ignore.length());
+        mBuffer.append(ch.in(), (U8*)part3.c_str(), part3.length());
+        std::string eat;
+        std::string my;
+        std::string shorts;
+        std::string homer;
+        str >> eat >> my >> shorts >> homer;
+        ensure_equals("word1", eat, std::string("Eat"));
+        ensure_equals("word2", my, std::string("my"));
+        ensure_equals("word3", shorts, std::string("shorts"));
+        ensure_equals("word4", homer, std::string("homer"));
+    }
+
+    template<> template<>
+    void bas_object::test<3>()
+    {
+        std::string part1("junk in ");
+        std::string part2("the trunk");
+        const S32 CHANNEL = 0;
+        mBuffer.append(CHANNEL, (U8*)part1.c_str(), part1.length());
+        mBuffer.append(CHANNEL, (U8*)part2.c_str(), part2.length());
+        U8* last = 0;
+        const S32 BUF_LEN = 128;
+        char buf[BUF_LEN];
+        S32 len = 11;
+        last = mBuffer.readAfter(CHANNEL, last, (U8*)buf, len);
+        buf[len] = '\0';
+        std::string actual(buf);
+        ensure_equals("first read", actual, std::string("junk in the"));
+        last = mBuffer.seek(CHANNEL, last, -6);
+        len = 12;
+        last = mBuffer.readAfter(CHANNEL, last, (U8*)buf, len);
+        buf[len] = '\0';
+        actual.assign(buf);
+        ensure_equals("seek and read", actual, std::string("in the trunk"));
+    }
+
+    template<> template<>
+    void bas_object::test<4>()
+    {
+        std::string phrase("zippity do da!");
+        const S32 CHANNEL = 0;
+        mBuffer.append(CHANNEL, (U8*)phrase.c_str(), phrase.length());
+        const S32 BUF_LEN = 128;
+        char buf[BUF_LEN];
+        S32 len = 7;
+        U8* last = mBuffer.readAfter(CHANNEL, NULL, (U8*)buf, len);
+        mBuffer.splitAfter(last);
+        LLBufferArray::segment_iterator_t it = mBuffer.beginSegment();
+        LLBufferArray::segment_iterator_t end = mBuffer.endSegment();
+        std::string first((char*)((*it).data()), (*it).size());
+        ensure_equals("first part", first, std::string("zippity"));
+        ++it;
+        std::string second((char*)((*it).data()), (*it).size());
+        ensure_equals("second part",    second, std::string(" do da!"));
+        ++it;
+        ensure("iterators equal",    (it == end));
+    }
+
+    template<> template<>
+    void bas_object::test<5>()
+    {
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        LLBufferStream str(ch, &mBuffer);
+        std::string h1("hello");
+        std::string h2(", how are you doing?");
+        std::string expected(h1);
+        expected.append(h2);
+        str << h1 << h2;
+        str.flush();
+        const S32 BUF_LEN = 128;
+        char buf[BUF_LEN];
+        S32 actual_len = BUF_LEN;
+        S32 expected_len = h1.size() + h2.size();
+        (void) mBuffer.readAfter(ch.out(), NULL, (U8*)buf, actual_len);
+        ensure_equals("streamed size", actual_len, expected_len);
+        buf[actual_len] = '\0';
+        std::string actual(buf);
+        ensure_equals("streamed to buf", actual, expected);
+    }
+
+    template<> template<>
+    void bas_object::test<6>()
+    {
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        LLBufferStream bstr(ch, &mBuffer);
+        std::ostringstream ostr;
+        std::vector<LLUUID> ids;
+        LLUUID id;
+        for(int i = 0; i < 5; ++i)
+        {
+            id.generate();
+            ids.push_back(id);
+        }
+        bstr << "SELECT concat(u.username, ' ', l.name) "
+             << "FROM user u, user_last_name l "
+             << "WHERE u.last_name_id = l.last_name_id"
+             << " AND u.agent_id IN ('";
+        ostr << "SELECT concat(u.username, ' ', l.name) "
+             << "FROM user u, user_last_name l "
+             << "WHERE u.last_name_id = l.last_name_id"
+             << " AND u.agent_id IN ('";
+        std::copy(
+            ids.begin(),
+            ids.end(),
+            std::ostream_iterator<LLUUID>(bstr, "','"));
+        std::copy(
+            ids.begin(),
+            ids.end(),
+            std::ostream_iterator<LLUUID>(ostr, "','"));
+        bstr.seekp(-2, std::ios::cur);
+        ostr.seekp(-2, std::ios::cur);
+        bstr << ") ";
+        ostr << ") ";
+        bstr.flush();
+        const S32 BUF_LEN = 512;
+        char buf[BUF_LEN];      /* Flawfinder: ignore */
+        S32 actual_len = BUF_LEN;
+        (void) mBuffer.readAfter(ch.out(), NULL, (U8*)buf, actual_len);
+        buf[actual_len] = '\0';
+        std::string actual(buf);
+        std::string expected(ostr.str());
+        ensure_equals("size of string in seek",actual.size(),expected.size());
+        ensure_equals("seek in ostream", actual, expected);
+    }
+
+    template<> template<>
+    void bas_object::test<7>()
+    {
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        LLBufferStream bstr(ch, &mBuffer);
+        bstr << "1";
+        bstr.flush();
+        S32 count = mBuffer.countAfter(ch.out(), NULL);
+        ensure_equals("buffer size 1", count, 1);
+        LLBufferArray buffer;
+        buffer.append(ch.out(), (U8*)"2", 1);
+        mBuffer.takeContents(buffer);
+        count = mBuffer.countAfter(ch.out(), NULL);
+        ensure_equals("buffer size 2", count, 2);
+        bstr << "3";
+        bstr.flush();
+        count = mBuffer.countAfter(ch.out(), NULL);
+        ensure_equals("buffer size 3", count, 3);
+        U8* temp = new U8[count];
+        mBuffer.readAfter(ch.out(), NULL, temp, count);
+        ensure("buffer content", (0 == memcmp(temp, (void*)"123", 3)));
+        delete[] temp;
+    }
+
+    template<> template<>
+    void bas_object::test<8>()
+    {
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        LLBufferStream ostr(ch, &mBuffer);
+        typedef std::vector<U8> buf_t;
+        typedef std::vector<buf_t> actual_t;
+        actual_t actual;
+        buf_t source;
+        bool need_comma = false;
+        ostr << "[";
+        S32 total_size = 1;
+        for(S32 i = 2000; i < 2003; ++i)
+        {
+            if(need_comma)
+            {
+                ostr << ",";
+                ++total_size;
+            }
+            need_comma = true;
+            srand(69 + i);  /* Flawfinder: ignore */
+            S32 size = rand() % 1000 + 1000;
+            std::generate_n(
+                std::back_insert_iterator<buf_t>(source),
+                size,
+                rand);
+            actual.push_back(source);
+            ostr << "b(" << size << ")\"";
+            total_size += 8;
+            ostr.write((const char*)(&source[0]), size);
+            total_size += size;
+            source.clear();
+            ostr << "\"";
+            ++total_size;
+        }
+        ostr << "]";
+        ++total_size;
+        ostr.flush();
+
+        // now that we have a bunch of data on a stream, parse it all.
+        ch = mBuffer.nextChannel();
+        S32 count = mBuffer.countAfter(ch.in(), NULL);
+        ensure_equals("size of buffer", count, total_size);
+        LLBufferStream istr(ch, &mBuffer);
+        LLSD data;
+        count = LLSDSerialize::fromNotation(data, istr, total_size);
+        ensure("sd parsed", data.isDefined());
+
+        for(S32 j = 0; j < 3; ++j)
+        {
+            std::ostringstream name;
+            LLSD child(data[j]);
+            name << "found buffer " << j;
+            ensure(name.str(), child.isDefined());
+            source = child.asBinary();
+            name.str("");
+            name << "buffer " << j << " size";
+            ensure_equals(name.str().c_str(), source.size(), actual[j].size());
+            name.str("");
+            name << "buffer " << j << " contents";
+            ensure(
+                name.str(),
+                (0 == memcmp(&source[0], &actual[j][0], source.size())));
+        }
+    }
+
+    template<> template<>
+    void bas_object::test<9>()
+    {
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        LLBufferStream ostr(ch, &mBuffer);
+        typedef std::vector<U8> buf_t;
+        buf_t source;
+        bool need_comma = false;
+        ostr << "{";
+        S32 total_size = 1;
+        for(S32 i = 1000; i < 3000; ++i)
+        {
+            if(need_comma)
+            {
+                ostr << ",";
+                ++total_size;
+            }
+            need_comma = true;
+            ostr << "'" << i << "':";
+            total_size += 7;
+            srand(69 + i);      /* Flawfinder: ignore */
+            S32 size = rand() % 1000 + 1000;
+            std::generate_n(
+                std::back_insert_iterator<buf_t>(source),
+                size,
+                rand);
+            ostr << "b(" << size << ")\"";
+            total_size += 8;
+            ostr.write((const char*)(&source[0]), size);
+            total_size += size;
+            source.clear();
+            ostr << "\"";
+            ++total_size;
+        }
+        ostr << "}";
+        ++total_size;
+        ostr.flush();
+
+        // now that we have a bunch of data on a stream, parse it all.
+        ch = mBuffer.nextChannel();
+        S32 count = mBuffer.countAfter(ch.in(), NULL);
+        ensure_equals("size of buffer", count, total_size);
+        LLBufferStream istr(ch, &mBuffer);
+        LLSD data;
+        count = LLSDSerialize::fromNotation(data, istr, total_size);
+        ensure("sd parsed", data.isDefined());
+    }
+
+    template<> template<>
+    void bas_object::test<10>()
+    {
 //#if LL_WINDOWS && _MSC_VER >= 1400
 //        skip_fail("Fails on VS2005 due to broken LLSDSerialize::fromNotation() parser.");
 //#endif
-		const char LOGIN_STREAM[] = "{'method':'login', 'parameter': [ {"
-										"'uri': 'sl-am:kellys.region.siva.lindenlab.com/location?start=url&px=128&py=128&pz=128&lx=0&ly=0&lz=0'}, "
-										"{'version': i1}, {'texture_data': [ '61d724fb-ad79-f637-2186-5cf457560daa', '6e38b9be-b7cc-e77a-8aec-029a42b0b416', "
-										"'a9073524-e89b-2924-ca6e-a81944109a1a', '658f18b5-5f1e-e593-f5d5-36c3abc7249a', '0cc799f4-8c99-6b91-bd75-b179b12429e2', "
-										"'59fd9b64-8300-a425-aad8-2ffcbe9a49d2', '59fd9b64-8300-a425-aad8-2ffcbe9a49d2', '5748decc-f629-461c-9a36-a35a221fe21f', "
-										"'b8fc9be2-26a6-6b47-690b-0e902e983484', 'a13ca0fe-3802-dc97-e79a-70d12171c724', 'dd9643cf-fd5d-0376-ed4a-b1cc646a97d5', "
-										"'4ad13ae9-a112-af09-210a-cf9353a7a9e7', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', "
-										"'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', "
-										"'5748decc-f629-461c-9a36-a35a221fe21f', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97'],"
-										"'session_id': '324cfa9f-fe5d-4d1c-a317-35f20a86a4d1','position': [ i128, i128, i128],'last_name': 'Linden','group_title': '-> !BLING! <-','group_name': 'test!','agent_access': 'M',"
-										"'attachment_data': [ {'asset_id': 'aaede2b1-9955-09d4-5c93-2b557c778cf3','attachment_point': i6,'item_id': 'f3694abc-5122-db33-73d9-e0f4288dc2bf'}],"
-										"'buddy_ids': [ '101358d5-469d-4b24-9b85-4dc3c05e635d', '1b00fec7-6265-4875-acac-80d9cfe9295c', '203ad6df-b522-491d-ba48-4e24eb57aeff', "
-										"'22d4dcdb-aebb-47fa-b925-a871cc75ee48','27da3df5-1339-4463-80aa-40504ee3b3e5', '299d1720-b61f-4268-8c29-9614aa2d44c2', "
-										"'2b048a24-2737-4994-9fa5-becc8e466253', '2cd5dc14-a853-49a4-be3c-a5a7178e37bc', '3de548e1-57be-cfea-2b78-83ae3ad95998', "
-										"'3dee98e4-a6a3-4543-91c3-bbd528447ba7', '3e2d81a3-6263-6ffe-ad5c-8ce04bee07e9', '40e70b98-fed7-47f3-9700-1bce93f9350b', "
-										"'50a9b68e-b5aa-4d35-9137-3cfebda0a15c', '54295571-9357-43ff-ae74-a83b5138160f', '6191e2d7-5f96-4856-bdab-af0f79f47ae4', "
-										"'63e577d8-cd34-4235-a0a3-de0500133364', '79cfb666-4fd0-4af7-95df-fb7d96b4e24d', '8121c2f3-4a88-4c33-9899-8fc1273f47ee', "
-										"'909da964-ef23-4f2a-ba13-f2a8cfd454b6','a2e76fcd-9360-4f6d-a924-000000000001', 'aaa6d664-527e-4d83-9cbb-7ef79ccc7cc8', "
-										"'b79bfb6c-23be-49eb-b35b-30ff2f501b37', 'ba0d9c79-148c-4a79-8e3c-0665eebe2427', 'bc9bda98-57cd-498f-b993-4ff1ac9dec93', "
-										"'c62d16f6-81cb-419d-9cac-e46dc394084d', 'd48f8fa7-2512-4fe5-80c8-c0a923412e07', 'd77e3e24-7e6c-4c3f-96d0-a1746337f8fb', "
-										"'da615c63-a84b-4592-a3d6-a90dd3e92e6e', 'df47190a-7eb7-4aff-985f-2d1d3ad6c6e9', 'e3380196-72cd-499c-a2ba-caa180bd5fe4', "
-										"'e937863f-f134-4207-803b-d6e686651d6c', 'efcdf98b-5269-45ef-ac7a-0671f09ea9d9'],"
-										"'circuit_code': i124,'group_id': '8615c885-9cf0-bf0a-6e40-0c11462aa652','limited_to_estate': i1,'look_at': [ i0, i0, i0],"
-										"'agent_id': '0e346d8b-4433-4d66-a6b0-fd37083abc4c','first_name': 'Kelly','start': 'url'}]}";
-		LLChannelDescriptors ch = mBuffer.nextChannel();
-		mBuffer.append(ch.out(), (U8*)LOGIN_STREAM, strlen(LOGIN_STREAM));		/* Flawfinder: ignore */
-		ch = mBuffer.nextChannel();
-		LLBufferStream istr(ch, &mBuffer);
-		LLSD data;
-		S32 count = LLSDSerialize::fromNotation(
-			data,
-			istr,
-			mBuffer.count(ch.in()));
-		ensure("parsed something", (count > 0));
-		ensure("sd parsed", data.isDefined());
-		ensure_equals("sd type", data.type(), LLSD::TypeMap);
-		ensure("has method", data.has("method"));
-		ensure("has parameter", data.has("parameter"));
-		LLSD parameter = data["parameter"];
-		ensure_equals("parameter is array", parameter.type(), LLSD::TypeArray);
-		LLSD agent_params = parameter[2];
-		std::string s_value;
-		s_value = agent_params["last_name"].asString();
-		ensure_equals("last name", s_value, std::string("Linden"));
-		s_value = agent_params["first_name"].asString();
-		ensure_equals("first name", s_value, std::string("Kelly"));
-		s_value = agent_params["agent_access"].asString();
-		ensure_equals("agent access", s_value, std::string("M"));
-		s_value = agent_params["group_name"].asString();
-		ensure_equals("group name", s_value, std::string("test!"));
-		s_value = agent_params["group_title"].asString();
-		ensure_equals("group title", s_value, std::string("-> !BLING! <-"));
-
-		LLUUID agent_id("0e346d8b-4433-4d66-a6b0-fd37083abc4c");
-		LLUUID id = agent_params["agent_id"];
-		ensure_equals("agent id", id, agent_id);
-		LLUUID session_id("324cfa9f-fe5d-4d1c-a317-35f20a86a4d1");
-		id = agent_params["session_id"];
-		ensure_equals("session id", id, session_id);
-		LLUUID group_id ("8615c885-9cf0-bf0a-6e40-0c11462aa652");
-		id = agent_params["group_id"];
-		ensure_equals("group id", id, group_id);
-
-		S32 i_val = agent_params["limited_to_estate"];
-		ensure_equals("limited to estate", i_val, 1);
-		i_val = agent_params["circuit_code"];
-		ensure_equals("circuit code", i_val, 124);
-	}
-
-
-	template<> template<>
-	void bas_object::test<11>()
-	{
-		std::string val = "{!'foo'@:#'bar'}";
-		std::istringstream istr;
-		istr.str(val);
-		LLSD sd;
-		S32 count = LLSDSerialize::fromNotation(sd, istr, val.size());
-		ensure_equals("parser error return value", count, -1);
-		ensure("data undefined", sd.isUndefined());
-	}
-
-	template<> template<>
-	void bas_object::test<12>()
-	{
+        const char LOGIN_STREAM[] = "{'method':'login', 'parameter': [ {"
+                                        "'uri': 'sl-am:kellys.region.siva.lindenlab.com/location?start=url&px=128&py=128&pz=128&lx=0&ly=0&lz=0'}, "
+                                        "{'version': i1}, {'texture_data': [ '61d724fb-ad79-f637-2186-5cf457560daa', '6e38b9be-b7cc-e77a-8aec-029a42b0b416', "
+                                        "'a9073524-e89b-2924-ca6e-a81944109a1a', '658f18b5-5f1e-e593-f5d5-36c3abc7249a', '0cc799f4-8c99-6b91-bd75-b179b12429e2', "
+                                        "'59fd9b64-8300-a425-aad8-2ffcbe9a49d2', '59fd9b64-8300-a425-aad8-2ffcbe9a49d2', '5748decc-f629-461c-9a36-a35a221fe21f', "
+                                        "'b8fc9be2-26a6-6b47-690b-0e902e983484', 'a13ca0fe-3802-dc97-e79a-70d12171c724', 'dd9643cf-fd5d-0376-ed4a-b1cc646a97d5', "
+                                        "'4ad13ae9-a112-af09-210a-cf9353a7a9e7', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', "
+                                        "'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', "
+                                        "'5748decc-f629-461c-9a36-a35a221fe21f', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97', 'c228d1cf-4b5d-4ba8-84f4-899a0796aa97'],"
+                                        "'session_id': '324cfa9f-fe5d-4d1c-a317-35f20a86a4d1','position': [ i128, i128, i128],'last_name': 'Linden','group_title': '-> !BLING! <-','group_name': 'test!','agent_access': 'M',"
+                                        "'attachment_data': [ {'asset_id': 'aaede2b1-9955-09d4-5c93-2b557c778cf3','attachment_point': i6,'item_id': 'f3694abc-5122-db33-73d9-e0f4288dc2bf'}],"
+                                        "'buddy_ids': [ '101358d5-469d-4b24-9b85-4dc3c05e635d', '1b00fec7-6265-4875-acac-80d9cfe9295c', '203ad6df-b522-491d-ba48-4e24eb57aeff', "
+                                        "'22d4dcdb-aebb-47fa-b925-a871cc75ee48','27da3df5-1339-4463-80aa-40504ee3b3e5', '299d1720-b61f-4268-8c29-9614aa2d44c2', "
+                                        "'2b048a24-2737-4994-9fa5-becc8e466253', '2cd5dc14-a853-49a4-be3c-a5a7178e37bc', '3de548e1-57be-cfea-2b78-83ae3ad95998', "
+                                        "'3dee98e4-a6a3-4543-91c3-bbd528447ba7', '3e2d81a3-6263-6ffe-ad5c-8ce04bee07e9', '40e70b98-fed7-47f3-9700-1bce93f9350b', "
+                                        "'50a9b68e-b5aa-4d35-9137-3cfebda0a15c', '54295571-9357-43ff-ae74-a83b5138160f', '6191e2d7-5f96-4856-bdab-af0f79f47ae4', "
+                                        "'63e577d8-cd34-4235-a0a3-de0500133364', '79cfb666-4fd0-4af7-95df-fb7d96b4e24d', '8121c2f3-4a88-4c33-9899-8fc1273f47ee', "
+                                        "'909da964-ef23-4f2a-ba13-f2a8cfd454b6','a2e76fcd-9360-4f6d-a924-000000000001', 'aaa6d664-527e-4d83-9cbb-7ef79ccc7cc8', "
+                                        "'b79bfb6c-23be-49eb-b35b-30ff2f501b37', 'ba0d9c79-148c-4a79-8e3c-0665eebe2427', 'bc9bda98-57cd-498f-b993-4ff1ac9dec93', "
+                                        "'c62d16f6-81cb-419d-9cac-e46dc394084d', 'd48f8fa7-2512-4fe5-80c8-c0a923412e07', 'd77e3e24-7e6c-4c3f-96d0-a1746337f8fb', "
+                                        "'da615c63-a84b-4592-a3d6-a90dd3e92e6e', 'df47190a-7eb7-4aff-985f-2d1d3ad6c6e9', 'e3380196-72cd-499c-a2ba-caa180bd5fe4', "
+                                        "'e937863f-f134-4207-803b-d6e686651d6c', 'efcdf98b-5269-45ef-ac7a-0671f09ea9d9'],"
+                                        "'circuit_code': i124,'group_id': '8615c885-9cf0-bf0a-6e40-0c11462aa652','limited_to_estate': i1,'look_at': [ i0, i0, i0],"
+                                        "'agent_id': '0e346d8b-4433-4d66-a6b0-fd37083abc4c','first_name': 'Kelly','start': 'url'}]}";
+        LLChannelDescriptors ch = mBuffer.nextChannel();
+        mBuffer.append(ch.out(), (U8*)LOGIN_STREAM, strlen(LOGIN_STREAM));      /* Flawfinder: ignore */
+        ch = mBuffer.nextChannel();
+        LLBufferStream istr(ch, &mBuffer);
+        LLSD data;
+        S32 count = LLSDSerialize::fromNotation(
+            data,
+            istr,
+            mBuffer.count(ch.in()));
+        ensure("parsed something", (count > 0));
+        ensure("sd parsed", data.isDefined());
+        ensure_equals("sd type", data.type(), LLSD::TypeMap);
+        ensure("has method", data.has("method"));
+        ensure("has parameter", data.has("parameter"));
+        LLSD parameter = data["parameter"];
+        ensure_equals("parameter is array", parameter.type(), LLSD::TypeArray);
+        LLSD agent_params = parameter[2];
+        std::string s_value;
+        s_value = agent_params["last_name"].asString();
+        ensure_equals("last name", s_value, std::string("Linden"));
+        s_value = agent_params["first_name"].asString();
+        ensure_equals("first name", s_value, std::string("Kelly"));
+        s_value = agent_params["agent_access"].asString();
+        ensure_equals("agent access", s_value, std::string("M"));
+        s_value = agent_params["group_name"].asString();
+        ensure_equals("group name", s_value, std::string("test!"));
+        s_value = agent_params["group_title"].asString();
+        ensure_equals("group title", s_value, std::string("-> !BLING! <-"));
+
+        LLUUID agent_id("0e346d8b-4433-4d66-a6b0-fd37083abc4c");
+        LLUUID id = agent_params["agent_id"];
+        ensure_equals("agent id", id, agent_id);
+        LLUUID session_id("324cfa9f-fe5d-4d1c-a317-35f20a86a4d1");
+        id = agent_params["session_id"];
+        ensure_equals("session id", id, session_id);
+        LLUUID group_id ("8615c885-9cf0-bf0a-6e40-0c11462aa652");
+        id = agent_params["group_id"];
+        ensure_equals("group id", id, group_id);
+
+        S32 i_val = agent_params["limited_to_estate"];
+        ensure_equals("limited to estate", i_val, 1);
+        i_val = agent_params["circuit_code"];
+        ensure_equals("circuit code", i_val, 124);
+    }
+
+
+    template<> template<>
+    void bas_object::test<11>()
+    {
+        std::string val = "{!'foo'@:#'bar'}";
+        std::istringstream istr;
+        istr.str(val);
+        LLSD sd;
+        S32 count = LLSDSerialize::fromNotation(sd, istr, val.size());
+        ensure_equals("parser error return value", count, -1);
+        ensure("data undefined", sd.isUndefined());
+    }
+
+    template<> template<>
+    void bas_object::test<12>()
+    {
 //#if LL_WINDOWS && _MSC_VER >= 1400
 //        skip_fail("Fails on VS2005 due to broken LLSDSerialize::fromNotation() parser.");
 //#endif
-		std::string val = "{!'foo':[i1,'hi',{@'bar'#:[$i2%,^'baz'&]*}+]=}";
-		std::istringstream istr;
-		istr.str(val);
-		LLSD sd;
-		S32 count = LLSDSerialize::fromNotation(sd, istr, val.size());
-		ensure_equals("parser error return value", count, -1);
-		ensure("data undefined", sd.isUndefined());
-	}
+        std::string val = "{!'foo':[i1,'hi',{@'bar'#:[$i2%,^'baz'&]*}+]=}";
+        std::istringstream istr;
+        istr.str(val);
+        LLSD sd;
+        S32 count = LLSDSerialize::fromNotation(sd, istr, val.size());
+        ensure_equals("parser error return value", count, -1);
+        ensure("data undefined", sd.isUndefined());
+    }
 
 /*
-	template<> template<>
-	void bas_object::test<13>()
-	{
-	}
-	template<> template<>
-	void bas_object::test<14>()
-	{
-	}
-	template<> template<>
-	void bas_object::test<15>()
-	{
-	}
+    template<> template<>
+    void bas_object::test<13>()
+    {
+    }
+    template<> template<>
+    void bas_object::test<14>()
+    {
+    }
+    template<> template<>
+    void bas_object::test<15>()
+    {
+    }
 */
 }
 
 
 namespace tut
 {
-	class PumpAndChainTestData
-	{
-	protected:
-		apr_pool_t* mPool;
-		LLPumpIO* mPump;
-		LLPumpIO::chain_t mChain;
-		
-	public:
-		PumpAndChainTestData()
-		{
-			apr_pool_create(&mPool, NULL);
-			mPump = new LLPumpIO(mPool);
-		}
-		
-		~PumpAndChainTestData()
-		{
-			mChain.clear();
-			delete mPump;
-			apr_pool_destroy(mPool);
-		}
-	};
-	typedef test_group<PumpAndChainTestData>	PumpAndChainTestGroup;
-	typedef PumpAndChainTestGroup::object		PumpAndChainTestObject;
-	PumpAndChainTestGroup pumpAndChainTestGroup("pump_and_chain");
-
-	template<> template<>
-	void PumpAndChainTestObject::test<1>()
-	{
-		LLPipeStringExtractor* extractor = new LLPipeStringExtractor();
-
-		mChain.push_back(LLIOPipe::ptr_t(new LLIOFlush));
-		mChain.push_back(LLIOPipe::ptr_t(extractor));
-
-		LLTimer timer;
-		timer.setTimerExpirySec(100.0f);
-
-		mPump->addChain(mChain, DEFAULT_CHAIN_EXPIRY_SECS);
-		while(!extractor->done() && !timer.hasExpired())
-		{
-			mPump->pump();
-			mPump->callback();
-		}
-		
-		ensure("reading string finished", extractor->done());
-		ensure_equals("string was empty", extractor->string(), "");
-	}
+    class PumpAndChainTestData
+    {
+    protected:
+        apr_pool_t* mPool;
+        LLPumpIO* mPump;
+        LLPumpIO::chain_t mChain;
+
+    public:
+        PumpAndChainTestData()
+        {
+            apr_pool_create(&mPool, NULL);
+            mPump = new LLPumpIO(mPool);
+        }
+
+        ~PumpAndChainTestData()
+        {
+            mChain.clear();
+            delete mPump;
+            apr_pool_destroy(mPool);
+        }
+    };
+    typedef test_group<PumpAndChainTestData>    PumpAndChainTestGroup;
+    typedef PumpAndChainTestGroup::object       PumpAndChainTestObject;
+    PumpAndChainTestGroup pumpAndChainTestGroup("pump_and_chain");
+
+    template<> template<>
+    void PumpAndChainTestObject::test<1>()
+    {
+        LLPipeStringExtractor* extractor = new LLPipeStringExtractor();
+
+        mChain.push_back(LLIOPipe::ptr_t(new LLIOFlush));
+        mChain.push_back(LLIOPipe::ptr_t(extractor));
+
+        LLTimer timer;
+        timer.setTimerExpirySec(100.0f);
+
+        mPump->addChain(mChain, DEFAULT_CHAIN_EXPIRY_SECS);
+        while(!extractor->done() && !timer.hasExpired())
+        {
+            mPump->pump();
+            mPump->callback();
+        }
+
+        ensure("reading string finished", extractor->done());
+        ensure_equals("string was empty", extractor->string(), "");
+    }
 }
 
 /*
 namespace tut
 {
-	struct double_construct
-	{
-	public:
-		double_construct()
-		{
-			LL_INFOS() << "constructed" << LL_ENDL;
-		}
-		~double_construct()
-		{
-			LL_INFOS() << "destroyed" << LL_ENDL;
-		}
-	};
-	typedef test_group<double_construct> double_construct_test_group;
-	typedef double_construct_test_group::object dc_test_object;
-	double_construct_test_group dctest("double construct");
-	template<> template<>
-	void dc_test_object::test<1>()
-	{
-		ensure("test 1", true);
-	}
+    struct double_construct
+    {
+    public:
+        double_construct()
+        {
+            LL_INFOS() << "constructed" << LL_ENDL;
+        }
+        ~double_construct()
+        {
+            LL_INFOS() << "destroyed" << LL_ENDL;
+        }
+    };
+    typedef test_group<double_construct> double_construct_test_group;
+    typedef double_construct_test_group::object dc_test_object;
+    double_construct_test_group dctest("double construct");
+    template<> template<>
+    void dc_test_object::test<1>()
+    {
+        ensure("test 1", true);
+    }
 }
 */
 
 namespace tut
 {
-	/**
-	 * @brief we want to test the pipes & pumps under bad conditions.
-	 */
-	struct pipe_and_pump_fitness
-	{
-	public:
-		enum
-		{
-			SERVER_LISTEN_PORT = 13050
-		};
-		
-		pipe_and_pump_fitness()
-		{
-			LLFrameTimer::updateFrameTime();
-			apr_pool_create(&mPool, NULL);
-			mPump = new LLPumpIO(mPool);
-			mSocket = LLSocket::create(
-				mPool,
-				LLSocket::STREAM_TCP,
-				SERVER_LISTEN_PORT,
-				"127.0.0.1");
-		}
-
-		~pipe_and_pump_fitness()
-		{
-			mSocket.reset();
-			delete mPump;
-			apr_pool_destroy(mPool);
-		}
-
-	protected:
-		apr_pool_t* mPool;
-		LLPumpIO* mPump;
-		LLSocket::ptr_t mSocket;
-	};
-	typedef test_group<pipe_and_pump_fitness> fitness_test_group;
-	typedef fitness_test_group::object fitness_test_object;
-	fitness_test_group fitness("pipe and pump fitness");
-
-	template<> template<>
-	void fitness_test_object::test<1>()
-	{
-		LL_DEBUGS() << "fitness_test_object::test<1>()" << LL_ENDL;
-
-		// Set up the server
-		//LL_DEBUGS() << "fitness_test_object::test<1> - setting up server."
-		//	 << LL_ENDL;
-		LLPumpIO::chain_t chain;
-		typedef LLCloneIOFactory<LLPipeStringInjector> emitter_t;
-		emitter_t* emitter = new emitter_t(
-			new LLPipeStringInjector("suckers never play me"));
-		std::shared_ptr<LLChainIOFactory> factory(emitter);
-		LLIOServerSocket* server = new LLIOServerSocket(
-			mPool,
-			mSocket,
-			factory);
-		server->setResponseTimeout(SHORT_CHAIN_EXPIRY_SECS);
-		chain.push_back(LLIOPipe::ptr_t(server));
-		mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
-
-		// We need to tickle the pump a little to set up the listen()
-		//LL_DEBUGS() << "fitness_test_object::test<1> - initializing server."
-		//	 << LL_ENDL;
-		pump_loop(mPump, 0.1f);
-
-		// Set up the client
-		//LL_DEBUGS() << "fitness_test_object::test<1> - connecting client."
-		//	 << LL_ENDL;
-		LLSocket::ptr_t client = LLSocket::create(mPool, LLSocket::STREAM_TCP);
-		LLHost server_host("127.0.0.1", SERVER_LISTEN_PORT);
-		bool connected = client->blockingConnect(server_host);
-		ensure("Connected to server", connected);
-		LL_DEBUGS() << "connected" << LL_ENDL;
-
-		// We have connected, since the socket reader does not block,
-		// the first call to read data will return EAGAIN, so we need
-		// to write something.
-		chain.clear();
-		chain.push_back(LLIOPipe::ptr_t(new LLPipeStringInjector("hi")));
-		chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(client)));
-		chain.push_back(LLIOPipe::ptr_t(new LLIONull));
-		mPump->addChain(chain, 1.0f);
-
-		// Now, the server should immediately send the data, but we'll
-		// never read it. pump for a bit
-		F32 elapsed = pump_loop(mPump, 2.0f);
-		ensure("Did not take too long", (elapsed < 3.0f));
-	}
-
-	template<> template<>
-	void fitness_test_object::test<2>()
-	{
-		LL_DEBUGS() << "fitness_test_object::test<2>()" << LL_ENDL;
-
-		// Set up the server
-		LLPumpIO::chain_t chain;
-		typedef LLCloneIOFactory<LLIOFuzz> emitter_t;
-		emitter_t* emitter = new emitter_t(new LLIOFuzz(1000000));
-		std::shared_ptr<LLChainIOFactory> factory(emitter);
-		LLIOServerSocket* server = new LLIOServerSocket(
-			mPool,
-			mSocket,
-			factory);
-		server->setResponseTimeout(SHORT_CHAIN_EXPIRY_SECS);
-		chain.push_back(LLIOPipe::ptr_t(server));
-		mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
-
-		// We need to tickle the pump a little to set up the listen()
-		pump_loop(mPump, 0.1f);
-
-		// Set up the client
-		LLSocket::ptr_t client = LLSocket::create(mPool, LLSocket::STREAM_TCP);
-		LLHost server_host("127.0.0.1", SERVER_LISTEN_PORT);
-		bool connected = client->blockingConnect(server_host);
-		ensure("Connected to server", connected);
-		LL_DEBUGS() << "connected" << LL_ENDL;
-
-		// We have connected, since the socket reader does not block,
-		// the first call to read data will return EAGAIN, so we need
-		// to write something.
-		chain.clear();
-		chain.push_back(LLIOPipe::ptr_t(new LLPipeStringInjector("hi")));
-		chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(client)));
-		chain.push_back(LLIOPipe::ptr_t(new LLIONull));
-		mPump->addChain(chain, SHORT_CHAIN_EXPIRY_SECS / 2.0f);
-
-		// Now, the server should immediately send the data, but we'll
-		// never read it. pump for a bit
-		F32 elapsed = pump_loop(mPump, SHORT_CHAIN_EXPIRY_SECS * 2.0f);
-		ensure("Did not take too long", (elapsed < 3.0f));
-	}
-
-	template<> template<>
-	void fitness_test_object::test<3>()
-	{
-		LL_DEBUGS() << "fitness_test_object::test<3>()" << LL_ENDL;
-
-		// Set up the server
-		LLPumpIO::chain_t chain;
-		typedef LLCloneIOFactory<LLIOFuzz> emitter_t;
-		emitter_t* emitter = new emitter_t(new LLIOFuzz(1000000));
-		std::shared_ptr<LLChainIOFactory> factory(emitter);
-		LLIOServerSocket* server = new LLIOServerSocket(
-			mPool,
-			mSocket,
-			factory);
-		server->setResponseTimeout(SHORT_CHAIN_EXPIRY_SECS);
-		chain.push_back(LLIOPipe::ptr_t(server));
-		mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
-
-		// We need to tickle the pump a little to set up the listen()
-		pump_loop(mPump, 0.1f);
-
-		// Set up the client
-		LLSocket::ptr_t client = LLSocket::create(mPool, LLSocket::STREAM_TCP);
-		LLHost server_host("127.0.0.1", SERVER_LISTEN_PORT);
-		bool connected = client->blockingConnect(server_host);
-		ensure("Connected to server", connected);
-		LL_DEBUGS() << "connected" << LL_ENDL;
-
-		// We have connected, since the socket reader does not block,
-		// the first call to read data will return EAGAIN, so we need
-		// to write something.
-		chain.clear();
-		chain.push_back(LLIOPipe::ptr_t(new LLPipeStringInjector("hi")));
-		chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(client)));
-		chain.push_back(LLIOPipe::ptr_t(new LLIONull));
-		mPump->addChain(chain, SHORT_CHAIN_EXPIRY_SECS * 2.0f);
-
-		// Now, the server should immediately send the data, but we'll
-		// never read it. pump for a bit
-		F32 elapsed = pump_loop(mPump, SHORT_CHAIN_EXPIRY_SECS * 2.0f + 1.0f);
-		ensure("Did not take too long", (elapsed < 4.0f));
-	}
-
-	template<> template<>
-	void fitness_test_object::test<4>()
-	{
-		LL_DEBUGS() << "fitness_test_object::test<4>()" << LL_ENDL;
-
-		// Set up the server
-		LLPumpIO::chain_t chain;
-		typedef LLCloneIOFactory<LLIOFuzz> emitter_t;
-		emitter_t* emitter = new emitter_t(new LLIOFuzz(1000000));
-		std::shared_ptr<LLChainIOFactory> factory(emitter);
-		LLIOServerSocket* server = new LLIOServerSocket(
-			mPool,
-			mSocket,
-			factory);
-		server->setResponseTimeout(SHORT_CHAIN_EXPIRY_SECS + 1.80f);
-		chain.push_back(LLIOPipe::ptr_t(server));
-		mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
-
-		// We need to tickle the pump a little to set up the listen()
-		pump_loop(mPump, 0.1f);
-
-		// Set up the client
-		LLSocket::ptr_t client = LLSocket::create(mPool, LLSocket::STREAM_TCP);
-		LLHost server_host("127.0.0.1", SERVER_LISTEN_PORT);
-		bool connected = client->blockingConnect(server_host);
-		ensure("Connected to server", connected);
-		LL_DEBUGS() << "connected" << LL_ENDL;
-
-		// We have connected, since the socket reader does not block,
-		// the first call to read data will return EAGAIN, so we need
-		// to write something.
-		chain.clear();
-		chain.push_back(LLIOPipe::ptr_t(new LLPipeStringInjector("hi")));
-		chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(client)));
-		chain.push_back(LLIOPipe::ptr_t(new LLIONull));
-		mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
-
-		// Now, the server should immediately send the data, but we'll
-		// never read it. pump for a bit
-		F32 elapsed = pump_loop(mPump, SHORT_CHAIN_EXPIRY_SECS + 3.0f);
-		ensure("Did not take too long", (elapsed < DEFAULT_CHAIN_EXPIRY_SECS));
-	}
-
-	template<> template<>
-	void fitness_test_object::test<5>()
-	{
-		// Set up the server
-		LLPumpIO::chain_t chain;
-		typedef LLCloneIOFactory<LLIOSleeper> sleeper_t;
-		sleeper_t* sleeper = new sleeper_t(new LLIOSleeper);
-		std::shared_ptr<LLChainIOFactory> factory(sleeper);
-		LLIOServerSocket* server = new LLIOServerSocket(
-			mPool,
-			mSocket,
-			factory);
-		server->setResponseTimeout(1.0);
-		chain.push_back(LLIOPipe::ptr_t(server));
-		mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
-		// We need to tickle the pump a little to set up the listen()
-		pump_loop(mPump, 0.1f);
-		U32 count = mPump->runningChains();
-		ensure_equals("server chain onboard", count, 1);
-		LL_DEBUGS() << "** Server is up." << LL_ENDL;
-
-		// Set up the client
-		LLSocket::ptr_t client = LLSocket::create(mPool, LLSocket::STREAM_TCP);
-		LLHost server_host("127.0.0.1", SERVER_LISTEN_PORT);
-		bool connected = client->blockingConnect(server_host);
-		ensure("Connected to server", connected);
-		LL_DEBUGS() << "connected" << LL_ENDL;
-		pump_loop(mPump,0.1f);
-		count = mPump->runningChains();
-		ensure_equals("server chain onboard", count, 2);
-		LL_DEBUGS() << "** Client is connected." << LL_ENDL;
-
-		// We have connected, since the socket reader does not block,
-		// the first call to read data will return EAGAIN, so we need
-		// to write something.
-		chain.clear();
-		chain.push_back(LLIOPipe::ptr_t(new LLPipeStringInjector("hi")));
-		chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(client)));
-		chain.push_back(LLIOPipe::ptr_t(new LLIONull));
-		mPump->addChain(chain, 0.2f);
-		chain.clear();
-
-		// pump for a bit and make sure all 3 chains are running
-		pump_loop(mPump,0.1f);
-		count = mPump->runningChains();
-		// ensure_equals("client chain onboard", count, 3); commented out because it fails frequently - appears to be timing sensitive
-		LL_DEBUGS() << "** request should have been sent." << LL_ENDL;
-
-		// pump for long enough the the client socket closes, and the
-		// server socket should not be closed yet.
-		pump_loop(mPump,0.2f);
-		count = mPump->runningChains();
-		ensure_equals("client chain timed out ", count, 2);
-		LL_DEBUGS() << "** client chain should be closed." << LL_ENDL;
-
-		// At this point, the socket should be closed by the timeout
-		pump_loop(mPump,1.0f);
-		count = mPump->runningChains();
-		ensure_equals("accepted socked close", count, 1);
-		LL_DEBUGS() << "** Sleeper should have timed out.." << LL_ENDL;
-	}
+    /**
+     * @brief we want to test the pipes & pumps under bad conditions.
+     */
+    struct pipe_and_pump_fitness
+    {
+    public:
+        enum
+        {
+            SERVER_LISTEN_PORT = 13050
+        };
+
+        pipe_and_pump_fitness()
+        {
+            LLFrameTimer::updateFrameTime();
+            apr_pool_create(&mPool, NULL);
+            mPump = new LLPumpIO(mPool);
+            mSocket = LLSocket::create(
+                mPool,
+                LLSocket::STREAM_TCP,
+                SERVER_LISTEN_PORT,
+                "127.0.0.1");
+        }
+
+        ~pipe_and_pump_fitness()
+        {
+            mSocket.reset();
+            delete mPump;
+            apr_pool_destroy(mPool);
+        }
+
+    protected:
+        apr_pool_t* mPool;
+        LLPumpIO* mPump;
+        LLSocket::ptr_t mSocket;
+    };
+    typedef test_group<pipe_and_pump_fitness> fitness_test_group;
+    typedef fitness_test_group::object fitness_test_object;
+    fitness_test_group fitness("pipe and pump fitness");
+
+    template<> template<>
+    void fitness_test_object::test<1>()
+    {
+        LL_DEBUGS() << "fitness_test_object::test<1>()" << LL_ENDL;
+
+        // Set up the server
+        //LL_DEBUGS() << "fitness_test_object::test<1> - setting up server."
+        //   << LL_ENDL;
+        LLPumpIO::chain_t chain;
+        typedef LLCloneIOFactory<LLPipeStringInjector> emitter_t;
+        emitter_t* emitter = new emitter_t(
+            new LLPipeStringInjector("suckers never play me"));
+        std::shared_ptr<LLChainIOFactory> factory(emitter);
+        LLIOServerSocket* server = new LLIOServerSocket(
+            mPool,
+            mSocket,
+            factory);
+        server->setResponseTimeout(SHORT_CHAIN_EXPIRY_SECS);
+        chain.push_back(LLIOPipe::ptr_t(server));
+        mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
+
+        // We need to tickle the pump a little to set up the listen()
+        //LL_DEBUGS() << "fitness_test_object::test<1> - initializing server."
+        //   << LL_ENDL;
+        pump_loop(mPump, 0.1f);
+
+        // Set up the client
+        //LL_DEBUGS() << "fitness_test_object::test<1> - connecting client."
+        //   << LL_ENDL;
+        LLSocket::ptr_t client = LLSocket::create(mPool, LLSocket::STREAM_TCP);
+        LLHost server_host("127.0.0.1", SERVER_LISTEN_PORT);
+        bool connected = client->blockingConnect(server_host);
+        ensure("Connected to server", connected);
+        LL_DEBUGS() << "connected" << LL_ENDL;
+
+        // We have connected, since the socket reader does not block,
+        // the first call to read data will return EAGAIN, so we need
+        // to write something.
+        chain.clear();
+        chain.push_back(LLIOPipe::ptr_t(new LLPipeStringInjector("hi")));
+        chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(client)));
+        chain.push_back(LLIOPipe::ptr_t(new LLIONull));
+        mPump->addChain(chain, 1.0f);
+
+        // Now, the server should immediately send the data, but we'll
+        // never read it. pump for a bit
+        F32 elapsed = pump_loop(mPump, 2.0f);
+        ensure("Did not take too long", (elapsed < 3.0f));
+    }
+
+    template<> template<>
+    void fitness_test_object::test<2>()
+    {
+        LL_DEBUGS() << "fitness_test_object::test<2>()" << LL_ENDL;
+
+        // Set up the server
+        LLPumpIO::chain_t chain;
+        typedef LLCloneIOFactory<LLIOFuzz> emitter_t;
+        emitter_t* emitter = new emitter_t(new LLIOFuzz(1000000));
+        std::shared_ptr<LLChainIOFactory> factory(emitter);
+        LLIOServerSocket* server = new LLIOServerSocket(
+            mPool,
+            mSocket,
+            factory);
+        server->setResponseTimeout(SHORT_CHAIN_EXPIRY_SECS);
+        chain.push_back(LLIOPipe::ptr_t(server));
+        mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
+
+        // We need to tickle the pump a little to set up the listen()
+        pump_loop(mPump, 0.1f);
+
+        // Set up the client
+        LLSocket::ptr_t client = LLSocket::create(mPool, LLSocket::STREAM_TCP);
+        LLHost server_host("127.0.0.1", SERVER_LISTEN_PORT);
+        bool connected = client->blockingConnect(server_host);
+        ensure("Connected to server", connected);
+        LL_DEBUGS() << "connected" << LL_ENDL;
+
+        // We have connected, since the socket reader does not block,
+        // the first call to read data will return EAGAIN, so we need
+        // to write something.
+        chain.clear();
+        chain.push_back(LLIOPipe::ptr_t(new LLPipeStringInjector("hi")));
+        chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(client)));
+        chain.push_back(LLIOPipe::ptr_t(new LLIONull));
+        mPump->addChain(chain, SHORT_CHAIN_EXPIRY_SECS / 2.0f);
+
+        // Now, the server should immediately send the data, but we'll
+        // never read it. pump for a bit
+        F32 elapsed = pump_loop(mPump, SHORT_CHAIN_EXPIRY_SECS * 2.0f);
+        ensure("Did not take too long", (elapsed < 3.0f));
+    }
+
+    template<> template<>
+    void fitness_test_object::test<3>()
+    {
+        LL_DEBUGS() << "fitness_test_object::test<3>()" << LL_ENDL;
+
+        // Set up the server
+        LLPumpIO::chain_t chain;
+        typedef LLCloneIOFactory<LLIOFuzz> emitter_t;
+        emitter_t* emitter = new emitter_t(new LLIOFuzz(1000000));
+        std::shared_ptr<LLChainIOFactory> factory(emitter);
+        LLIOServerSocket* server = new LLIOServerSocket(
+            mPool,
+            mSocket,
+            factory);
+        server->setResponseTimeout(SHORT_CHAIN_EXPIRY_SECS);
+        chain.push_back(LLIOPipe::ptr_t(server));
+        mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
+
+        // We need to tickle the pump a little to set up the listen()
+        pump_loop(mPump, 0.1f);
+
+        // Set up the client
+        LLSocket::ptr_t client = LLSocket::create(mPool, LLSocket::STREAM_TCP);
+        LLHost server_host("127.0.0.1", SERVER_LISTEN_PORT);
+        bool connected = client->blockingConnect(server_host);
+        ensure("Connected to server", connected);
+        LL_DEBUGS() << "connected" << LL_ENDL;
+
+        // We have connected, since the socket reader does not block,
+        // the first call to read data will return EAGAIN, so we need
+        // to write something.
+        chain.clear();
+        chain.push_back(LLIOPipe::ptr_t(new LLPipeStringInjector("hi")));
+        chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(client)));
+        chain.push_back(LLIOPipe::ptr_t(new LLIONull));
+        mPump->addChain(chain, SHORT_CHAIN_EXPIRY_SECS * 2.0f);
+
+        // Now, the server should immediately send the data, but we'll
+        // never read it. pump for a bit
+        F32 elapsed = pump_loop(mPump, SHORT_CHAIN_EXPIRY_SECS * 2.0f + 1.0f);
+        ensure("Did not take too long", (elapsed < 4.0f));
+    }
+
+    template<> template<>
+    void fitness_test_object::test<4>()
+    {
+        LL_DEBUGS() << "fitness_test_object::test<4>()" << LL_ENDL;
+
+        // Set up the server
+        LLPumpIO::chain_t chain;
+        typedef LLCloneIOFactory<LLIOFuzz> emitter_t;
+        emitter_t* emitter = new emitter_t(new LLIOFuzz(1000000));
+        std::shared_ptr<LLChainIOFactory> factory(emitter);
+        LLIOServerSocket* server = new LLIOServerSocket(
+            mPool,
+            mSocket,
+            factory);
+        server->setResponseTimeout(SHORT_CHAIN_EXPIRY_SECS + 1.80f);
+        chain.push_back(LLIOPipe::ptr_t(server));
+        mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
+
+        // We need to tickle the pump a little to set up the listen()
+        pump_loop(mPump, 0.1f);
+
+        // Set up the client
+        LLSocket::ptr_t client = LLSocket::create(mPool, LLSocket::STREAM_TCP);
+        LLHost server_host("127.0.0.1", SERVER_LISTEN_PORT);
+        bool connected = client->blockingConnect(server_host);
+        ensure("Connected to server", connected);
+        LL_DEBUGS() << "connected" << LL_ENDL;
+
+        // We have connected, since the socket reader does not block,
+        // the first call to read data will return EAGAIN, so we need
+        // to write something.
+        chain.clear();
+        chain.push_back(LLIOPipe::ptr_t(new LLPipeStringInjector("hi")));
+        chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(client)));
+        chain.push_back(LLIOPipe::ptr_t(new LLIONull));
+        mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
+
+        // Now, the server should immediately send the data, but we'll
+        // never read it. pump for a bit
+        F32 elapsed = pump_loop(mPump, SHORT_CHAIN_EXPIRY_SECS + 3.0f);
+        ensure("Did not take too long", (elapsed < DEFAULT_CHAIN_EXPIRY_SECS));
+    }
+
+    template<> template<>
+    void fitness_test_object::test<5>()
+    {
+        // Set up the server
+        LLPumpIO::chain_t chain;
+        typedef LLCloneIOFactory<LLIOSleeper> sleeper_t;
+        sleeper_t* sleeper = new sleeper_t(new LLIOSleeper);
+        std::shared_ptr<LLChainIOFactory> factory(sleeper);
+        LLIOServerSocket* server = new LLIOServerSocket(
+            mPool,
+            mSocket,
+            factory);
+        server->setResponseTimeout(1.0);
+        chain.push_back(LLIOPipe::ptr_t(server));
+        mPump->addChain(chain, NEVER_CHAIN_EXPIRY_SECS);
+        // We need to tickle the pump a little to set up the listen()
+        pump_loop(mPump, 0.1f);
+        U32 count = mPump->runningChains();
+        ensure_equals("server chain onboard", count, 1);
+        LL_DEBUGS() << "** Server is up." << LL_ENDL;
+
+        // Set up the client
+        LLSocket::ptr_t client = LLSocket::create(mPool, LLSocket::STREAM_TCP);
+        LLHost server_host("127.0.0.1", SERVER_LISTEN_PORT);
+        bool connected = client->blockingConnect(server_host);
+        ensure("Connected to server", connected);
+        LL_DEBUGS() << "connected" << LL_ENDL;
+        pump_loop(mPump,0.1f);
+        count = mPump->runningChains();
+        ensure_equals("server chain onboard", count, 2);
+        LL_DEBUGS() << "** Client is connected." << LL_ENDL;
+
+        // We have connected, since the socket reader does not block,
+        // the first call to read data will return EAGAIN, so we need
+        // to write something.
+        chain.clear();
+        chain.push_back(LLIOPipe::ptr_t(new LLPipeStringInjector("hi")));
+        chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(client)));
+        chain.push_back(LLIOPipe::ptr_t(new LLIONull));
+        mPump->addChain(chain, 0.2f);
+        chain.clear();
+
+        // pump for a bit and make sure all 3 chains are running
+        pump_loop(mPump,0.1f);
+        count = mPump->runningChains();
+        // ensure_equals("client chain onboard", count, 3); commented out because it fails frequently - appears to be timing sensitive
+        LL_DEBUGS() << "** request should have been sent." << LL_ENDL;
+
+        // pump for long enough the the client socket closes, and the
+        // server socket should not be closed yet.
+        pump_loop(mPump,0.2f);
+        count = mPump->runningChains();
+        ensure_equals("client chain timed out ", count, 2);
+        LL_DEBUGS() << "** client chain should be closed." << LL_ENDL;
+
+        // At this point, the socket should be closed by the timeout
+        pump_loop(mPump,1.0f);
+        count = mPump->runningChains();
+        ensure_equals("accepted socked close", count, 1);
+        LL_DEBUGS() << "** Sleeper should have timed out.." << LL_ENDL;
+    }
 }
 
 /*
diff --git a/indra/test/llapp_tut.cpp b/indra/test/llapp_tut.cpp
index 98e714a497..114af6edbf 100644
--- a/indra/test/llapp_tut.cpp
+++ b/indra/test/llapp_tut.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llapp_tut.cpp
  * @author Phoenix
  * @date 2006-09-12
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2006&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2006-2011, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -34,129 +34,129 @@
 
 namespace tut
 {
-	struct application
-	{
-		class LLTestApp : public LLApp
-		{
-		public:
-			virtual bool init() { return true; }
-			virtual bool cleanup() { return true; }
-			virtual bool frame() { return true; }
-		};
-		LLTestApp* mApp;
-		application()
-		{
-			mApp = new LLTestApp;
-		}
-		~application()
-		{
-			delete mApp;
-		}
-	};
+    struct application
+    {
+        class LLTestApp : public LLApp
+        {
+        public:
+            virtual bool init() { return true; }
+            virtual bool cleanup() { return true; }
+            virtual bool frame() { return true; }
+        };
+        LLTestApp* mApp;
+        application()
+        {
+            mApp = new LLTestApp;
+        }
+        ~application()
+        {
+            delete mApp;
+        }
+    };
 
-	typedef test_group<application> application_t;
-	typedef application_t::object application_object_t;
-	tut::application_t tut_application("application");
+    typedef test_group<application> application_t;
+    typedef application_t::object application_object_t;
+    tut::application_t tut_application("application");
 
-	template<> template<>
-	void application_object_t::test<1>()
-	{
-		LLSD defaults;
-		defaults["template"] = "../../../scripts/messages/message_template.msg";
-		defaults["configdir"] = ".";
-		defaults["datadir"] = "data";
-		mApp->setOptionData(LLApp::PRIORITY_DEFAULT, defaults);
+    template<> template<>
+    void application_object_t::test<1>()
+    {
+        LLSD defaults;
+        defaults["template"] = "../../../scripts/messages/message_template.msg";
+        defaults["configdir"] = ".";
+        defaults["datadir"] = "data";
+        mApp->setOptionData(LLApp::PRIORITY_DEFAULT, defaults);
 
-		LLSD datadir_sd = mApp->getOption("datadir");
-		ensure_equals("data type", datadir_sd.type(), LLSD::TypeString);
-		ensure_equals(
-			"data value", datadir_sd.asString(), std::string("data"));
-	}
+        LLSD datadir_sd = mApp->getOption("datadir");
+        ensure_equals("data type", datadir_sd.type(), LLSD::TypeString);
+        ensure_equals(
+            "data value", datadir_sd.asString(), std::string("data"));
+    }
 
-	template<> template<>
-	void application_object_t::test<2>()
-	{
-		const int ARGC = 13;
-		const char* ARGV[ARGC] =
-		{
-			"", // argv[0] is usually the application name
-			"-crashcount",
-			"2",
-			"-space",
-			"spaceserver.grid.lindenlab.com",
-			"-db_host",
-			"localhost",
-			"--allowlslhttprequests",
-			"-asset-uri",
-			"http://test.lindenlab.com/assets",
-			"-data",
-			"127.0.0.1",
-			"--smtp"
-		};
-		bool ok = mApp->parseCommandOptions(ARGC, const_cast<char**>(ARGV));
-		ensure("command line parsed", ok);
-		ensure_equals(
-			"crashcount", mApp->getOption("crashcount").asInteger(), 2);
-		ensure_equals(
-			"space",
-			mApp->getOption("space").asString(),
-			std::string("spaceserver.grid.lindenlab.com"));
-		ensure_equals(
-			"db_host",
-			mApp->getOption("db_host").asString(),
-			std::string("localhost"));
-		ensure("allowlshlttprequests", mApp->getOption("smtp"));
-		ensure_equals(
-			"asset-uri",
-			mApp->getOption("asset-uri").asString(),
-			std::string("http://test.lindenlab.com/assets"));
-		ensure_equals(
-			"data",
-			mApp->getOption("data").asString(),
-			std::string("127.0.0.1"));
-		ensure("smtp", mApp->getOption("smtp"));
-	}
+    template<> template<>
+    void application_object_t::test<2>()
+    {
+        const int ARGC = 13;
+        const char* ARGV[ARGC] =
+        {
+            "", // argv[0] is usually the application name
+            "-crashcount",
+            "2",
+            "-space",
+            "spaceserver.grid.lindenlab.com",
+            "-db_host",
+            "localhost",
+            "--allowlslhttprequests",
+            "-asset-uri",
+            "http://test.lindenlab.com/assets",
+            "-data",
+            "127.0.0.1",
+            "--smtp"
+        };
+        bool ok = mApp->parseCommandOptions(ARGC, const_cast<char**>(ARGV));
+        ensure("command line parsed", ok);
+        ensure_equals(
+            "crashcount", mApp->getOption("crashcount").asInteger(), 2);
+        ensure_equals(
+            "space",
+            mApp->getOption("space").asString(),
+            std::string("spaceserver.grid.lindenlab.com"));
+        ensure_equals(
+            "db_host",
+            mApp->getOption("db_host").asString(),
+            std::string("localhost"));
+        ensure("allowlshlttprequests", mApp->getOption("smtp"));
+        ensure_equals(
+            "asset-uri",
+            mApp->getOption("asset-uri").asString(),
+            std::string("http://test.lindenlab.com/assets"));
+        ensure_equals(
+            "data",
+            mApp->getOption("data").asString(),
+            std::string("127.0.0.1"));
+        ensure("smtp", mApp->getOption("smtp"));
+    }
 
-	template<> template<>
-	void application_object_t::test<3>()
-	{
-		const int ARGC = 4;
-		const char* ARGV[ARGC] =
-		{
-			"", // argv[0] is usually the application name
-			"crashcount",
-			"2",
-			"--space"
-		};
-		bool ok = mApp->parseCommandOptions(ARGC, const_cast<char**>(ARGV));
-		ensure("command line parse failure", !ok);
-	}
+    template<> template<>
+    void application_object_t::test<3>()
+    {
+        const int ARGC = 4;
+        const char* ARGV[ARGC] =
+        {
+            "", // argv[0] is usually the application name
+            "crashcount",
+            "2",
+            "--space"
+        };
+        bool ok = mApp->parseCommandOptions(ARGC, const_cast<char**>(ARGV));
+        ensure("command line parse failure", !ok);
+    }
 
-	template<> template<>
-	void application_object_t::test<4>()
-	{
-		const int ARGC = 4;
-		const char* ARGV[ARGC] =
-		{
-			"", // argv[0] is usually the application name
-			"--crashcount",
-			"2",
-			"space"
-		};
-		bool ok = mApp->parseCommandOptions(ARGC, const_cast<char**>(ARGV));
-		ensure("command line parse failure", !ok);
-	}
+    template<> template<>
+    void application_object_t::test<4>()
+    {
+        const int ARGC = 4;
+        const char* ARGV[ARGC] =
+        {
+            "", // argv[0] is usually the application name
+            "--crashcount",
+            "2",
+            "space"
+        };
+        bool ok = mApp->parseCommandOptions(ARGC, const_cast<char**>(ARGV));
+        ensure("command line parse failure", !ok);
+    }
 
 
-	template<> template<>
-	void application_object_t::test<5>()
-	{
-		LLSD options;
-		options["boolean-test"] = true;
-		mApp->setOptionData(LLApp::PRIORITY_GENERAL_CONFIGURATION, options);
-		ensure("bool set", mApp->getOption("boolean-test").asBoolean());
-		options["boolean-test"] = false;
-		mApp->setOptionData(LLApp::PRIORITY_RUNTIME_OVERRIDE, options);
-		ensure("bool unset", !mApp->getOption("boolean-test").asBoolean());
-	}
+    template<> template<>
+    void application_object_t::test<5>()
+    {
+        LLSD options;
+        options["boolean-test"] = true;
+        mApp->setOptionData(LLApp::PRIORITY_GENERAL_CONFIGURATION, options);
+        ensure("bool set", mApp->getOption("boolean-test").asBoolean());
+        options["boolean-test"] = false;
+        mApp->setOptionData(LLApp::PRIORITY_RUNTIME_OVERRIDE, options);
+        ensure("bool unset", !mApp->getOption("boolean-test").asBoolean());
+    }
 }
diff --git a/indra/test/llassetuploadqueue_tut.cpp b/indra/test/llassetuploadqueue_tut.cpp
index 25efe63d3f..be5f9e4288 100644
--- a/indra/test/llassetuploadqueue_tut.cpp
+++ b/indra/test/llassetuploadqueue_tut.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file asset_upload_queue_tut.cpp
  * @brief Tests for newview/llassetuploadqueue.cpp
  *
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -32,8 +32,8 @@
 
 // Mock implementation.
 LLAssetUploadResponder::LLAssetUploadResponder(const LLSD& post_data,
-											   const LLUUID& vfile_id,
-											   LLAssetType::EType asset_type)
+                                               const LLUUID& vfile_id,
+                                               LLAssetType::EType asset_type)
 {
 }
 
@@ -66,22 +66,22 @@ void LLAssetUploadResponder::uploadFailure(const LLSD& content)
 }
 
 LLUpdateTaskInventoryResponder::LLUpdateTaskInventoryResponder(const LLSD& post_data,
-															   const LLUUID& vfile_id,
-															   LLAssetType::EType asset_type) :
-	LLAssetUploadResponder(post_data, vfile_id, asset_type)
+                                                               const LLUUID& vfile_id,
+                                                               LLAssetType::EType asset_type) :
+    LLAssetUploadResponder(post_data, vfile_id, asset_type)
 {
 }
 
 LLUpdateTaskInventoryResponder::LLUpdateTaskInventoryResponder(const LLSD& post_data,
-															   const std::string& file_name) :
-	LLAssetUploadResponder(post_data, file_name)
+                                                               const std::string& file_name) :
+    LLAssetUploadResponder(post_data, file_name)
 {
 }
 
 LLUpdateTaskInventoryResponder::LLUpdateTaskInventoryResponder(const LLSD& post_data,
-															   const std::string& file_name,
-															   const LLUUID& queue_id) :
-	LLAssetUploadResponder(post_data, file_name)
+                                                               const std::string& file_name,
+                                                               const LLUUID& queue_id) :
+    LLAssetUploadResponder(post_data, file_name)
 {
 }
 
@@ -91,105 +91,105 @@ void LLUpdateTaskInventoryResponder::uploadComplete(const LLSD& content)
 
 namespace tut
 {
-	class asset_upload_queue_test_data : public MockHttpClient {};
-	typedef test_group<asset_upload_queue_test_data> asset_upload_queue_test;
-	typedef asset_upload_queue_test::object asset_upload_queue_object;
-	tut::asset_upload_queue_test asset_upload_queue("asset_upload_queue");
-
-	void queue(LLAssetUploadQueue& q, const std::string& filename)
-	{
-		LLUUID task_id;
-		LLUUID item_id;
-		BOOL is_running = FALSE; 
-		BOOL is_target_mono = TRUE; 
-		LLUUID queue_id;
-		q.queue(filename, task_id, item_id, is_running, is_target_mono, queue_id);
-	}
-
-	class LLTestSupplier : public LLAssetUploadQueueSupplier
-	{
-	public:
-
-		void set(LLAssetUploadQueue* queue) {mQueue = queue;}
-		
-		virtual LLAssetUploadQueue* get() const
-			{
-				return mQueue;
-			}
-
-	private:
-		LLAssetUploadQueue* mQueue;  
-	};
-
-	template<> template<>
-	void asset_upload_queue_object::test<1>()
-	{
-		setupTheServer();
-		reset();
-		LLTestSupplier* supplier = new LLTestSupplier();
-		LLAssetUploadQueue q("http://localhost:8888/test/success", supplier);
-		supplier->set(&q);
-		queue(q, "foo.bar");
-		ensure("upload queue not empty before request", q.isEmpty());
-		runThePump(10);
-		ensure("upload queue not empty after request", q.isEmpty());
-	}
-
-	template<> template<>
-	void asset_upload_queue_object::test<2>()
-	{
-		reset();
-		LLTestSupplier* supplier = new LLTestSupplier();
-		LLAssetUploadQueue q("http://localhost:8888/test/error", supplier);
-		supplier->set(&q);
-		queue(q, "foo.bar");
-		ensure("upload queue not empty before request", q.isEmpty());
-		runThePump(10);
-		ensure("upload queue not empty after request", q.isEmpty());
-	}
-
-	template<> template<>
-	void asset_upload_queue_object::test<3>()
-	{
-		reset();
-		LLTestSupplier* supplier = new LLTestSupplier();
-		LLAssetUploadQueue q("http://localhost:8888/test/timeout", supplier);
-		supplier->set(&q);
-		queue(q, "foo.bar");
-		ensure("upload queue not empty before request", q.isEmpty());
-		runThePump(10);
-		ensure("upload queue not empty after request", q.isEmpty());
-	}
-
-	template<> template<>
-	void asset_upload_queue_object::test<4>()
-	{
-		reset();
-		LLTestSupplier* supplier = new LLTestSupplier();
-		LLAssetUploadQueue q("http://localhost:8888/test/success", supplier);
-		supplier->set(&q);
-		queue(q, "foo.bar");
-		queue(q, "baz.bar");
-		ensure("upload queue empty before request", !q.isEmpty());
-		runThePump(10);
-		ensure("upload queue not empty before request", q.isEmpty());
-		runThePump(10);
-		ensure("upload queue not empty after request", q.isEmpty());
-	}
-
-	template<> template<>
-	void asset_upload_queue_object::test<5>()
-	{
-		reset();
-		LLTestSupplier* supplier = new LLTestSupplier();
-		LLAssetUploadQueue q("http://localhost:8888/test/success", supplier);
-		supplier->set(&q);
-		queue(q, "foo.bar");
-		runThePump(10);
-		ensure("upload queue not empty before request", q.isEmpty());
-		queue(q, "baz.bar");
-		ensure("upload queue not empty after request", q.isEmpty());
-		runThePump(10);
-		killServer();
-	}
+    class asset_upload_queue_test_data : public MockHttpClient {};
+    typedef test_group<asset_upload_queue_test_data> asset_upload_queue_test;
+    typedef asset_upload_queue_test::object asset_upload_queue_object;
+    tut::asset_upload_queue_test asset_upload_queue("asset_upload_queue");
+
+    void queue(LLAssetUploadQueue& q, const std::string& filename)
+    {
+        LLUUID task_id;
+        LLUUID item_id;
+        BOOL is_running = FALSE;
+        BOOL is_target_mono = TRUE;
+        LLUUID queue_id;
+        q.queue(filename, task_id, item_id, is_running, is_target_mono, queue_id);
+    }
+
+    class LLTestSupplier : public LLAssetUploadQueueSupplier
+    {
+    public:
+
+        void set(LLAssetUploadQueue* queue) {mQueue = queue;}
+
+        virtual LLAssetUploadQueue* get() const
+            {
+                return mQueue;
+            }
+
+    private:
+        LLAssetUploadQueue* mQueue;
+    };
+
+    template<> template<>
+    void asset_upload_queue_object::test<1>()
+    {
+        setupTheServer();
+        reset();
+        LLTestSupplier* supplier = new LLTestSupplier();
+        LLAssetUploadQueue q("http://localhost:8888/test/success", supplier);
+        supplier->set(&q);
+        queue(q, "foo.bar");
+        ensure("upload queue not empty before request", q.isEmpty());
+        runThePump(10);
+        ensure("upload queue not empty after request", q.isEmpty());
+    }
+
+    template<> template<>
+    void asset_upload_queue_object::test<2>()
+    {
+        reset();
+        LLTestSupplier* supplier = new LLTestSupplier();
+        LLAssetUploadQueue q("http://localhost:8888/test/error", supplier);
+        supplier->set(&q);
+        queue(q, "foo.bar");
+        ensure("upload queue not empty before request", q.isEmpty());
+        runThePump(10);
+        ensure("upload queue not empty after request", q.isEmpty());
+    }
+
+    template<> template<>
+    void asset_upload_queue_object::test<3>()
+    {
+        reset();
+        LLTestSupplier* supplier = new LLTestSupplier();
+        LLAssetUploadQueue q("http://localhost:8888/test/timeout", supplier);
+        supplier->set(&q);
+        queue(q, "foo.bar");
+        ensure("upload queue not empty before request", q.isEmpty());
+        runThePump(10);
+        ensure("upload queue not empty after request", q.isEmpty());
+    }
+
+    template<> template<>
+    void asset_upload_queue_object::test<4>()
+    {
+        reset();
+        LLTestSupplier* supplier = new LLTestSupplier();
+        LLAssetUploadQueue q("http://localhost:8888/test/success", supplier);
+        supplier->set(&q);
+        queue(q, "foo.bar");
+        queue(q, "baz.bar");
+        ensure("upload queue empty before request", !q.isEmpty());
+        runThePump(10);
+        ensure("upload queue not empty before request", q.isEmpty());
+        runThePump(10);
+        ensure("upload queue not empty after request", q.isEmpty());
+    }
+
+    template<> template<>
+    void asset_upload_queue_object::test<5>()
+    {
+        reset();
+        LLTestSupplier* supplier = new LLTestSupplier();
+        LLAssetUploadQueue q("http://localhost:8888/test/success", supplier);
+        supplier->set(&q);
+        queue(q, "foo.bar");
+        runThePump(10);
+        ensure("upload queue not empty before request", q.isEmpty());
+        queue(q, "baz.bar");
+        ensure("upload queue not empty after request", q.isEmpty());
+        runThePump(10);
+        killServer();
+    }
 }
diff --git a/indra/test/llblowfish_tut.cpp b/indra/test/llblowfish_tut.cpp
index 18eb01363f..a8690ccb33 100644
--- a/indra/test/llblowfish_tut.cpp
+++ b/indra/test/llblowfish_tut.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llblowfish_tut.cpp
  * @author James Cook, james@lindenlab.com
  * @date 2007-02-04
@@ -10,21 +10,21 @@
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -38,104 +38,104 @@
 
 namespace tut
 {
-	class LLData
-	{
-	public:
-		unsigned char* mInput;
-		int mInputSize;
-
-		LLData()
-		{
-			// \n to make it easier to create text files
-			// for testing with command line openssl
-			mInput = (unsigned char*)"01234567890123456789012345678901234\n";
-			mInputSize = 36;
-		}
-
-		bool matchFile(const std::string& filename,
-					   const std::string& data)
-		{
-			LLFILE* fp = LLFile::fopen(filename, "rb");
-			if (!fp) 
-			{
-				// sometimes test is run inside the indra directory
-				std::string path = "test/";
-				path += filename;
-				fp = LLFile::fopen(path, "rb");
-			}
-			if (!fp)
-			{
-				LL_WARNS() << "unable to open " << filename << LL_ENDL;
-				return false;
-			}
-
-			std::string good;
-			good.resize(256);
-			size_t got = fread(&good[0], 1, 256, fp);
-			LL_DEBUGS() << "matchFile read " << got << LL_ENDL;
-			fclose(fp);
-			good.resize(got);
-		
-			return (good == data);
-		}
-	};
-	typedef test_group<LLData> blowfish_test;
-	typedef blowfish_test::object blowfish_object;
-	// Create test with name that can be selected on
-	// command line of test app.
-	tut::blowfish_test blowfish("blowfish");
-
-	template<> template<>
-	void blowfish_object::test<1>()
-	{
-		LLUUID blank;
-		LLBlowfishCipher cipher(&blank.mData[0], UUID_BYTES);
-
-		U32 dst_len = cipher.requiredEncryptionSpace(36);
-		ensure("encryption space 36",
-				(dst_len == 40) );
-
-		// Blowfish adds an additional 8-byte block if your
-		// input is an exact multiple of 8
-		dst_len = cipher.requiredEncryptionSpace(8);
-		ensure("encryption space 8",
-				(dst_len == 16)  );
-	}
-
-	template<> template<>
-	void blowfish_object::test<2>()
-	{
-		LLUUID blank;
-		LLBlowfishCipher cipher(&blank.mData[0], UUID_BYTES);
-
-		std::string result;
-		result.resize(256);
-		U32 count = cipher.encrypt(mInput, mInputSize,
-				(U8*) &result[0], 256);
-
-		ensure("encrypt output count",
-				(count == 40) );
-		result.resize(count);
-
-		ensure("encrypt null key", matchFile("blowfish.1.bin", result));
-	}
-
-	template<> template<>
-	void blowfish_object::test<3>()
-	{
+    class LLData
+    {
+    public:
+        unsigned char* mInput;
+        int mInputSize;
+
+        LLData()
+        {
+            // \n to make it easier to create text files
+            // for testing with command line openssl
+            mInput = (unsigned char*)"01234567890123456789012345678901234\n";
+            mInputSize = 36;
+        }
+
+        bool matchFile(const std::string& filename,
+                       const std::string& data)
+        {
+            LLFILE* fp = LLFile::fopen(filename, "rb");
+            if (!fp)
+            {
+                // sometimes test is run inside the indra directory
+                std::string path = "test/";
+                path += filename;
+                fp = LLFile::fopen(path, "rb");
+            }
+            if (!fp)
+            {
+                LL_WARNS() << "unable to open " << filename << LL_ENDL;
+                return false;
+            }
+
+            std::string good;
+            good.resize(256);
+            size_t got = fread(&good[0], 1, 256, fp);
+            LL_DEBUGS() << "matchFile read " << got << LL_ENDL;
+            fclose(fp);
+            good.resize(got);
+
+            return (good == data);
+        }
+    };
+    typedef test_group<LLData> blowfish_test;
+    typedef blowfish_test::object blowfish_object;
+    // Create test with name that can be selected on
+    // command line of test app.
+    tut::blowfish_test blowfish("blowfish");
+
+    template<> template<>
+    void blowfish_object::test<1>()
+    {
+        LLUUID blank;
+        LLBlowfishCipher cipher(&blank.mData[0], UUID_BYTES);
+
+        U32 dst_len = cipher.requiredEncryptionSpace(36);
+        ensure("encryption space 36",
+                (dst_len == 40) );
+
+        // Blowfish adds an additional 8-byte block if your
+        // input is an exact multiple of 8
+        dst_len = cipher.requiredEncryptionSpace(8);
+        ensure("encryption space 8",
+                (dst_len == 16)  );
+    }
+
+    template<> template<>
+    void blowfish_object::test<2>()
+    {
+        LLUUID blank;
+        LLBlowfishCipher cipher(&blank.mData[0], UUID_BYTES);
+
+        std::string result;
+        result.resize(256);
+        U32 count = cipher.encrypt(mInput, mInputSize,
+                (U8*) &result[0], 256);
+
+        ensure("encrypt output count",
+                (count == 40) );
+        result.resize(count);
+
+        ensure("encrypt null key", matchFile("blowfish.1.bin", result));
+    }
+
+    template<> template<>
+    void blowfish_object::test<3>()
+    {
         // same as base64 test id
-		LLUUID id("526a1e07-a19d-baed-84c4-ff08a488d15e");
-		LLBlowfishCipher cipher(&id.mData[0], UUID_BYTES);
+        LLUUID id("526a1e07-a19d-baed-84c4-ff08a488d15e");
+        LLBlowfishCipher cipher(&id.mData[0], UUID_BYTES);
 
-		std::string result;
-		result.resize(256);
-		U32 count = cipher.encrypt(mInput, mInputSize,
-				(U8*) &result[0], 256);
+        std::string result;
+        result.resize(256);
+        U32 count = cipher.encrypt(mInput, mInputSize,
+                (U8*) &result[0], 256);
 
-		ensure("encrypt output count",
-				(count == 40) );
-		result.resize(count);
+        ensure("encrypt output count",
+                (count == 40) );
+        result.resize(count);
 
-		ensure("encrypt real key", matchFile("blowfish.2.bin", result));
-	}
+        ensure("encrypt real key", matchFile("blowfish.2.bin", result));
+    }
 }
diff --git a/indra/test/llbuffer_tut.cpp b/indra/test/llbuffer_tut.cpp
index 9b8aae6a73..a31870241c 100644
--- a/indra/test/llbuffer_tut.cpp
+++ b/indra/test/llbuffer_tut.cpp
@@ -7,21 +7,21 @@
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -36,236 +36,236 @@
 
 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));
-	}
+    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 b403660c13..2e975ee637 100644
--- a/indra/test/lldatapacker_tut.cpp
+++ b/indra/test/lldatapacker_tut.cpp
@@ -7,21 +7,21 @@
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -37,534 +37,534 @@
 #include "v4math.h"
 #include "llsdserialize.h"
 
-#define TEST_FILE_NAME	"datapacker_test.txt"
+#define TEST_FILE_NAME  "datapacker_test.txt"
 namespace tut
 {
-	struct datapacker_test
-	{
-	};
-	typedef test_group<datapacker_test> datapacker_test_t;
-	typedef datapacker_test_t::object datapacker_test_object_t;
-	tut::datapacker_test_t tut_datapacker_test("datapacker_test");
-
-	//*********LLDataPackerBinaryBuffer
-	template<> template<>
-	void datapacker_test_object_t::test<1>()
-	{
-		U8 packbuf[128];
-		F32 f_val1 = 44.44f, f_unpkval1;
-		F32 f_val2 = 12344.443232f, f_unpkval2;
-		F32 f_val3 = 44.4456789f, f_unpkval3;
-		LLDataPackerBinaryBuffer lldp(packbuf,128);
-		lldp.packFixed( f_val1, "linden_lab", FALSE, 8, 8);
-		lldp.packFixed( f_val2, "linden_lab", FALSE, 14, 16);
-		lldp.packFixed( f_val3, "linden_lab", FALSE, 8, 23);
-
-		LLDataPackerBinaryBuffer lldp1(packbuf, lldp.getCurrentSize());
-		lldp1.unpackFixed(f_unpkval1, "linden_lab", FALSE, 8, 8);
-		lldp1.unpackFixed(f_unpkval2, "linden_lab", FALSE, 14, 16);
-		lldp1.unpackFixed(f_unpkval3, "linden_lab", FALSE, 8, 23);
-		ensure_approximately_equals("LLDataPackerBinaryBuffer::packFixed 8 failed", f_val1, f_unpkval1, 8);
-		ensure_approximately_equals("LLDataPackerBinaryBuffer::packFixed 16 failed", f_val2, f_unpkval2, 16);
-		ensure_approximately_equals("LLDataPackerBinaryBuffer::packFixed 23 failed", f_val3, f_unpkval3, 31);
-	}
-
-	template<> template<>
-	void datapacker_test_object_t::test<2>()
-	{
-		U8 packbuf[1024];
-
-		char str[] = "SecondLife is virtual World\0";
-		char strBinary[] = "SecondLife is virtual World";
-		char strBinaryFixed[] = "Fixed Data";
-		S32 sizeBinaryFixed = sizeof(strBinaryFixed);
-		U8 valU8 = 'C';
-		U16 valU16 = 0xFFFF;
-		U32 valU32 = 0xFFFFFFFF;
-		S32 valS32 = -94967295;
-		F32 valF32 = 4354355.44f ;
-		LLColor4 llcol4(3.3f, 0, 4.4f, 5.5f);
-		LLColor4U llcol4u(3, 128, 24, 33);
-		LLVector2 llvec2(333.33f, 444.44f);
-		LLVector3 llvec3(333.33f, 444.44f, 555.55f);
-		LLVector4 llvec4(333.33f, 444.44f, 555.55f, 666.66f);
-		LLUUID uuid;
-
-		std::string unpkstr;
-		char unpkstrBinary[256];
-		char unpkstrBinaryFixed[256];
-		S32 unpksizeBinary;
-		U8 unpkvalU8;
-		U16 unpkvalU16;
-		U32 unpkvalU32;
-		S32 unpkvalS32;
-		F32 unpkvalF32;
-		LLColor4 unpkllcol4;
-		LLColor4U unpkllcol4u;
-		LLVector2 unpkllvec2;
-		LLVector3 unpkllvec3;
-		LLVector4 unpkllvec4;
-		LLUUID unpkuuid;
-
-		LLDataPackerBinaryBuffer lldp(packbuf,1024);
-		lldp.packString(str , "linden_lab_str");
-		lldp.packBinaryData((U8*)strBinary, sizeof(strBinary), "linden_lab_bd");
-		lldp.packBinaryDataFixed((U8*)strBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
-		lldp.packU8(valU8,"linden_lab_u8");
-		lldp.packU16(valU16,"linden_lab_u16");
-		lldp.packU32(valU32, "linden_lab_u32");
-		lldp.packS32(valS32, "linden_lab_s32");
-		lldp.packF32(valF32, "linden_lab_f32");
-		lldp.packColor4(llcol4, "linden_lab_col4");
-		lldp.packColor4U(llcol4u, "linden_lab_col4u");
-		lldp.packVector2(llvec2, "linden_lab_vec2");
-		lldp.packVector3(llvec3, "linden_lab_vec3");
-		lldp.packVector4(llvec4, "linden_lab_vec4");
-		uuid.generate();
-		lldp.packUUID(uuid, "linden_lab_uuid");
-
-		S32 cur_size = lldp.getCurrentSize();
-
-		LLDataPackerBinaryBuffer lldp1(packbuf, cur_size);
-		lldp1.unpackString(unpkstr , "linden_lab_str");
-		lldp1.unpackBinaryData((U8*)unpkstrBinary, unpksizeBinary, "linden_lab_bd");
-		lldp1.unpackBinaryDataFixed((U8*)unpkstrBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
-		lldp1.unpackU8(unpkvalU8,"linden_lab_u8");
-		lldp1.unpackU16(unpkvalU16,"linden_lab_u16");
-		lldp1.unpackU32(unpkvalU32, "linden_lab_u32");
-		lldp1.unpackS32(unpkvalS32, "linden_lab_s32");
-		lldp1.unpackF32(unpkvalF32, "linden_lab_f32");
-		lldp1.unpackColor4(unpkllcol4, "linden_lab_col4");
-		lldp1.unpackColor4U(unpkllcol4u, "linden_lab_col4u");
-		lldp1.unpackVector2(unpkllvec2, "linden_lab_vec2");
-		lldp1.unpackVector3(unpkllvec3, "linden_lab_vec3");
-		lldp1.unpackVector4(unpkllvec4, "linden_lab_vec4");
-		lldp1.unpackUUID(unpkuuid, "linden_lab_uuid");
-
-		ensure("LLDataPackerBinaryBuffer::packString failed", strcmp(str, unpkstr.c_str())  == 0);
-		ensure("LLDataPackerBinaryBuffer::packBinaryData failed", strcmp(strBinary, unpkstrBinary)  == 0);
-		ensure("LLDataPackerBinaryBuffer::packBinaryDataFixed failed", strcmp(strBinaryFixed, unpkstrBinaryFixed) == 0);
-		ensure_equals("LLDataPackerBinaryBuffer::packU8 failed", valU8, unpkvalU8);
-		ensure_equals("LLDataPackerBinaryBuffer::packU16 failed", valU16, unpkvalU16);
-		ensure_equals("LLDataPackerBinaryBuffer::packU32 failed", valU32, unpkvalU32);
-		ensure_equals("LLDataPackerBinaryBuffer::packS32 failed", valS32, unpkvalS32);
-		ensure("LLDataPackerBinaryBuffer::packF32 failed", is_approx_equal(valF32, unpkvalF32));
-		ensure_equals("LLDataPackerBinaryBuffer::packColor4 failed", llcol4, unpkllcol4);
-		ensure_equals("LLDataPackerBinaryBuffer::packColor4U failed", llcol4u, unpkllcol4u);
-		ensure_equals("LLDataPackerBinaryBuffer::packVector2 failed", llvec2, unpkllvec2);
-		ensure_equals("LLDataPackerBinaryBuffer::packVector3 failed", llvec3, unpkllvec3);
-		ensure_equals("LLDataPackerBinaryBuffer::packVector4 failed", llvec4, unpkllvec4);
-		ensure_equals("LLDataPackerBinaryBuffer::packUUID failed", uuid, unpkuuid);
-	}
-
-	template<> template<>
-	void datapacker_test_object_t::test<3>()
-	{
-		U8 packbuf[128];
-		char str[] = "SecondLife is virtual World";
-		S32 strSize = sizeof(str); // include '\0'
-		LLDataPackerBinaryBuffer lldp(packbuf, 128);
-		lldp.packString(str , "linden_lab");
-
-		ensure("LLDataPackerBinaryBuffer: current size is wrong", strSize == lldp.getCurrentSize());
-		ensure("LLDataPackerBinaryBuffer: buffer size is wrong", 128 == lldp.getBufferSize());
-
-		lldp.reset();
-		ensure("LLDataPackerBinaryBuffer::reset failed",0 == lldp.getCurrentSize());
-	}
-
-	template<> template<>
-	void datapacker_test_object_t::test<4>()
-	{
-		U8* packbuf = new U8[128];
-		char str[] = "SecondLife is virtual World";
-		LLDataPackerBinaryBuffer lldp(packbuf, 128);
-		lldp.packString(str , "linden_lab");
-		lldp.freeBuffer();
-		ensure("LLDataPackerBinaryBuffer.freeBuffer failed" , 0 == lldp.getBufferSize());
-
-	}
-
-	template<> template<>
-	void datapacker_test_object_t::test<5>()
-	{
-		U8 buf[] = "SecondLife is virtual World";
-		S32 size = sizeof(buf);
-		LLDataPackerBinaryBuffer lldp(buf, size);
-		U8 new_buf[] = "Its Amazing";
-		size = sizeof(new_buf);
-		lldp.assignBuffer(new_buf, size);
-		ensure("LLDataPackerBinaryBuffer::assignBuffer failed" , ((lldp.getBufferSize() == size) && (0 == lldp.getCurrentSize()))) ;
-	}
-
-	template<> template<>
-	void datapacker_test_object_t::test<6>()
-	{
-		U8 packbuf[128];
-		char str[] = "SecondLife is virtual World";
-		LLDataPackerBinaryBuffer lldp(packbuf, 128);
-		lldp.packString(str , "linden_lab");
-		U8 new_buffer[128];
-		std::string unpkbuf;
-		LLDataPackerBinaryBuffer lldp1(new_buffer,128);	
-		lldp1 = lldp;
-		lldp1.unpackString(unpkbuf, "linden_lab");
-		ensure("1. LLDataPackerBinaryBuffer::operator= failed" , lldp1.getBufferSize() == lldp.getBufferSize());
-		ensure_equals("2.LLDataPackerBinaryBuffer::operator= failed", str,unpkbuf);
-	}
-
-	//*********LLDataPackerAsciiBuffer
-
-	template<> template<>
-	void datapacker_test_object_t::test<7>()
-	{
-		char packbuf[128];
-		F32 f_val = 44.44f, f_unpkval;
-		LLDataPackerAsciiBuffer lldp(packbuf,128);
-		lldp.packFixed( f_val, "linden_lab", FALSE, 8, 8);
-
-		LLDataPackerAsciiBuffer lldp1(packbuf, lldp.getCurrentSize());
-		lldp1.unpackFixed(f_unpkval, "linden_lab", FALSE, 8, 8);
-		ensure_approximately_equals("LLDataPackerAsciiBuffer::packFixed failed", f_val, f_unpkval, 8);
-	}
-
-	template<> template<>
-	void datapacker_test_object_t::test<8>()
-	{
-		char packbuf[1024];
-
-		char str[] = "SecondLife is virtual World\0";
-		char strBinary[] = "SecondLife is virtual World";
-		char strBinaryFixed[] = "Fixed Data";
-		S32 sizeBinaryFixed = sizeof(strBinaryFixed);
-		U8 valU8 = 'C';
-		U16 valU16 = 0xFFFF;
-		U32 valU32 = 0xFFFFFFFF;
-		S32 valS32 = -94967295;
-		F32 valF32 = 4354355.44f ;
-		LLColor4 llcol4(3.3f, 0, 4.4f, 5.5f);
-		LLColor4U llcol4u(3, 128, 24, 33);
-		LLVector2 llvec2(333.33f, 444.44f);
-		LLVector3 llvec3(333.33f, 444.44f, 555.55f);
-		LLVector4 llvec4(4354355.44f, 444.44f, 555.55f, 666.66f);
-		LLUUID uuid;
-
-		std::string unpkstr;
-		char unpkstrBinary[256];
-		char unpkstrBinaryFixed[256];
-		S32 unpksizeBinary;
-		U8 unpkvalU8;
-		U16 unpkvalU16;
-		U32 unpkvalU32;
-		S32 unpkvalS32;
-		F32 unpkvalF32;
-		LLColor4 unpkllcol4;
-		LLColor4U unpkllcol4u;
-		LLVector2 unpkllvec2;
-		LLVector3 unpkllvec3;
-		LLVector4 unpkllvec4;
-		LLUUID unpkuuid;
-
-		LLDataPackerAsciiBuffer lldp(packbuf,1024);
-		lldp.packString(str , "linden_lab_str");
-		lldp.packBinaryData((U8*)strBinary, sizeof(strBinary), "linden_lab_bd");
-		lldp.packBinaryDataFixed((U8*)strBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
-		lldp.packU8(valU8,"linden_lab_u8");
-		lldp.packU16(valU16,"linden_lab_u16");
-		lldp.packU32(valU32, "linden_lab_u32");
-		lldp.packS32(valS32, "linden_lab_s32");
-		lldp.packF32(valF32, "linden_lab_f32");
-		lldp.packColor4(llcol4, "linden_lab_col4");
-		lldp.packColor4U(llcol4u, "linden_lab_col4u");
-		lldp.packVector2(llvec2, "linden_lab_vec2");
-		lldp.packVector3(llvec3, "linden_lab_vec3");
-		lldp.packVector4(llvec4, "linden_lab_vec4");
-		uuid.generate();
-		lldp.packUUID(uuid, "linden_lab_uuid");
-
-		S32 cur_size = lldp.getCurrentSize();
-
-		LLDataPackerAsciiBuffer lldp1(packbuf, cur_size);
-		lldp1.unpackString(unpkstr , "linden_lab_str");
-		lldp1.unpackBinaryData((U8*)unpkstrBinary, unpksizeBinary, "linden_lab_bd");
-		lldp1.unpackBinaryDataFixed((U8*)unpkstrBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
-		lldp1.unpackU8(unpkvalU8,"linden_lab_u8");
-		lldp1.unpackU16(unpkvalU16,"linden_lab_u16");
-		lldp1.unpackU32(unpkvalU32, "linden_lab_u32");
-		lldp1.unpackS32(unpkvalS32, "linden_lab_s32");
-		lldp1.unpackF32(unpkvalF32, "linden_lab_f32");
-		lldp1.unpackColor4(unpkllcol4, "linden_lab_col4");
-		lldp1.unpackColor4U(unpkllcol4u, "linden_lab_col4u");
-		lldp1.unpackVector2(unpkllvec2, "linden_lab_vec2");
-		lldp1.unpackVector3(unpkllvec3, "linden_lab_vec3");
-		lldp1.unpackVector4(unpkllvec4, "linden_lab_vec4");
-		lldp1.unpackUUID(unpkuuid, "linden_lab_uuid");
-
-		ensure("LLDataPackerAsciiBuffer::packString failed", strcmp(str, unpkstr.c_str())  == 0);
-		ensure("LLDataPackerAsciiBuffer::packBinaryData failed", strcmp(strBinary, unpkstrBinary)  == 0);
-		ensure("LLDataPackerAsciiBuffer::packBinaryDataFixed failed", strcmp(strBinaryFixed, unpkstrBinaryFixed) == 0);
-		ensure_equals("LLDataPackerAsciiBuffer::packU8 failed", valU8, unpkvalU8);
-		ensure_equals("LLDataPackerAsciiBuffer::packU16 failed", valU16, unpkvalU16);
-		ensure_equals("LLDataPackerAsciiBuffer::packU32 failed", valU32, unpkvalU32);
-		ensure_equals("LLDataPackerAsciiBuffer::packS32 failed", valS32, unpkvalS32);
-		ensure("LLDataPackerAsciiBuffer::packF32 failed", is_approx_equal(valF32, unpkvalF32));
-		ensure_equals("LLDataPackerAsciiBuffer::packColor4 failed", llcol4, unpkllcol4);
-		ensure_equals("LLDataPackerAsciiBuffer::packColor4U failed", llcol4u, unpkllcol4u);
-		ensure_equals("LLDataPackerAsciiBuffer::packVector2 failed", llvec2, unpkllvec2);
-		ensure_equals("LLDataPackerAsciiBuffer::packVector3 failed", llvec3, unpkllvec3);
-		ensure_equals("LLDataPackerAsciiBuffer::packVector4 failed", llvec4, unpkllvec4);
-		ensure_equals("LLDataPackerAsciiBuffer::packUUID failed", uuid, unpkuuid);
-	}
-
-	template<> template<>
-	void datapacker_test_object_t::test<9>()
-	{
-		char* packbuf = new char[128];
-		char str[] = "SecondLife is virtual World";
-		LLDataPackerAsciiBuffer lldp(packbuf, 128);
-		lldp.packString(str , "linden_lab");
-		lldp.freeBuffer();
-		ensure("LLDataPackerAsciiBuffer::freeBuffer failed" , 0 == lldp.getBufferSize());
-	}
-
-	template<> template<>
-	void datapacker_test_object_t::test<10>()
-	{
-		char buf[] = "SecondLife is virtual World";
-		S32 size = sizeof(buf);
-		LLDataPackerAsciiBuffer lldp(buf, size);
-		char new_buf[] = "Its Amazing";
-		size = sizeof(new_buf);
-		lldp.assignBuffer(new_buf, size);
-		ensure("LLDataPackerAsciiBuffer::assignBuffer failed" , ((lldp.getBufferSize() == size) && (1 == lldp.getCurrentSize()))) ;
-	}
-
-	//*********LLDataPackerAsciiFile
-
-	template<> template<>
-	void datapacker_test_object_t::test<11>()
-	{
-		F32 f_val = 44.44f, f_unpkval;
-
-		LLFILE* fp = LLFile::fopen(TEST_FILE_NAME, "w+");
-		if(!fp)
-		{
-			LL_ERRS() << "File couldnt be open" << LL_ENDL;
-			return;
-		}
-
-		LLDataPackerAsciiFile lldp(fp,2);
-		lldp.packFixed( f_val, "linden_lab", FALSE, 8, 8);
-
-		fflush(fp);	
-		fseek(fp,0,SEEK_SET);
-		LLDataPackerAsciiFile lldp1(fp,2);
-
-		lldp1.unpackFixed(f_unpkval, "linden_lab", FALSE, 8, 8);
-		fclose(fp);
-
-		ensure_approximately_equals("LLDataPackerAsciiFile::packFixed failed", f_val, f_unpkval, 8);
-	}
-
-	template<> template<>
-	void datapacker_test_object_t::test<12>()
-	{
-		char str[] = "SecondLife is virtual World\0";
-		char strBinary[] = "SecondLife is virtual World";
-		char strBinaryFixed[] = "Fixed Data";
-		S32 sizeBinaryFixed = sizeof(strBinaryFixed);
-		U8 valU8 = 'C';
-		U16 valU16 = 0xFFFF;
-		U32 valU32 = 0xFFFFFFFF;
-		S32 valS32 = -94967295;
-		F32 valF32 = 4354355.44f ;
-		LLColor4 llcol4(3.3f, 0, 4.4f, 5.5f);
-		LLColor4U llcol4u(3, 128, 24, 33);
-		LLVector2 llvec2(333.33f, 444.44f);
-		LLVector3 llvec3(333.33f, 444.44f, 555.55f);
-		LLVector4 llvec4(333.33f, 444.44f, 555.55f, 666.66f);
-		LLUUID uuid;
-
-		std::string unpkstr;
-		char unpkstrBinary[256];
-		char unpkstrBinaryFixed[256];
-		S32 unpksizeBinary;
-		U8 unpkvalU8;
-		U16 unpkvalU16;
-		U32 unpkvalU32;
-		S32 unpkvalS32;
-		F32 unpkvalF32;
-		LLColor4 unpkllcol4;
-		LLColor4U unpkllcol4u;
-		LLVector2 unpkllvec2;
-		LLVector3 unpkllvec3;
-		LLVector4 unpkllvec4;
-		LLUUID unpkuuid;
-
-		LLFILE* fp = LLFile::fopen(TEST_FILE_NAME,"w+");
-		if(!fp)
-		{
-			LL_ERRS() << "File couldnt be open" << LL_ENDL;
-			return;
-		}
-
-		LLDataPackerAsciiFile lldp(fp,2);
-
-		lldp.packString(str , "linden_lab_str");
-		lldp.packBinaryData((U8*)strBinary, sizeof(strBinary), "linden_lab_bd");
-		lldp.packBinaryDataFixed((U8*)strBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
-		lldp.packU8(valU8,"linden_lab_u8");
-		lldp.packU16(valU16,"linden_lab_u16");
-		lldp.packU32(valU32, "linden_lab_u32");
-		lldp.packS32(valS32, "linden_lab_s32");
-		lldp.packF32(valF32, "linden_lab_f32");
-		lldp.packColor4(llcol4, "linden_lab_col4");
-		lldp.packColor4U(llcol4u, "linden_lab_col4u");
-		lldp.packVector2(llvec2, "linden_lab_vec2");
-		lldp.packVector3(llvec3, "linden_lab_vec3");
-		lldp.packVector4(llvec4, "linden_lab_vec4");
-		uuid.generate();
-		lldp.packUUID(uuid, "linden_lab_uuid");
-
-		fflush(fp);	
-		fseek(fp,0,SEEK_SET);
-		LLDataPackerAsciiFile lldp1(fp,2);
-
-		lldp1.unpackString(unpkstr , "linden_lab_str");
-		lldp1.unpackBinaryData((U8*)unpkstrBinary, unpksizeBinary, "linden_lab_bd");
-		lldp1.unpackBinaryDataFixed((U8*)unpkstrBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
-		lldp1.unpackU8(unpkvalU8,"linden_lab_u8");
-		lldp1.unpackU16(unpkvalU16,"linden_lab_u16");
-		lldp1.unpackU32(unpkvalU32, "linden_lab_u32");
-		lldp1.unpackS32(unpkvalS32, "linden_lab_s32");
-		lldp1.unpackF32(unpkvalF32, "linden_lab_f32");
-		lldp1.unpackColor4(unpkllcol4, "linden_lab_col4");
-		lldp1.unpackColor4U(unpkllcol4u, "linden_lab_col4u");
-		lldp1.unpackVector2(unpkllvec2, "linden_lab_vec2");
-		lldp1.unpackVector3(unpkllvec3, "linden_lab_vec3");
-		lldp1.unpackVector4(unpkllvec4, "linden_lab_vec4");
-		lldp1.unpackUUID(unpkuuid, "linden_lab_uuid");
-
-		fclose(fp);
-
-		ensure("LLDataPackerAsciiFile::packString failed", strcmp(str, unpkstr.c_str())  == 0);
-		ensure("LLDataPackerAsciiFile::packBinaryData failed", strcmp(strBinary, unpkstrBinary)  == 0);
-		ensure("LLDataPackerAsciiFile::packBinaryDataFixed failed", strcmp(strBinaryFixed, unpkstrBinaryFixed) == 0);
-		ensure_equals("LLDataPackerAsciiFile::packU8 failed", valU8, unpkvalU8);
-		ensure_equals("LLDataPackerAsciiFile::packU16 failed", valU16, unpkvalU16);
-		ensure_equals("LLDataPackerAsciiFile::packU32 failed", valU32, unpkvalU32);
-		ensure_equals("LLDataPackerAsciiFile::packS32 failed", valS32, unpkvalS32);
-		ensure("LLDataPackerAsciiFile::packF32 failed", is_approx_equal(valF32, unpkvalF32));
-		ensure_equals("LLDataPackerAsciiFile::packColor4 failed", llcol4, unpkllcol4);
-		ensure_equals("LLDataPackerAsciiFile::packColor4U failed", llcol4u, unpkllcol4u);
-		ensure_equals("LLDataPackerAsciiFile::packVector2 failed", llvec2, unpkllvec2);
-		ensure_equals("LLDataPackerAsciiFile::packVector3 failed", llvec3, unpkllvec3);
-		ensure_equals("LLDataPackerAsciiFile::packVector4 failed", llvec4, unpkllvec4);
-		ensure_equals("LLDataPackerAsciiFile::packUUID failed", uuid, unpkuuid);
-	}
-
-	template<> template<>
-	void datapacker_test_object_t::test<13>()
-	{
-		F32 f_val = 44.44f, f_unpkval;
-
-		std::ostringstream ostr;
-		LLDataPackerAsciiFile lldp(ostr,2);
-		lldp.packFixed( f_val, "linden_lab", FALSE, 8, 8);
-
-		std::istringstream istr(ostr.str());
-		LLDataPackerAsciiFile lldp1(istr,2);
-
-		lldp1.unpackFixed(f_unpkval, "linden_lab", FALSE, 8, 8);
-
-		ensure_approximately_equals("LLDataPackerAsciiFile::packFixed (iostring) failed", f_val, f_unpkval, 8);
-	}
-
-	template<> template<>
-	void datapacker_test_object_t::test<14>()
-	{
-		char str[] = "SecondLife is virtual World\0";
-		char strBinary[] = "SecondLife is virtual World";
-		char strBinaryFixed[] = "Fixed Data";
-		S32 sizeBinaryFixed = sizeof(strBinaryFixed);
-		U8 valU8 = 'C';
-		U16 valU16 = 0xFFFF;
-		U32 valU32 = 0xFFFFFFFF;
-		S32 valS32 = -94967295;
-		F32 valF32 = 4354355.44f ;
-		LLColor4 llcol4(3.3f, 0, 4.4f, 5.5f);
-		LLColor4U llcol4u(3, 128, 24, 33);
-		LLVector2 llvec2(3333333.33f, 444.333344f);
-		LLVector3 llvec3(3323233.33f, 444.4324f, 555.553232f);
-		LLVector4 llvec4(333.33233f, 444.4323234f, 55323225.55f, 6323236.66f);
-		LLUUID uuid;
-
-		std::string unpkstr;
-		char unpkstrBinary[256];
-		char unpkstrBinaryFixed[256];
-		S32 unpksizeBinary;
-		U8 unpkvalU8;
-		U16 unpkvalU16;
-		U32 unpkvalU32;
-		S32 unpkvalS32;
-		F32 unpkvalF32;
-		LLColor4 unpkllcol4;
-		LLColor4U unpkllcol4u;
-		LLVector2 unpkllvec2;
-		LLVector3 unpkllvec3;
-		LLVector4 unpkllvec4;
-		LLUUID unpkuuid;
-
-		std::ostringstream ostr;
-		LLDataPackerAsciiFile lldp(ostr,2);
-
-		lldp.packString(str , "linden_lab_str");
-		lldp.packBinaryData((U8*)strBinary, sizeof(strBinary), "linden_lab_bd");
-		lldp.packBinaryDataFixed((U8*)strBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
-		lldp.packU8(valU8,"linden_lab_u8");
-		lldp.packU16(valU16,"linden_lab_u16");
-		lldp.packU32(valU32, "linden_lab_u32");
-		lldp.packS32(valS32, "linden_lab_s32");
-		lldp.packF32(valF32, "linden_lab_f32");
-		lldp.packColor4(llcol4, "linden_lab_col4");
-		lldp.packColor4U(llcol4u, "linden_lab_col4u");
-		lldp.packVector2(llvec2, "linden_lab_vec2");
-		lldp.packVector3(llvec3, "linden_lab_vec3");
-		lldp.packVector4(llvec4, "linden_lab_vec4");
-		uuid.generate();
-		lldp.packUUID(uuid, "linden_lab_uuid");
-
-		std::istringstream istr(ostr.str());
-		LLDataPackerAsciiFile lldp1(istr,2);
-
-		lldp1.unpackString(unpkstr , "linden_lab_str");
-		lldp1.unpackBinaryData((U8*)unpkstrBinary, unpksizeBinary, "linden_lab_bd");
-		lldp1.unpackBinaryDataFixed((U8*)unpkstrBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
-		lldp1.unpackU8(unpkvalU8,"linden_lab_u8");
-		lldp1.unpackU16(unpkvalU16,"linden_lab_u16");
-		lldp1.unpackU32(unpkvalU32, "linden_lab_u32");
-		lldp1.unpackS32(unpkvalS32, "linden_lab_s32");
-		lldp1.unpackF32(unpkvalF32, "linden_lab_f32");
-		lldp1.unpackColor4(unpkllcol4, "linden_lab_col4");
-		lldp1.unpackColor4U(unpkllcol4u, "linden_lab_col4u");
-		lldp1.unpackVector2(unpkllvec2, "linden_lab_vec2");
-		lldp1.unpackVector3(unpkllvec3, "linden_lab_vec3");
-		lldp1.unpackVector4(unpkllvec4, "linden_lab_vec4");
-		lldp1.unpackUUID(unpkuuid, "linden_lab_uuid");
-
-		ensure("LLDataPackerAsciiFile::packString (iostring) failed", strcmp(str, unpkstr.c_str())  == 0);
-		ensure("LLDataPackerAsciiFile::packBinaryData (iostring) failed", strcmp(strBinary, unpkstrBinary)  == 0);
-		ensure("LLDataPackerAsciiFile::packBinaryDataFixed (iostring) failed", strcmp(strBinaryFixed, unpkstrBinaryFixed) == 0);
-		ensure_equals("LLDataPackerAsciiFile::packU8 (iostring) failed", valU8, unpkvalU8);
-		ensure_equals("LLDataPackerAsciiFile::packU16 (iostring) failed", valU16, unpkvalU16);
-		ensure_equals("LLDataPackerAsciiFile::packU32 (iostring) failed", valU32, unpkvalU32);
-		ensure_equals("LLDataPackerAsciiFile::packS32 (iostring) failed", valS32, unpkvalS32);
-		ensure("LLDataPackerAsciiFile::packF32 (iostring) failed", is_approx_equal(valF32, unpkvalF32));
-		ensure_equals("LLDataPackerAsciiFile::packColor4 (iostring) failed", llcol4, unpkllcol4);
-		ensure_equals("LLDataPackerAsciiFile::packColor4U (iostring) failed", llcol4u, unpkllcol4u);
-		ensure_equals("LLDataPackerAsciiFile::packVector2 (iostring) failed", llvec2, unpkllvec2);
-		ensure_equals("LLDataPackerAsciiFile::packVector3 (iostring) failed", llvec3, unpkllvec3);
-		ensure_equals("LLDataPackerAsciiFile::packVector4 (iostring) failed", llvec4, unpkllvec4);
-		ensure_equals("LLDataPackerAsciiFile::packUUID (iostring) failed", uuid, unpkuuid);
-	}
+    struct datapacker_test
+    {
+    };
+    typedef test_group<datapacker_test> datapacker_test_t;
+    typedef datapacker_test_t::object datapacker_test_object_t;
+    tut::datapacker_test_t tut_datapacker_test("datapacker_test");
+
+    //*********LLDataPackerBinaryBuffer
+    template<> template<>
+    void datapacker_test_object_t::test<1>()
+    {
+        U8 packbuf[128];
+        F32 f_val1 = 44.44f, f_unpkval1;
+        F32 f_val2 = 12344.443232f, f_unpkval2;
+        F32 f_val3 = 44.4456789f, f_unpkval3;
+        LLDataPackerBinaryBuffer lldp(packbuf,128);
+        lldp.packFixed( f_val1, "linden_lab", FALSE, 8, 8);
+        lldp.packFixed( f_val2, "linden_lab", FALSE, 14, 16);
+        lldp.packFixed( f_val3, "linden_lab", FALSE, 8, 23);
+
+        LLDataPackerBinaryBuffer lldp1(packbuf, lldp.getCurrentSize());
+        lldp1.unpackFixed(f_unpkval1, "linden_lab", FALSE, 8, 8);
+        lldp1.unpackFixed(f_unpkval2, "linden_lab", FALSE, 14, 16);
+        lldp1.unpackFixed(f_unpkval3, "linden_lab", FALSE, 8, 23);
+        ensure_approximately_equals("LLDataPackerBinaryBuffer::packFixed 8 failed", f_val1, f_unpkval1, 8);
+        ensure_approximately_equals("LLDataPackerBinaryBuffer::packFixed 16 failed", f_val2, f_unpkval2, 16);
+        ensure_approximately_equals("LLDataPackerBinaryBuffer::packFixed 23 failed", f_val3, f_unpkval3, 31);
+    }
+
+    template<> template<>
+    void datapacker_test_object_t::test<2>()
+    {
+        U8 packbuf[1024];
+
+        char str[] = "SecondLife is virtual World\0";
+        char strBinary[] = "SecondLife is virtual World";
+        char strBinaryFixed[] = "Fixed Data";
+        S32 sizeBinaryFixed = sizeof(strBinaryFixed);
+        U8 valU8 = 'C';
+        U16 valU16 = 0xFFFF;
+        U32 valU32 = 0xFFFFFFFF;
+        S32 valS32 = -94967295;
+        F32 valF32 = 4354355.44f ;
+        LLColor4 llcol4(3.3f, 0, 4.4f, 5.5f);
+        LLColor4U llcol4u(3, 128, 24, 33);
+        LLVector2 llvec2(333.33f, 444.44f);
+        LLVector3 llvec3(333.33f, 444.44f, 555.55f);
+        LLVector4 llvec4(333.33f, 444.44f, 555.55f, 666.66f);
+        LLUUID uuid;
+
+        std::string unpkstr;
+        char unpkstrBinary[256];
+        char unpkstrBinaryFixed[256];
+        S32 unpksizeBinary;
+        U8 unpkvalU8;
+        U16 unpkvalU16;
+        U32 unpkvalU32;
+        S32 unpkvalS32;
+        F32 unpkvalF32;
+        LLColor4 unpkllcol4;
+        LLColor4U unpkllcol4u;
+        LLVector2 unpkllvec2;
+        LLVector3 unpkllvec3;
+        LLVector4 unpkllvec4;
+        LLUUID unpkuuid;
+
+        LLDataPackerBinaryBuffer lldp(packbuf,1024);
+        lldp.packString(str , "linden_lab_str");
+        lldp.packBinaryData((U8*)strBinary, sizeof(strBinary), "linden_lab_bd");
+        lldp.packBinaryDataFixed((U8*)strBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
+        lldp.packU8(valU8,"linden_lab_u8");
+        lldp.packU16(valU16,"linden_lab_u16");
+        lldp.packU32(valU32, "linden_lab_u32");
+        lldp.packS32(valS32, "linden_lab_s32");
+        lldp.packF32(valF32, "linden_lab_f32");
+        lldp.packColor4(llcol4, "linden_lab_col4");
+        lldp.packColor4U(llcol4u, "linden_lab_col4u");
+        lldp.packVector2(llvec2, "linden_lab_vec2");
+        lldp.packVector3(llvec3, "linden_lab_vec3");
+        lldp.packVector4(llvec4, "linden_lab_vec4");
+        uuid.generate();
+        lldp.packUUID(uuid, "linden_lab_uuid");
+
+        S32 cur_size = lldp.getCurrentSize();
+
+        LLDataPackerBinaryBuffer lldp1(packbuf, cur_size);
+        lldp1.unpackString(unpkstr , "linden_lab_str");
+        lldp1.unpackBinaryData((U8*)unpkstrBinary, unpksizeBinary, "linden_lab_bd");
+        lldp1.unpackBinaryDataFixed((U8*)unpkstrBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
+        lldp1.unpackU8(unpkvalU8,"linden_lab_u8");
+        lldp1.unpackU16(unpkvalU16,"linden_lab_u16");
+        lldp1.unpackU32(unpkvalU32, "linden_lab_u32");
+        lldp1.unpackS32(unpkvalS32, "linden_lab_s32");
+        lldp1.unpackF32(unpkvalF32, "linden_lab_f32");
+        lldp1.unpackColor4(unpkllcol4, "linden_lab_col4");
+        lldp1.unpackColor4U(unpkllcol4u, "linden_lab_col4u");
+        lldp1.unpackVector2(unpkllvec2, "linden_lab_vec2");
+        lldp1.unpackVector3(unpkllvec3, "linden_lab_vec3");
+        lldp1.unpackVector4(unpkllvec4, "linden_lab_vec4");
+        lldp1.unpackUUID(unpkuuid, "linden_lab_uuid");
+
+        ensure("LLDataPackerBinaryBuffer::packString failed", strcmp(str, unpkstr.c_str())  == 0);
+        ensure("LLDataPackerBinaryBuffer::packBinaryData failed", strcmp(strBinary, unpkstrBinary)  == 0);
+        ensure("LLDataPackerBinaryBuffer::packBinaryDataFixed failed", strcmp(strBinaryFixed, unpkstrBinaryFixed) == 0);
+        ensure_equals("LLDataPackerBinaryBuffer::packU8 failed", valU8, unpkvalU8);
+        ensure_equals("LLDataPackerBinaryBuffer::packU16 failed", valU16, unpkvalU16);
+        ensure_equals("LLDataPackerBinaryBuffer::packU32 failed", valU32, unpkvalU32);
+        ensure_equals("LLDataPackerBinaryBuffer::packS32 failed", valS32, unpkvalS32);
+        ensure("LLDataPackerBinaryBuffer::packF32 failed", is_approx_equal(valF32, unpkvalF32));
+        ensure_equals("LLDataPackerBinaryBuffer::packColor4 failed", llcol4, unpkllcol4);
+        ensure_equals("LLDataPackerBinaryBuffer::packColor4U failed", llcol4u, unpkllcol4u);
+        ensure_equals("LLDataPackerBinaryBuffer::packVector2 failed", llvec2, unpkllvec2);
+        ensure_equals("LLDataPackerBinaryBuffer::packVector3 failed", llvec3, unpkllvec3);
+        ensure_equals("LLDataPackerBinaryBuffer::packVector4 failed", llvec4, unpkllvec4);
+        ensure_equals("LLDataPackerBinaryBuffer::packUUID failed", uuid, unpkuuid);
+    }
+
+    template<> template<>
+    void datapacker_test_object_t::test<3>()
+    {
+        U8 packbuf[128];
+        char str[] = "SecondLife is virtual World";
+        S32 strSize = sizeof(str); // include '\0'
+        LLDataPackerBinaryBuffer lldp(packbuf, 128);
+        lldp.packString(str , "linden_lab");
+
+        ensure("LLDataPackerBinaryBuffer: current size is wrong", strSize == lldp.getCurrentSize());
+        ensure("LLDataPackerBinaryBuffer: buffer size is wrong", 128 == lldp.getBufferSize());
+
+        lldp.reset();
+        ensure("LLDataPackerBinaryBuffer::reset failed",0 == lldp.getCurrentSize());
+    }
+
+    template<> template<>
+    void datapacker_test_object_t::test<4>()
+    {
+        U8* packbuf = new U8[128];
+        char str[] = "SecondLife is virtual World";
+        LLDataPackerBinaryBuffer lldp(packbuf, 128);
+        lldp.packString(str , "linden_lab");
+        lldp.freeBuffer();
+        ensure("LLDataPackerBinaryBuffer.freeBuffer failed" , 0 == lldp.getBufferSize());
+
+    }
+
+    template<> template<>
+    void datapacker_test_object_t::test<5>()
+    {
+        U8 buf[] = "SecondLife is virtual World";
+        S32 size = sizeof(buf);
+        LLDataPackerBinaryBuffer lldp(buf, size);
+        U8 new_buf[] = "Its Amazing";
+        size = sizeof(new_buf);
+        lldp.assignBuffer(new_buf, size);
+        ensure("LLDataPackerBinaryBuffer::assignBuffer failed" , ((lldp.getBufferSize() == size) && (0 == lldp.getCurrentSize()))) ;
+    }
+
+    template<> template<>
+    void datapacker_test_object_t::test<6>()
+    {
+        U8 packbuf[128];
+        char str[] = "SecondLife is virtual World";
+        LLDataPackerBinaryBuffer lldp(packbuf, 128);
+        lldp.packString(str , "linden_lab");
+        U8 new_buffer[128];
+        std::string unpkbuf;
+        LLDataPackerBinaryBuffer lldp1(new_buffer,128);
+        lldp1 = lldp;
+        lldp1.unpackString(unpkbuf, "linden_lab");
+        ensure("1. LLDataPackerBinaryBuffer::operator= failed" , lldp1.getBufferSize() == lldp.getBufferSize());
+        ensure_equals("2.LLDataPackerBinaryBuffer::operator= failed", str,unpkbuf);
+    }
+
+    //*********LLDataPackerAsciiBuffer
+
+    template<> template<>
+    void datapacker_test_object_t::test<7>()
+    {
+        char packbuf[128];
+        F32 f_val = 44.44f, f_unpkval;
+        LLDataPackerAsciiBuffer lldp(packbuf,128);
+        lldp.packFixed( f_val, "linden_lab", FALSE, 8, 8);
+
+        LLDataPackerAsciiBuffer lldp1(packbuf, lldp.getCurrentSize());
+        lldp1.unpackFixed(f_unpkval, "linden_lab", FALSE, 8, 8);
+        ensure_approximately_equals("LLDataPackerAsciiBuffer::packFixed failed", f_val, f_unpkval, 8);
+    }
+
+    template<> template<>
+    void datapacker_test_object_t::test<8>()
+    {
+        char packbuf[1024];
+
+        char str[] = "SecondLife is virtual World\0";
+        char strBinary[] = "SecondLife is virtual World";
+        char strBinaryFixed[] = "Fixed Data";
+        S32 sizeBinaryFixed = sizeof(strBinaryFixed);
+        U8 valU8 = 'C';
+        U16 valU16 = 0xFFFF;
+        U32 valU32 = 0xFFFFFFFF;
+        S32 valS32 = -94967295;
+        F32 valF32 = 4354355.44f ;
+        LLColor4 llcol4(3.3f, 0, 4.4f, 5.5f);
+        LLColor4U llcol4u(3, 128, 24, 33);
+        LLVector2 llvec2(333.33f, 444.44f);
+        LLVector3 llvec3(333.33f, 444.44f, 555.55f);
+        LLVector4 llvec4(4354355.44f, 444.44f, 555.55f, 666.66f);
+        LLUUID uuid;
+
+        std::string unpkstr;
+        char unpkstrBinary[256];
+        char unpkstrBinaryFixed[256];
+        S32 unpksizeBinary;
+        U8 unpkvalU8;
+        U16 unpkvalU16;
+        U32 unpkvalU32;
+        S32 unpkvalS32;
+        F32 unpkvalF32;
+        LLColor4 unpkllcol4;
+        LLColor4U unpkllcol4u;
+        LLVector2 unpkllvec2;
+        LLVector3 unpkllvec3;
+        LLVector4 unpkllvec4;
+        LLUUID unpkuuid;
+
+        LLDataPackerAsciiBuffer lldp(packbuf,1024);
+        lldp.packString(str , "linden_lab_str");
+        lldp.packBinaryData((U8*)strBinary, sizeof(strBinary), "linden_lab_bd");
+        lldp.packBinaryDataFixed((U8*)strBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
+        lldp.packU8(valU8,"linden_lab_u8");
+        lldp.packU16(valU16,"linden_lab_u16");
+        lldp.packU32(valU32, "linden_lab_u32");
+        lldp.packS32(valS32, "linden_lab_s32");
+        lldp.packF32(valF32, "linden_lab_f32");
+        lldp.packColor4(llcol4, "linden_lab_col4");
+        lldp.packColor4U(llcol4u, "linden_lab_col4u");
+        lldp.packVector2(llvec2, "linden_lab_vec2");
+        lldp.packVector3(llvec3, "linden_lab_vec3");
+        lldp.packVector4(llvec4, "linden_lab_vec4");
+        uuid.generate();
+        lldp.packUUID(uuid, "linden_lab_uuid");
+
+        S32 cur_size = lldp.getCurrentSize();
+
+        LLDataPackerAsciiBuffer lldp1(packbuf, cur_size);
+        lldp1.unpackString(unpkstr , "linden_lab_str");
+        lldp1.unpackBinaryData((U8*)unpkstrBinary, unpksizeBinary, "linden_lab_bd");
+        lldp1.unpackBinaryDataFixed((U8*)unpkstrBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
+        lldp1.unpackU8(unpkvalU8,"linden_lab_u8");
+        lldp1.unpackU16(unpkvalU16,"linden_lab_u16");
+        lldp1.unpackU32(unpkvalU32, "linden_lab_u32");
+        lldp1.unpackS32(unpkvalS32, "linden_lab_s32");
+        lldp1.unpackF32(unpkvalF32, "linden_lab_f32");
+        lldp1.unpackColor4(unpkllcol4, "linden_lab_col4");
+        lldp1.unpackColor4U(unpkllcol4u, "linden_lab_col4u");
+        lldp1.unpackVector2(unpkllvec2, "linden_lab_vec2");
+        lldp1.unpackVector3(unpkllvec3, "linden_lab_vec3");
+        lldp1.unpackVector4(unpkllvec4, "linden_lab_vec4");
+        lldp1.unpackUUID(unpkuuid, "linden_lab_uuid");
+
+        ensure("LLDataPackerAsciiBuffer::packString failed", strcmp(str, unpkstr.c_str())  == 0);
+        ensure("LLDataPackerAsciiBuffer::packBinaryData failed", strcmp(strBinary, unpkstrBinary)  == 0);
+        ensure("LLDataPackerAsciiBuffer::packBinaryDataFixed failed", strcmp(strBinaryFixed, unpkstrBinaryFixed) == 0);
+        ensure_equals("LLDataPackerAsciiBuffer::packU8 failed", valU8, unpkvalU8);
+        ensure_equals("LLDataPackerAsciiBuffer::packU16 failed", valU16, unpkvalU16);
+        ensure_equals("LLDataPackerAsciiBuffer::packU32 failed", valU32, unpkvalU32);
+        ensure_equals("LLDataPackerAsciiBuffer::packS32 failed", valS32, unpkvalS32);
+        ensure("LLDataPackerAsciiBuffer::packF32 failed", is_approx_equal(valF32, unpkvalF32));
+        ensure_equals("LLDataPackerAsciiBuffer::packColor4 failed", llcol4, unpkllcol4);
+        ensure_equals("LLDataPackerAsciiBuffer::packColor4U failed", llcol4u, unpkllcol4u);
+        ensure_equals("LLDataPackerAsciiBuffer::packVector2 failed", llvec2, unpkllvec2);
+        ensure_equals("LLDataPackerAsciiBuffer::packVector3 failed", llvec3, unpkllvec3);
+        ensure_equals("LLDataPackerAsciiBuffer::packVector4 failed", llvec4, unpkllvec4);
+        ensure_equals("LLDataPackerAsciiBuffer::packUUID failed", uuid, unpkuuid);
+    }
+
+    template<> template<>
+    void datapacker_test_object_t::test<9>()
+    {
+        char* packbuf = new char[128];
+        char str[] = "SecondLife is virtual World";
+        LLDataPackerAsciiBuffer lldp(packbuf, 128);
+        lldp.packString(str , "linden_lab");
+        lldp.freeBuffer();
+        ensure("LLDataPackerAsciiBuffer::freeBuffer failed" , 0 == lldp.getBufferSize());
+    }
+
+    template<> template<>
+    void datapacker_test_object_t::test<10>()
+    {
+        char buf[] = "SecondLife is virtual World";
+        S32 size = sizeof(buf);
+        LLDataPackerAsciiBuffer lldp(buf, size);
+        char new_buf[] = "Its Amazing";
+        size = sizeof(new_buf);
+        lldp.assignBuffer(new_buf, size);
+        ensure("LLDataPackerAsciiBuffer::assignBuffer failed" , ((lldp.getBufferSize() == size) && (1 == lldp.getCurrentSize()))) ;
+    }
+
+    //*********LLDataPackerAsciiFile
+
+    template<> template<>
+    void datapacker_test_object_t::test<11>()
+    {
+        F32 f_val = 44.44f, f_unpkval;
+
+        LLFILE* fp = LLFile::fopen(TEST_FILE_NAME, "w+");
+        if(!fp)
+        {
+            LL_ERRS() << "File couldnt be open" << LL_ENDL;
+            return;
+        }
+
+        LLDataPackerAsciiFile lldp(fp,2);
+        lldp.packFixed( f_val, "linden_lab", FALSE, 8, 8);
+
+        fflush(fp);
+        fseek(fp,0,SEEK_SET);
+        LLDataPackerAsciiFile lldp1(fp,2);
+
+        lldp1.unpackFixed(f_unpkval, "linden_lab", FALSE, 8, 8);
+        fclose(fp);
+
+        ensure_approximately_equals("LLDataPackerAsciiFile::packFixed failed", f_val, f_unpkval, 8);
+    }
+
+    template<> template<>
+    void datapacker_test_object_t::test<12>()
+    {
+        char str[] = "SecondLife is virtual World\0";
+        char strBinary[] = "SecondLife is virtual World";
+        char strBinaryFixed[] = "Fixed Data";
+        S32 sizeBinaryFixed = sizeof(strBinaryFixed);
+        U8 valU8 = 'C';
+        U16 valU16 = 0xFFFF;
+        U32 valU32 = 0xFFFFFFFF;
+        S32 valS32 = -94967295;
+        F32 valF32 = 4354355.44f ;
+        LLColor4 llcol4(3.3f, 0, 4.4f, 5.5f);
+        LLColor4U llcol4u(3, 128, 24, 33);
+        LLVector2 llvec2(333.33f, 444.44f);
+        LLVector3 llvec3(333.33f, 444.44f, 555.55f);
+        LLVector4 llvec4(333.33f, 444.44f, 555.55f, 666.66f);
+        LLUUID uuid;
+
+        std::string unpkstr;
+        char unpkstrBinary[256];
+        char unpkstrBinaryFixed[256];
+        S32 unpksizeBinary;
+        U8 unpkvalU8;
+        U16 unpkvalU16;
+        U32 unpkvalU32;
+        S32 unpkvalS32;
+        F32 unpkvalF32;
+        LLColor4 unpkllcol4;
+        LLColor4U unpkllcol4u;
+        LLVector2 unpkllvec2;
+        LLVector3 unpkllvec3;
+        LLVector4 unpkllvec4;
+        LLUUID unpkuuid;
+
+        LLFILE* fp = LLFile::fopen(TEST_FILE_NAME,"w+");
+        if(!fp)
+        {
+            LL_ERRS() << "File couldnt be open" << LL_ENDL;
+            return;
+        }
+
+        LLDataPackerAsciiFile lldp(fp,2);
+
+        lldp.packString(str , "linden_lab_str");
+        lldp.packBinaryData((U8*)strBinary, sizeof(strBinary), "linden_lab_bd");
+        lldp.packBinaryDataFixed((U8*)strBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
+        lldp.packU8(valU8,"linden_lab_u8");
+        lldp.packU16(valU16,"linden_lab_u16");
+        lldp.packU32(valU32, "linden_lab_u32");
+        lldp.packS32(valS32, "linden_lab_s32");
+        lldp.packF32(valF32, "linden_lab_f32");
+        lldp.packColor4(llcol4, "linden_lab_col4");
+        lldp.packColor4U(llcol4u, "linden_lab_col4u");
+        lldp.packVector2(llvec2, "linden_lab_vec2");
+        lldp.packVector3(llvec3, "linden_lab_vec3");
+        lldp.packVector4(llvec4, "linden_lab_vec4");
+        uuid.generate();
+        lldp.packUUID(uuid, "linden_lab_uuid");
+
+        fflush(fp);
+        fseek(fp,0,SEEK_SET);
+        LLDataPackerAsciiFile lldp1(fp,2);
+
+        lldp1.unpackString(unpkstr , "linden_lab_str");
+        lldp1.unpackBinaryData((U8*)unpkstrBinary, unpksizeBinary, "linden_lab_bd");
+        lldp1.unpackBinaryDataFixed((U8*)unpkstrBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
+        lldp1.unpackU8(unpkvalU8,"linden_lab_u8");
+        lldp1.unpackU16(unpkvalU16,"linden_lab_u16");
+        lldp1.unpackU32(unpkvalU32, "linden_lab_u32");
+        lldp1.unpackS32(unpkvalS32, "linden_lab_s32");
+        lldp1.unpackF32(unpkvalF32, "linden_lab_f32");
+        lldp1.unpackColor4(unpkllcol4, "linden_lab_col4");
+        lldp1.unpackColor4U(unpkllcol4u, "linden_lab_col4u");
+        lldp1.unpackVector2(unpkllvec2, "linden_lab_vec2");
+        lldp1.unpackVector3(unpkllvec3, "linden_lab_vec3");
+        lldp1.unpackVector4(unpkllvec4, "linden_lab_vec4");
+        lldp1.unpackUUID(unpkuuid, "linden_lab_uuid");
+
+        fclose(fp);
+
+        ensure("LLDataPackerAsciiFile::packString failed", strcmp(str, unpkstr.c_str())  == 0);
+        ensure("LLDataPackerAsciiFile::packBinaryData failed", strcmp(strBinary, unpkstrBinary)  == 0);
+        ensure("LLDataPackerAsciiFile::packBinaryDataFixed failed", strcmp(strBinaryFixed, unpkstrBinaryFixed) == 0);
+        ensure_equals("LLDataPackerAsciiFile::packU8 failed", valU8, unpkvalU8);
+        ensure_equals("LLDataPackerAsciiFile::packU16 failed", valU16, unpkvalU16);
+        ensure_equals("LLDataPackerAsciiFile::packU32 failed", valU32, unpkvalU32);
+        ensure_equals("LLDataPackerAsciiFile::packS32 failed", valS32, unpkvalS32);
+        ensure("LLDataPackerAsciiFile::packF32 failed", is_approx_equal(valF32, unpkvalF32));
+        ensure_equals("LLDataPackerAsciiFile::packColor4 failed", llcol4, unpkllcol4);
+        ensure_equals("LLDataPackerAsciiFile::packColor4U failed", llcol4u, unpkllcol4u);
+        ensure_equals("LLDataPackerAsciiFile::packVector2 failed", llvec2, unpkllvec2);
+        ensure_equals("LLDataPackerAsciiFile::packVector3 failed", llvec3, unpkllvec3);
+        ensure_equals("LLDataPackerAsciiFile::packVector4 failed", llvec4, unpkllvec4);
+        ensure_equals("LLDataPackerAsciiFile::packUUID failed", uuid, unpkuuid);
+    }
+
+    template<> template<>
+    void datapacker_test_object_t::test<13>()
+    {
+        F32 f_val = 44.44f, f_unpkval;
+
+        std::ostringstream ostr;
+        LLDataPackerAsciiFile lldp(ostr,2);
+        lldp.packFixed( f_val, "linden_lab", FALSE, 8, 8);
+
+        std::istringstream istr(ostr.str());
+        LLDataPackerAsciiFile lldp1(istr,2);
+
+        lldp1.unpackFixed(f_unpkval, "linden_lab", FALSE, 8, 8);
+
+        ensure_approximately_equals("LLDataPackerAsciiFile::packFixed (iostring) failed", f_val, f_unpkval, 8);
+    }
+
+    template<> template<>
+    void datapacker_test_object_t::test<14>()
+    {
+        char str[] = "SecondLife is virtual World\0";
+        char strBinary[] = "SecondLife is virtual World";
+        char strBinaryFixed[] = "Fixed Data";
+        S32 sizeBinaryFixed = sizeof(strBinaryFixed);
+        U8 valU8 = 'C';
+        U16 valU16 = 0xFFFF;
+        U32 valU32 = 0xFFFFFFFF;
+        S32 valS32 = -94967295;
+        F32 valF32 = 4354355.44f ;
+        LLColor4 llcol4(3.3f, 0, 4.4f, 5.5f);
+        LLColor4U llcol4u(3, 128, 24, 33);
+        LLVector2 llvec2(3333333.33f, 444.333344f);
+        LLVector3 llvec3(3323233.33f, 444.4324f, 555.553232f);
+        LLVector4 llvec4(333.33233f, 444.4323234f, 55323225.55f, 6323236.66f);
+        LLUUID uuid;
+
+        std::string unpkstr;
+        char unpkstrBinary[256];
+        char unpkstrBinaryFixed[256];
+        S32 unpksizeBinary;
+        U8 unpkvalU8;
+        U16 unpkvalU16;
+        U32 unpkvalU32;
+        S32 unpkvalS32;
+        F32 unpkvalF32;
+        LLColor4 unpkllcol4;
+        LLColor4U unpkllcol4u;
+        LLVector2 unpkllvec2;
+        LLVector3 unpkllvec3;
+        LLVector4 unpkllvec4;
+        LLUUID unpkuuid;
+
+        std::ostringstream ostr;
+        LLDataPackerAsciiFile lldp(ostr,2);
+
+        lldp.packString(str , "linden_lab_str");
+        lldp.packBinaryData((U8*)strBinary, sizeof(strBinary), "linden_lab_bd");
+        lldp.packBinaryDataFixed((U8*)strBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
+        lldp.packU8(valU8,"linden_lab_u8");
+        lldp.packU16(valU16,"linden_lab_u16");
+        lldp.packU32(valU32, "linden_lab_u32");
+        lldp.packS32(valS32, "linden_lab_s32");
+        lldp.packF32(valF32, "linden_lab_f32");
+        lldp.packColor4(llcol4, "linden_lab_col4");
+        lldp.packColor4U(llcol4u, "linden_lab_col4u");
+        lldp.packVector2(llvec2, "linden_lab_vec2");
+        lldp.packVector3(llvec3, "linden_lab_vec3");
+        lldp.packVector4(llvec4, "linden_lab_vec4");
+        uuid.generate();
+        lldp.packUUID(uuid, "linden_lab_uuid");
+
+        std::istringstream istr(ostr.str());
+        LLDataPackerAsciiFile lldp1(istr,2);
+
+        lldp1.unpackString(unpkstr , "linden_lab_str");
+        lldp1.unpackBinaryData((U8*)unpkstrBinary, unpksizeBinary, "linden_lab_bd");
+        lldp1.unpackBinaryDataFixed((U8*)unpkstrBinaryFixed, sizeBinaryFixed, "linden_lab_bdf");
+        lldp1.unpackU8(unpkvalU8,"linden_lab_u8");
+        lldp1.unpackU16(unpkvalU16,"linden_lab_u16");
+        lldp1.unpackU32(unpkvalU32, "linden_lab_u32");
+        lldp1.unpackS32(unpkvalS32, "linden_lab_s32");
+        lldp1.unpackF32(unpkvalF32, "linden_lab_f32");
+        lldp1.unpackColor4(unpkllcol4, "linden_lab_col4");
+        lldp1.unpackColor4U(unpkllcol4u, "linden_lab_col4u");
+        lldp1.unpackVector2(unpkllvec2, "linden_lab_vec2");
+        lldp1.unpackVector3(unpkllvec3, "linden_lab_vec3");
+        lldp1.unpackVector4(unpkllvec4, "linden_lab_vec4");
+        lldp1.unpackUUID(unpkuuid, "linden_lab_uuid");
+
+        ensure("LLDataPackerAsciiFile::packString (iostring) failed", strcmp(str, unpkstr.c_str())  == 0);
+        ensure("LLDataPackerAsciiFile::packBinaryData (iostring) failed", strcmp(strBinary, unpkstrBinary)  == 0);
+        ensure("LLDataPackerAsciiFile::packBinaryDataFixed (iostring) failed", strcmp(strBinaryFixed, unpkstrBinaryFixed) == 0);
+        ensure_equals("LLDataPackerAsciiFile::packU8 (iostring) failed", valU8, unpkvalU8);
+        ensure_equals("LLDataPackerAsciiFile::packU16 (iostring) failed", valU16, unpkvalU16);
+        ensure_equals("LLDataPackerAsciiFile::packU32 (iostring) failed", valU32, unpkvalU32);
+        ensure_equals("LLDataPackerAsciiFile::packS32 (iostring) failed", valS32, unpkvalS32);
+        ensure("LLDataPackerAsciiFile::packF32 (iostring) failed", is_approx_equal(valF32, unpkvalF32));
+        ensure_equals("LLDataPackerAsciiFile::packColor4 (iostring) failed", llcol4, unpkllcol4);
+        ensure_equals("LLDataPackerAsciiFile::packColor4U (iostring) failed", llcol4u, unpkllcol4u);
+        ensure_equals("LLDataPackerAsciiFile::packVector2 (iostring) failed", llvec2, unpkllvec2);
+        ensure_equals("LLDataPackerAsciiFile::packVector3 (iostring) failed", llvec3, unpkllvec3);
+        ensure_equals("LLDataPackerAsciiFile::packVector4 (iostring) failed", llvec4, unpkllvec4);
+        ensure_equals("LLDataPackerAsciiFile::packUUID (iostring) failed", uuid, unpkuuid);
+    }
 }
diff --git a/indra/test/lldoubledispatch_tut.cpp b/indra/test/lldoubledispatch_tut.cpp
index dbf55e666f..79c4edc058 100644
--- a/indra/test/lldoubledispatch_tut.cpp
+++ b/indra/test/lldoubledispatch_tut.cpp
@@ -10,21 +10,21 @@
  * $LicenseInfo:firstyear=2008&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -190,7 +190,7 @@ namespace tut
         dispatcher.add(DD::Type<SpaceShip>(), DD::Type<Asteroid>(), shipAsteroid, true);
         dispatcher.add(DD::Type<SpaceShip>(), DD::Type<SpaceStation>(), shipStation, true);
         dispatcher.add(DD::Type<Asteroid>(), DD::Type<SpaceStation>(), asteroidStation, true);
-        
+
         ensure_equals(dispatcher(*patrol, *obstacle), "militaryShipAsteroid");
         ensure_equals(dispatcher(*tug, *obstacle), "shipAsteroid");
     }
diff --git a/indra/test/llevents_tut.cpp b/indra/test/llevents_tut.cpp
index a38de71e48..875ca9ad89 100644
--- a/indra/test/llevents_tut.cpp
+++ b/indra/test/llevents_tut.cpp
@@ -3,25 +3,25 @@
  * @author Nat Goodspeed
  * @date   2008-09-12
  * @brief  Test of llevents.h
- * 
+ *
  * $LicenseInfo:firstyear=2008&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -57,7 +57,7 @@ using boost::assign::list_of;
 template<typename T>
 T make(const T& value)
 {
-	return value;
+    return value;
 }
 
 /*****************************************************************************
@@ -67,21 +67,21 @@ namespace tut
 {
 struct events_data
 {
-	events_data() :
-		pumps(LLEventPumps::instance()),
-		listener0("first"),
-		listener1("second")
-	{
-	}
-	LLEventPumps& pumps;
-	Listener listener0;
-	Listener listener1;
+    events_data() :
+        pumps(LLEventPumps::instance()),
+        listener0("first"),
+        listener1("second")
+    {
+    }
+    LLEventPumps& pumps;
+    Listener listener0;
+    Listener listener1;
 
-	void check_listener(const std::string& desc, const Listener& listener, LLSD::Integer got)
-	{
-		ensure_equals(STRINGIZE(listener << ' ' << desc),
-					  listener.getLastEvent().asInteger(), got);
-	}
+    void check_listener(const std::string& desc, const Listener& listener, LLSD::Integer got)
+    {
+        ensure_equals(STRINGIZE(listener << ' ' << desc),
+                      listener.getLastEvent().asInteger(), got);
+    }
 };
 typedef test_group<events_data> events_group;
 typedef events_group::object events_object;
@@ -90,367 +90,367 @@ tut::events_group evgr("events");
 template<> template<>
 void events_object::test<1>()
 {
-	set_test_name("basic operations");
-	// Having to modify this to track the statically-
-	// constructed pumps in other TUT modules in this giant monolithic test
-	// executable isn't such a hot idea.
-	// ensure_equals("initial pump", pumps.mPumpMap.size(), 1);
-	size_t initial_pumps(pumps.mPumpMap.size());
-	LLEventPump& per_frame(pumps.obtain("per-frame"));
-	ensure_equals("first explicit pump", pumps.mPumpMap.size(), initial_pumps + 1);
-	// Verify that per_frame was instantiated as an LLEventStream.
-	ensure("LLEventStream leaf class", dynamic_cast<LLEventStream*> (&per_frame));
-	ensure("enabled", per_frame.enabled());
-	// Trivial test, but posting an event to an EventPump with no
-	// listeners should not blow up. The test is relevant because defining
-	// a boost::signal with a non-void return signature, using the default
-	// combiner, blows up if there are no listeners. This is because the
-	// default combiner is defined to return the value returned by the
-	// last listener, which is meaningless if there were no listeners.
-	per_frame.post(0);
-	LLBoundListener connection = listener0.listenTo(per_frame);
-	ensure("connected", connection.connected());
-	ensure("not blocked", !connection.blocked());
-	per_frame.post(1);
-	check_listener("received", listener0, 1);
-	{ // block the connection
-		LLEventPump::Blocker block(connection);
-		ensure("blocked", connection.blocked());
-		per_frame.post(2);
-		check_listener("not updated", listener0, 1);
-	} // unblock
-	ensure("unblocked", !connection.blocked());
-	per_frame.post(3);
-	check_listener("unblocked", listener0, 3);
-	LLBoundListener sameConnection = per_frame.getListener(listener0.getName());
-	ensure("still connected", sameConnection.connected());
-	ensure("still not blocked", !sameConnection.blocked());
-	{ // block it again
-		LLEventPump::Blocker block(sameConnection);
-		ensure("re-blocked", sameConnection.blocked());
-		per_frame.post(4);
-		check_listener("re-blocked", listener0, 3);
-	} // unblock
-	std::string threw = catch_what<LLEventPump::DupListenerName>(
-		[&per_frame, this](){
-			// NOTE: boost::bind() saves its arguments by VALUE! If you pass
-			// an object instance rather than a pointer, you'll end up binding
-			// to an internal copy of that instance! Use boost::ref() to
-			// capture a reference instead.
-			per_frame.listen(listener0.getName(), // note bug, dup name
-							 boost::bind(&Listener::call, boost::ref(listener1), _1));
-		});
-	ensure_equals(threw,
-				  std::string("DupListenerName: "
-							  "Attempt to register duplicate listener name '") +
-							  listener0.getName() + "' on " + typeid(per_frame).name() +
-							  " '" + per_frame.getName() + "'");
-	// do it right this time
-	listener1.listenTo(per_frame);
-	per_frame.post(5);
-	check_listener("got", listener0, 5);
-	check_listener("got", listener1, 5);
-	per_frame.enable(false);
-	per_frame.post(6);
-	check_listener("didn't get", listener0, 5);
-	check_listener("didn't get", listener1, 5);
-	per_frame.enable();
-	per_frame.post(7);
-	check_listener("got", listener0, 7);
-	check_listener("got", listener1, 7);
-	per_frame.stopListening(listener0.getName());
-	ensure("disconnected 0", ! connection.connected());
-	ensure("disconnected 1", ! sameConnection.connected());
-	per_frame.post(8);
-	check_listener("disconnected", listener0, 7);
-	check_listener("still connected", listener1, 8);
-	per_frame.stopListening(listener1.getName());
-	per_frame.post(9);
-	check_listener("disconnected", listener1, 8);
+    set_test_name("basic operations");
+    // Having to modify this to track the statically-
+    // constructed pumps in other TUT modules in this giant monolithic test
+    // executable isn't such a hot idea.
+    // ensure_equals("initial pump", pumps.mPumpMap.size(), 1);
+    size_t initial_pumps(pumps.mPumpMap.size());
+    LLEventPump& per_frame(pumps.obtain("per-frame"));
+    ensure_equals("first explicit pump", pumps.mPumpMap.size(), initial_pumps + 1);
+    // Verify that per_frame was instantiated as an LLEventStream.
+    ensure("LLEventStream leaf class", dynamic_cast<LLEventStream*> (&per_frame));
+    ensure("enabled", per_frame.enabled());
+    // Trivial test, but posting an event to an EventPump with no
+    // listeners should not blow up. The test is relevant because defining
+    // a boost::signal with a non-void return signature, using the default
+    // combiner, blows up if there are no listeners. This is because the
+    // default combiner is defined to return the value returned by the
+    // last listener, which is meaningless if there were no listeners.
+    per_frame.post(0);
+    LLBoundListener connection = listener0.listenTo(per_frame);
+    ensure("connected", connection.connected());
+    ensure("not blocked", !connection.blocked());
+    per_frame.post(1);
+    check_listener("received", listener0, 1);
+    { // block the connection
+        LLEventPump::Blocker block(connection);
+        ensure("blocked", connection.blocked());
+        per_frame.post(2);
+        check_listener("not updated", listener0, 1);
+    } // unblock
+    ensure("unblocked", !connection.blocked());
+    per_frame.post(3);
+    check_listener("unblocked", listener0, 3);
+    LLBoundListener sameConnection = per_frame.getListener(listener0.getName());
+    ensure("still connected", sameConnection.connected());
+    ensure("still not blocked", !sameConnection.blocked());
+    { // block it again
+        LLEventPump::Blocker block(sameConnection);
+        ensure("re-blocked", sameConnection.blocked());
+        per_frame.post(4);
+        check_listener("re-blocked", listener0, 3);
+    } // unblock
+    std::string threw = catch_what<LLEventPump::DupListenerName>(
+        [&per_frame, this](){
+            // NOTE: boost::bind() saves its arguments by VALUE! If you pass
+            // an object instance rather than a pointer, you'll end up binding
+            // to an internal copy of that instance! Use boost::ref() to
+            // capture a reference instead.
+            per_frame.listen(listener0.getName(), // note bug, dup name
+                             boost::bind(&Listener::call, boost::ref(listener1), _1));
+        });
+    ensure_equals(threw,
+                  std::string("DupListenerName: "
+                              "Attempt to register duplicate listener name '") +
+                              listener0.getName() + "' on " + typeid(per_frame).name() +
+                              " '" + per_frame.getName() + "'");
+    // do it right this time
+    listener1.listenTo(per_frame);
+    per_frame.post(5);
+    check_listener("got", listener0, 5);
+    check_listener("got", listener1, 5);
+    per_frame.enable(false);
+    per_frame.post(6);
+    check_listener("didn't get", listener0, 5);
+    check_listener("didn't get", listener1, 5);
+    per_frame.enable();
+    per_frame.post(7);
+    check_listener("got", listener0, 7);
+    check_listener("got", listener1, 7);
+    per_frame.stopListening(listener0.getName());
+    ensure("disconnected 0", ! connection.connected());
+    ensure("disconnected 1", ! sameConnection.connected());
+    per_frame.post(8);
+    check_listener("disconnected", listener0, 7);
+    check_listener("still connected", listener1, 8);
+    per_frame.stopListening(listener1.getName());
+    per_frame.post(9);
+    check_listener("disconnected", listener1, 8);
 }
 
 template<> template<>
 void events_object::test<2>()
 {
-	set_test_name("callstop() returning true");
-	LLEventPump& per_frame(pumps.obtain("per-frame"));
-	listener0.reset(0);
-	listener1.reset(0);
-	LLBoundListener bound0 = listener0.listenTo(per_frame, &Listener::callstop);
-	LLBoundListener bound1 = listener1.listenTo(per_frame, &Listener::call,
-												// after listener0
-												make<LLEventPump::NameList>(list_of(listener0.getName())));
-	ensure("enabled", per_frame.enabled());
-	ensure("connected 0", bound0.connected());
-	ensure("unblocked 0", !bound0.blocked());
-	ensure("connected 1", bound1.connected());
-	ensure("unblocked 1", !bound1.blocked());
-	per_frame.post(1);
-	check_listener("got", listener0, 1);
-	// Because listener0.callstop() returns true, control never reaches listener1.call().
-	check_listener("got", listener1, 0);
+    set_test_name("callstop() returning true");
+    LLEventPump& per_frame(pumps.obtain("per-frame"));
+    listener0.reset(0);
+    listener1.reset(0);
+    LLBoundListener bound0 = listener0.listenTo(per_frame, &Listener::callstop);
+    LLBoundListener bound1 = listener1.listenTo(per_frame, &Listener::call,
+                                                // after listener0
+                                                make<LLEventPump::NameList>(list_of(listener0.getName())));
+    ensure("enabled", per_frame.enabled());
+    ensure("connected 0", bound0.connected());
+    ensure("unblocked 0", !bound0.blocked());
+    ensure("connected 1", bound1.connected());
+    ensure("unblocked 1", !bound1.blocked());
+    per_frame.post(1);
+    check_listener("got", listener0, 1);
+    // Because listener0.callstop() returns true, control never reaches listener1.call().
+    check_listener("got", listener1, 0);
 }
 
 bool chainEvents(Listener& someListener, const LLSD& event)
 {
-	// Make this call so we can watch for side effects for test purposes.
-	someListener.call(event);
-	// This function represents a recursive event chain -- or some other
-	// scenario in which an event handler raises additional events.
-	int value = event.asInteger();
-	if (value)
-	{
-		LLEventPumps::instance().obtain("login").post(value - 1);
-	}
-	return false;
+    // Make this call so we can watch for side effects for test purposes.
+    someListener.call(event);
+    // This function represents a recursive event chain -- or some other
+    // scenario in which an event handler raises additional events.
+    int value = event.asInteger();
+    if (value)
+    {
+        LLEventPumps::instance().obtain("login").post(value - 1);
+    }
+    return false;
 }
 
 template<> template<>
 void events_object::test<3>()
 {
-	set_test_name("explicitly-instantiated LLEventStream");
-	// Explicitly instantiate an LLEventStream, and verify that it
-	// self-registers with LLEventPumps
-	size_t registered = pumps.mPumpMap.size();
-	size_t owned = pumps.mOurPumps.size();
-	LLEventPump* localInstance;
-	{
-		LLEventStream myEventStream("stream");
-		localInstance = &myEventStream;
-		LLEventPump& stream(pumps.obtain("stream"));
-		ensure("found named LLEventStream instance", &stream == localInstance);
-		ensure_equals("registered new instance", pumps.mPumpMap.size(), registered + 1);
-		ensure_equals("explicit instance not owned", pumps.mOurPumps.size(), owned);
-	} // destroy myEventStream -- should unregister
-	ensure_equals("destroyed instance unregistered", pumps.mPumpMap.size(), registered);
-	ensure_equals("destroyed instance not owned", pumps.mOurPumps.size(), owned);
-	LLEventPump& stream(pumps.obtain("stream"));
-	ensure("new LLEventStream instance", &stream != localInstance);
-	ensure_equals("obtain()ed instance registered", pumps.mPumpMap.size(), registered + 1);
-	ensure_equals("obtain()ed instance owned", pumps.mOurPumps.size(), owned + 1);
+    set_test_name("explicitly-instantiated LLEventStream");
+    // Explicitly instantiate an LLEventStream, and verify that it
+    // self-registers with LLEventPumps
+    size_t registered = pumps.mPumpMap.size();
+    size_t owned = pumps.mOurPumps.size();
+    LLEventPump* localInstance;
+    {
+        LLEventStream myEventStream("stream");
+        localInstance = &myEventStream;
+        LLEventPump& stream(pumps.obtain("stream"));
+        ensure("found named LLEventStream instance", &stream == localInstance);
+        ensure_equals("registered new instance", pumps.mPumpMap.size(), registered + 1);
+        ensure_equals("explicit instance not owned", pumps.mOurPumps.size(), owned);
+    } // destroy myEventStream -- should unregister
+    ensure_equals("destroyed instance unregistered", pumps.mPumpMap.size(), registered);
+    ensure_equals("destroyed instance not owned", pumps.mOurPumps.size(), owned);
+    LLEventPump& stream(pumps.obtain("stream"));
+    ensure("new LLEventStream instance", &stream != localInstance);
+    ensure_equals("obtain()ed instance registered", pumps.mPumpMap.size(), registered + 1);
+    ensure_equals("obtain()ed instance owned", pumps.mOurPumps.size(), owned + 1);
 }
 
 template<> template<>
 void events_object::test<4>()
 {
-	set_test_name("stopListening()");
-	LLEventPump& login(pumps.obtain("login"));
-	listener0.listenTo(login);
-	login.stopListening(listener0.getName());
-	// should not throw because stopListening() should have removed name
-	listener0.listenTo(login, &Listener::callstop);
-	LLBoundListener wrong = login.getListener("bogus");
-	ensure("bogus connection disconnected", !wrong.connected());
-	ensure("bogus connection blocked", wrong.blocked());
+    set_test_name("stopListening()");
+    LLEventPump& login(pumps.obtain("login"));
+    listener0.listenTo(login);
+    login.stopListening(listener0.getName());
+    // should not throw because stopListening() should have removed name
+    listener0.listenTo(login, &Listener::callstop);
+    LLBoundListener wrong = login.getListener("bogus");
+    ensure("bogus connection disconnected", !wrong.connected());
+    ensure("bogus connection blocked", wrong.blocked());
 }
 
 template<> template<>
 void events_object::test<5>()
 {
-	set_test_name("chaining LLEventPump instances");
-	LLEventPump& upstream(pumps.obtain("upstream"));
-	// One potentially-useful construct is to chain LLEventPumps together.
-	// Among other things, this allows you to turn subsets of listeners on
-	// and off in groups.
-	LLEventPump& filter0(pumps.obtain("filter0"));
-	LLEventPump& filter1(pumps.obtain("filter1"));
-	upstream.listen(filter0.getName(), boost::bind(&LLEventPump::post, boost::ref(filter0), _1));
-	upstream.listen(filter1.getName(), boost::bind(&LLEventPump::post, boost::ref(filter1), _1));
-	listener0.listenTo(filter0);
-	listener1.listenTo(filter1);
-	listener0.reset(0);
-	listener1.reset(0);
-	upstream.post(1);
-	check_listener("got unfiltered", listener0, 1);
-	check_listener("got unfiltered", listener1, 1);
-	filter0.enable(false);
-	upstream.post(2);
-	check_listener("didn't get filtered", listener0, 1);
-	check_listener("got filtered", listener1, 2);
+    set_test_name("chaining LLEventPump instances");
+    LLEventPump& upstream(pumps.obtain("upstream"));
+    // One potentially-useful construct is to chain LLEventPumps together.
+    // Among other things, this allows you to turn subsets of listeners on
+    // and off in groups.
+    LLEventPump& filter0(pumps.obtain("filter0"));
+    LLEventPump& filter1(pumps.obtain("filter1"));
+    upstream.listen(filter0.getName(), boost::bind(&LLEventPump::post, boost::ref(filter0), _1));
+    upstream.listen(filter1.getName(), boost::bind(&LLEventPump::post, boost::ref(filter1), _1));
+    listener0.listenTo(filter0);
+    listener1.listenTo(filter1);
+    listener0.reset(0);
+    listener1.reset(0);
+    upstream.post(1);
+    check_listener("got unfiltered", listener0, 1);
+    check_listener("got unfiltered", listener1, 1);
+    filter0.enable(false);
+    upstream.post(2);
+    check_listener("didn't get filtered", listener0, 1);
+    check_listener("got filtered", listener1, 2);
 }
 
 template<> template<>
 void events_object::test<6>()
 {
-	set_test_name("listener dependency order");
-	typedef LLEventPump::NameList NameList;
-	LLEventPump& button(pumps.obtain("button"));
-	Collect collector;
-	button.listen("Mary",
-				  boost::bind(&Collect::add, boost::ref(collector), "Mary", _1),
-				  // state that "Mary" must come after "checked"
-				  make<NameList> (list_of("checked")));
-	button.listen("checked",
-				  boost::bind(&Collect::add, boost::ref(collector), "checked", _1),
-				  // "checked" must come after "spot"
-				  make<NameList> (list_of("spot")));
-	button.listen("spot",
-				  boost::bind(&Collect::add, boost::ref(collector), "spot", _1));
-	button.post(1);
-	ensure_equals(collector.result, make<StringVec>(list_of("spot")("checked")("Mary")));
-	collector.clear();
-	button.stopListening("Mary");
-	button.listen("Mary",
-			boost::bind(&Collect::add, boost::ref(collector), "Mary", _1),
-			LLEventPump::empty, // no after dependencies
-			// now "Mary" must come before "spot"
-			make<NameList>(list_of("spot")));
-	button.post(2);
-	ensure_equals(collector.result, make<StringVec>(list_of("Mary")("spot")("checked")));
-	collector.clear();
-	button.stopListening("spot");
-	std::string threw = catch_what<LLEventPump::Cycle>(
-		[&button, &collector](){
-			button.listen("spot",
-						  boost::bind(&Collect::add, boost::ref(collector), "spot", _1),
-						  // after "Mary" and "checked" -- whoops!
-						  make<NameList>(list_of("Mary")("checked")));
-		});
-	// Obviously the specific wording of the exception text can
-	// change; go ahead and change the test to match.
-	// Establish that it contains:
-	// - the name and runtime type of the LLEventPump
-	ensure_contains("LLEventPump type", threw, typeid(button).name());
-	ensure_contains("LLEventPump name", threw, "'button'");
-	// - the name of the new listener that caused the problem
-	ensure_contains("new listener name", threw, "'spot'");
-	// - a synopsis of the problematic dependencies.
-	ensure_contains("cyclic dependencies", threw,
-					"\"Mary\" -> before (\"spot\")");
-	ensure_contains("cyclic dependencies", threw,
-					"after (\"spot\") -> \"checked\"");
-	ensure_contains("cyclic dependencies", threw,
-					"after (\"Mary\", \"checked\") -> \"spot\"");
-	button.listen("yellow",
-				  boost::bind(&Collect::add, boost::ref(collector), "yellow", _1),
-				  make<NameList>(list_of("checked")));
-	button.listen("shoelaces",
-				  boost::bind(&Collect::add, boost::ref(collector), "shoelaces", _1),
-				  make<NameList>(list_of("checked")));
-	button.post(3);
-	ensure_equals(collector.result, make<StringVec>(list_of("Mary")("checked")("yellow")("shoelaces")));
-	collector.clear();
-	threw = catch_what<LLEventPump::OrderChange>(
-		[&button, &collector](){
-			button.listen("of",
-						  boost::bind(&Collect::add, boost::ref(collector), "of", _1),
-						  make<NameList>(list_of("shoelaces")),
-						  make<NameList>(list_of("yellow")));
-		});
-	// Same remarks about the specific wording of the exception. Just
-	// ensure that it contains enough information to clarify the
-	// problem and what must be done to resolve it.
-	ensure_contains("LLEventPump type", threw, typeid(button).name());
-	ensure_contains("LLEventPump name", threw, "'button'");
-	ensure_contains("new listener name", threw, "'of'");
-	ensure_contains("prev listener name", threw, "'yellow'");
-	// std::cout << "Thrown Exception: " << threw << std::endl;
-	ensure_contains("old order", threw, "was: Mary, checked, yellow, shoelaces");
-	ensure_contains("new order", threw, "now: Mary, checked, shoelaces, of, yellow");
-	button.post(4);
-	ensure_equals(collector.result, make<StringVec>(list_of("Mary")("checked")("yellow")("shoelaces")));
+    set_test_name("listener dependency order");
+    typedef LLEventPump::NameList NameList;
+    LLEventPump& button(pumps.obtain("button"));
+    Collect collector;
+    button.listen("Mary",
+                  boost::bind(&Collect::add, boost::ref(collector), "Mary", _1),
+                  // state that "Mary" must come after "checked"
+                  make<NameList> (list_of("checked")));
+    button.listen("checked",
+                  boost::bind(&Collect::add, boost::ref(collector), "checked", _1),
+                  // "checked" must come after "spot"
+                  make<NameList> (list_of("spot")));
+    button.listen("spot",
+                  boost::bind(&Collect::add, boost::ref(collector), "spot", _1));
+    button.post(1);
+    ensure_equals(collector.result, make<StringVec>(list_of("spot")("checked")("Mary")));
+    collector.clear();
+    button.stopListening("Mary");
+    button.listen("Mary",
+            boost::bind(&Collect::add, boost::ref(collector), "Mary", _1),
+            LLEventPump::empty, // no after dependencies
+            // now "Mary" must come before "spot"
+            make<NameList>(list_of("spot")));
+    button.post(2);
+    ensure_equals(collector.result, make<StringVec>(list_of("Mary")("spot")("checked")));
+    collector.clear();
+    button.stopListening("spot");
+    std::string threw = catch_what<LLEventPump::Cycle>(
+        [&button, &collector](){
+            button.listen("spot",
+                          boost::bind(&Collect::add, boost::ref(collector), "spot", _1),
+                          // after "Mary" and "checked" -- whoops!
+                          make<NameList>(list_of("Mary")("checked")));
+        });
+    // Obviously the specific wording of the exception text can
+    // change; go ahead and change the test to match.
+    // Establish that it contains:
+    // - the name and runtime type of the LLEventPump
+    ensure_contains("LLEventPump type", threw, typeid(button).name());
+    ensure_contains("LLEventPump name", threw, "'button'");
+    // - the name of the new listener that caused the problem
+    ensure_contains("new listener name", threw, "'spot'");
+    // - a synopsis of the problematic dependencies.
+    ensure_contains("cyclic dependencies", threw,
+                    "\"Mary\" -> before (\"spot\")");
+    ensure_contains("cyclic dependencies", threw,
+                    "after (\"spot\") -> \"checked\"");
+    ensure_contains("cyclic dependencies", threw,
+                    "after (\"Mary\", \"checked\") -> \"spot\"");
+    button.listen("yellow",
+                  boost::bind(&Collect::add, boost::ref(collector), "yellow", _1),
+                  make<NameList>(list_of("checked")));
+    button.listen("shoelaces",
+                  boost::bind(&Collect::add, boost::ref(collector), "shoelaces", _1),
+                  make<NameList>(list_of("checked")));
+    button.post(3);
+    ensure_equals(collector.result, make<StringVec>(list_of("Mary")("checked")("yellow")("shoelaces")));
+    collector.clear();
+    threw = catch_what<LLEventPump::OrderChange>(
+        [&button, &collector](){
+            button.listen("of",
+                          boost::bind(&Collect::add, boost::ref(collector), "of", _1),
+                          make<NameList>(list_of("shoelaces")),
+                          make<NameList>(list_of("yellow")));
+        });
+    // Same remarks about the specific wording of the exception. Just
+    // ensure that it contains enough information to clarify the
+    // problem and what must be done to resolve it.
+    ensure_contains("LLEventPump type", threw, typeid(button).name());
+    ensure_contains("LLEventPump name", threw, "'button'");
+    ensure_contains("new listener name", threw, "'of'");
+    ensure_contains("prev listener name", threw, "'yellow'");
+    // std::cout << "Thrown Exception: " << threw << std::endl;
+    ensure_contains("old order", threw, "was: Mary, checked, yellow, shoelaces");
+    ensure_contains("new order", threw, "now: Mary, checked, shoelaces, of, yellow");
+    button.post(4);
+    ensure_equals(collector.result, make<StringVec>(list_of("Mary")("checked")("yellow")("shoelaces")));
 }
 
 template<> template<>
 void events_object::test<7>()
 {
-	set_test_name("tweaked and untweaked LLEventPump instance names");
-	{ 	// nested scope
-		// Hand-instantiate an LLEventStream...
-		LLEventStream bob("bob");
-		std::string threw = catch_what<LLEventPump::DupPumpName>(
-			[](){
-				// then another with a duplicate name.
-				LLEventStream bob2("bob");
-			});
-		ensure("Caught DupPumpName", !threw.empty());
-	} 	// delete first 'bob'
-	LLEventStream bob("bob"); 		// should work, previous one unregistered
-	LLEventStream bob1("bob", true);// allowed to tweak name
-	ensure_equals("tweaked LLEventStream name", bob1.getName(), "bob1");
-	std::vector<std::shared_ptr<LLEventStream> > streams;
-	for (int i = 2; i <= 10; ++i)
-	{
-		streams.push_back(std::shared_ptr<LLEventStream>(new LLEventStream("bob", true)));
-	}
-	ensure_equals("last tweaked LLEventStream name", streams.back()->getName(), "bob10");
+    set_test_name("tweaked and untweaked LLEventPump instance names");
+    {   // nested scope
+        // Hand-instantiate an LLEventStream...
+        LLEventStream bob("bob");
+        std::string threw = catch_what<LLEventPump::DupPumpName>(
+            [](){
+                // then another with a duplicate name.
+                LLEventStream bob2("bob");
+            });
+        ensure("Caught DupPumpName", !threw.empty());
+    }   // delete first 'bob'
+    LLEventStream bob("bob");       // should work, previous one unregistered
+    LLEventStream bob1("bob", true);// allowed to tweak name
+    ensure_equals("tweaked LLEventStream name", bob1.getName(), "bob1");
+    std::vector<std::shared_ptr<LLEventStream> > streams;
+    for (int i = 2; i <= 10; ++i)
+    {
+        streams.push_back(std::shared_ptr<LLEventStream>(new LLEventStream("bob", true)));
+    }
+    ensure_equals("last tweaked LLEventStream name", streams.back()->getName(), "bob10");
 }
 
 // Define a function that accepts an LLListenerOrPumpName
 void eventSource(const LLListenerOrPumpName& listener)
 {
-	// Pretend that some time has elapsed. Call listener immediately.
-	listener(17);
+    // Pretend that some time has elapsed. Call listener immediately.
+    listener(17);
 }
 
 template<> template<>
 void events_object::test<8>()
 {
-	set_test_name("LLListenerOrPumpName");
-	// Passing a boost::bind() expression to LLListenerOrPumpName
-	listener0.reset(0);
-	eventSource(boost::bind(&Listener::call, boost::ref(listener0), _1));
-	check_listener("got by listener", listener0, 17);
-	// Passing a string LLEventPump name to LLListenerOrPumpName
-	listener0.reset(0);
-	LLEventStream random("random");
-	listener0.listenTo(random);
-	eventSource("random");
-	check_listener("got by pump name", listener0, 17);
-	std::string threw = catch_what<LLListenerOrPumpName::Empty>(
-		[](){
-			LLListenerOrPumpName empty;
-			empty(17);
-		});
+    set_test_name("LLListenerOrPumpName");
+    // Passing a boost::bind() expression to LLListenerOrPumpName
+    listener0.reset(0);
+    eventSource(boost::bind(&Listener::call, boost::ref(listener0), _1));
+    check_listener("got by listener", listener0, 17);
+    // Passing a string LLEventPump name to LLListenerOrPumpName
+    listener0.reset(0);
+    LLEventStream random("random");
+    listener0.listenTo(random);
+    eventSource("random");
+    check_listener("got by pump name", listener0, 17);
+    std::string threw = catch_what<LLListenerOrPumpName::Empty>(
+        [](){
+            LLListenerOrPumpName empty;
+            empty(17);
+        });
 
-	ensure("threw Empty", !threw.empty());
+    ensure("threw Empty", !threw.empty());
 }
 
 class TempListener: public Listener
 {
 public:
-	TempListener(const std::string& name, bool& liveFlag) :
-		Listener(name), mLiveFlag(liveFlag)
-	{
-		mLiveFlag = true;
-	}
+    TempListener(const std::string& name, bool& liveFlag) :
+        Listener(name), mLiveFlag(liveFlag)
+    {
+        mLiveFlag = true;
+    }
 
-	virtual ~TempListener()
-	{
-		mLiveFlag = false;
-	}
+    virtual ~TempListener()
+    {
+        mLiveFlag = false;
+    }
 
 private:
-	bool& mLiveFlag;
+    bool& mLiveFlag;
 };
 
 template<> template<>
 void events_object::test<9>()
 {
-	set_test_name("listen(boost::bind(...TempListener...))");
-	// listen() can't do anything about a plain TempListener instance:
-	// it's not managed with shared_ptr, nor is it an LLEventTrackable subclass
-	bool live = false;
-	LLEventPump& heaptest(pumps.obtain("heaptest"));
-	LLBoundListener connection;
-	{
-		TempListener tempListener("temp", live);
-		ensure("TempListener constructed", live);
-		connection = heaptest.listen(tempListener.getName(),
-									 boost::bind(&Listener::call,
-												 boost::ref(tempListener),
-												 _1));
-		heaptest.post(1);
-		check_listener("received", tempListener, 1);
-	} // presumably this will make newListener go away?
-	// verify that
-	ensure("TempListener destroyed", !live);
-	// This is the case against which we can't defend. Don't even try to
-	// post to heaptest -- that would engage Undefined Behavior.
-	// Cautiously inspect connection...
-	ensure("misleadingly connected", connection.connected());
-	// then disconnect by hand.
-	heaptest.stopListening("temp");
+    set_test_name("listen(boost::bind(...TempListener...))");
+    // listen() can't do anything about a plain TempListener instance:
+    // it's not managed with shared_ptr, nor is it an LLEventTrackable subclass
+    bool live = false;
+    LLEventPump& heaptest(pumps.obtain("heaptest"));
+    LLBoundListener connection;
+    {
+        TempListener tempListener("temp", live);
+        ensure("TempListener constructed", live);
+        connection = heaptest.listen(tempListener.getName(),
+                                     boost::bind(&Listener::call,
+                                                 boost::ref(tempListener),
+                                                 _1));
+        heaptest.post(1);
+        check_listener("received", tempListener, 1);
+    } // presumably this will make newListener go away?
+    // verify that
+    ensure("TempListener destroyed", !live);
+    // This is the case against which we can't defend. Don't even try to
+    // post to heaptest -- that would engage Undefined Behavior.
+    // Cautiously inspect connection...
+    ensure("misleadingly connected", connection.connected());
+    // then disconnect by hand.
+    heaptest.stopListening("temp");
 }
 
 class TempTrackableListener: public TempListener, public LLEventTrackable
diff --git a/indra/test/llhttpdate_tut.cpp b/indra/test/llhttpdate_tut.cpp
index ecf734ee90..a47602dec5 100644
--- a/indra/test/llhttpdate_tut.cpp
+++ b/indra/test/llhttpdate_tut.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llhttpdate_tut.cpp
  * @author Kartic Krishnamurthy
  * @date Wednesday, 18 Jul 2007 17:00:00 GMT :)
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -39,12 +39,12 @@ namespace tut
 {
     struct httpdate_data
     {
-		httpdate_data() 
-		{ 
-		}
-		~httpdate_data() 
-		{ 
-		}
+        httpdate_data()
+        {
+        }
+        ~httpdate_data()
+        {
+        }
         LLDate some_date;
     };
     typedef test_group<httpdate_data> httpdate_test;
@@ -79,11 +79,11 @@ namespace tut
         some_date = LLDate((F64) sometime);
         struct tm *result;
         char expected[255];
-		std::string actual;
-        
+        std::string actual;
+
         result = gmtime(&sometime);
         /*
-        std::cout << " seconds: "<< result->tm_sec 
+        std::cout << " seconds: "<< result->tm_sec
                   << ", minutes: " << result->tm_min
                   << ", hours: " << result->tm_hour
                   << ", day of the month: " << result->tm_mday
@@ -99,69 +99,69 @@ namespace tut
         ensure("Current time in RFC 1123", (strcmp(expected, actual.c_str()) == 0));
     }
 
-	void test_date_string(const std::string &locale, struct tm *t,
-						  const std::string &fmt, const std::string &expected)
-	{
-		std::string result = LLDate::toHTTPDateString(t, fmt);
-		LLStringUtil::toLower(result);
-		std::string label = std::string("toHTTPDateString - ") + locale;
-		ensure_equals(label.c_str(), result, expected);
-	}
-
-	template<> template<>
-	void httpdate_object::test<4>()
-	{
-		// test localization of http dates
+    void test_date_string(const std::string &locale, struct tm *t,
+                          const std::string &fmt, const std::string &expected)
+    {
+        std::string result = LLDate::toHTTPDateString(t, fmt);
+        LLStringUtil::toLower(result);
+        std::string label = std::string("toHTTPDateString - ") + locale;
+        ensure_equals(label.c_str(), result, expected);
+    }
+
+    template<> template<>
+    void httpdate_object::test<4>()
+    {
+        // test localization of http dates
 #if LL_WINDOWS
-		const char *en_locale = "english";
-		const char *fr_locale = "french";
+        const char *en_locale = "english";
+        const char *fr_locale = "french";
 #else
-		const char *en_locale = "en_GB.UTF-8";
-		const char *fr_locale = "fr_FR.UTF-8";
+        const char *en_locale = "en_GB.UTF-8";
+        const char *fr_locale = "fr_FR.UTF-8";
 #endif
 
-		std::string prev_locale = LLStringUtil::getLocale();
-		std::string prev_clocale = std::string(setlocale(LC_TIME, NULL));
-		time_t test_time = 1252374030;  // 8 Sep 2009 01:40:01
-		struct tm *t = gmtime(&test_time);
-
-		setlocale(LC_TIME, en_locale);
-		if (strcmp(setlocale(LC_TIME, NULL), en_locale) != 0)
-		{
-			setlocale(LC_TIME, prev_clocale.c_str());
-			skip("Cannot set English locale");
-		}
-
-		LLStringUtil::setLocale(en_locale);
-		test_date_string(en_locale, t, "%d %B %Y - %H:%M", "08 september 2009 - 01:40");
-		test_date_string(en_locale, t, "%H", "01");
-		test_date_string(en_locale, t, "%M", "40");
-		test_date_string(en_locale, t, "%I", "01");
-		test_date_string(en_locale, t, "%d", "08");
-		test_date_string(en_locale, t, "%Y", "2009");
-		test_date_string(en_locale, t, "%p", "am");
-		test_date_string(en_locale, t, "%A", "tuesday");
-		test_date_string(en_locale, t, "%B", "september");
-
-		setlocale(LC_TIME, fr_locale);
-		if (strcmp(setlocale(LC_TIME, NULL), fr_locale) != 0)
-		{
-			LLStringUtil::setLocale(prev_locale);
-			setlocale(LC_TIME, prev_clocale.c_str());
-			skip("Cannot set French locale");
-		}
-
-		LLStringUtil::setLocale(fr_locale);
-		test_date_string(fr_locale, t, "%d %B %Y - %H:%M", "08 septembre 2009 - 01:40");
-		test_date_string(fr_locale, t, "%H", "01");
-		test_date_string(fr_locale, t, "%M", "40");
-		test_date_string(fr_locale, t, "%I", "01");
-		test_date_string(fr_locale, t, "%d", "08");
-		test_date_string(fr_locale, t, "%Y", "2009");
-		test_date_string(fr_locale, t, "%A", "mardi");
-		test_date_string(fr_locale, t, "%B", "septembre");
-
-		LLStringUtil::setLocale(prev_locale);
-		setlocale(LC_TIME, prev_clocale.c_str());
-	}
+        std::string prev_locale = LLStringUtil::getLocale();
+        std::string prev_clocale = std::string(setlocale(LC_TIME, NULL));
+        time_t test_time = 1252374030;  // 8 Sep 2009 01:40:01
+        struct tm *t = gmtime(&test_time);
+
+        setlocale(LC_TIME, en_locale);
+        if (strcmp(setlocale(LC_TIME, NULL), en_locale) != 0)
+        {
+            setlocale(LC_TIME, prev_clocale.c_str());
+            skip("Cannot set English locale");
+        }
+
+        LLStringUtil::setLocale(en_locale);
+        test_date_string(en_locale, t, "%d %B %Y - %H:%M", "08 september 2009 - 01:40");
+        test_date_string(en_locale, t, "%H", "01");
+        test_date_string(en_locale, t, "%M", "40");
+        test_date_string(en_locale, t, "%I", "01");
+        test_date_string(en_locale, t, "%d", "08");
+        test_date_string(en_locale, t, "%Y", "2009");
+        test_date_string(en_locale, t, "%p", "am");
+        test_date_string(en_locale, t, "%A", "tuesday");
+        test_date_string(en_locale, t, "%B", "september");
+
+        setlocale(LC_TIME, fr_locale);
+        if (strcmp(setlocale(LC_TIME, NULL), fr_locale) != 0)
+        {
+            LLStringUtil::setLocale(prev_locale);
+            setlocale(LC_TIME, prev_clocale.c_str());
+            skip("Cannot set French locale");
+        }
+
+        LLStringUtil::setLocale(fr_locale);
+        test_date_string(fr_locale, t, "%d %B %Y - %H:%M", "08 septembre 2009 - 01:40");
+        test_date_string(fr_locale, t, "%H", "01");
+        test_date_string(fr_locale, t, "%M", "40");
+        test_date_string(fr_locale, t, "%I", "01");
+        test_date_string(fr_locale, t, "%d", "08");
+        test_date_string(fr_locale, t, "%Y", "2009");
+        test_date_string(fr_locale, t, "%A", "mardi");
+        test_date_string(fr_locale, t, "%B", "septembre");
+
+        LLStringUtil::setLocale(prev_locale);
+        setlocale(LC_TIME, prev_clocale.c_str());
+    }
 }
diff --git a/indra/test/llhttpnode_tut.cpp b/indra/test/llhttpnode_tut.cpp
index c528a34129..c38dee120b 100644
--- a/indra/test/llhttpnode_tut.cpp
+++ b/indra/test/llhttpnode_tut.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file lliohttpnode_tut.cpp
  * @date   May 2006
  * @brief HTTP server unit tests
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2006&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -32,397 +32,397 @@
 
 namespace tut
 {
-	struct HTTPNodeTestData
-	{
-		LLHTTPNode mRoot;
-		LLSD mContext;
-	
-		const LLSD& context() { return mContext; }
-		
-		std::string remainderPath()
-		{
-			std::ostringstream pathOutput;
-			bool addSlash = false;
-			
-			LLSD& remainder = mContext[CONTEXT_REQUEST]["remainder"];
-			for (LLSD::array_const_iterator i = remainder.beginArray();
-				i != remainder.endArray();
-				++i)
-			{
-				if (addSlash) { pathOutput << '/'; }
-				pathOutput << i->asString();
-				addSlash = true;
-			}
-			
-			return pathOutput.str();
-		}
-		
-		void ensureRootTraversal(const std::string& path,
-			const LLHTTPNode* expectedNode,
-			const char* expectedRemainder)
-		{
-			mContext.clear();
-			
-			const LLHTTPNode* actualNode = mRoot.traverse(path, mContext);
-			
-			ensure_equals("traverse " + path + " node",
-				actualNode, expectedNode);
-			ensure_equals("traverse " + path + " remainder",
-				remainderPath(), expectedRemainder);
-		}
-
-		class Response : public LLHTTPNode::Response
-		{
-		public:
-			static LLPointer<Response> create() {return new Response();}
-
-			LLSD mResult;
-
-			void result(const LLSD& result) { mResult = result; }
-			void status(S32 code, const std::string& message) { }
-			void extendedResult(S32 code, const std::string& message, const LLSD& headers) { }
-			void extendedResult(S32 code, const LLSD& result, const LLSD& headers) { }
-			
-		private:
-			Response() {;} // Must be accessed through LLPointer.
-		};
-
-		typedef LLPointer<Response> ResponsePtr;
-
-		LLSD get(const std::string& path)
-		{
-			mContext.clear();
-			const LLHTTPNode* node = mRoot.traverse(path, mContext);
-			ensure(path + " found", node != NULL);
-
-			ResponsePtr response = Response::create();
-			node->get(LLHTTPNode::ResponsePtr(response), mContext);
-			return response->mResult;
-		}
-		
-		LLSD post(const std::string& path, const LLSD& input)
-		{
-			mContext.clear();
-			const LLHTTPNode* node = mRoot.traverse(path, mContext);
-			ensure(path + " found", node != NULL);
-
-			ResponsePtr response = Response::create();
-			node->post(LLHTTPNode::ResponsePtr(response), mContext, input);
-			return response->mResult;
-		}
-		
-		void ensureMemberString(const std::string& name,
-			const LLSD& actualMap, const std::string& member,
-			const std::string& expectedValue)
-		{
-			ensure_equals(name + " " + member,
-				actualMap[member].asString(), expectedValue);
-		}
-		
-		
-		void ensureInArray(const LLSD& actualArray,
-			const std::string& expectedValue)
-		{
-			LLSD::array_const_iterator i = actualArray.beginArray();
-			LLSD::array_const_iterator end = actualArray.endArray();
-		
-			for (; i != end; ++i)
-			{
-				std::string path = i->asString();
-
-				if (path == expectedValue)
-				{
-					return;
-				}
-			}
-			
-			fail("didn't find " + expectedValue);
-		}
-			
-	};
-	
-	typedef test_group<HTTPNodeTestData>	HTTPNodeTestGroup;
-	typedef HTTPNodeTestGroup::object		HTTPNodeTestObject;
-	HTTPNodeTestGroup httpNodeTestGroup("http node");
-
-	template<> template<>
-	void HTTPNodeTestObject::test<1>()
-	{
-		// traversal of the lone node
-		
-		ensureRootTraversal("", &mRoot, "");
-		ensureRootTraversal("/", &mRoot, "");
-		ensureRootTraversal("foo", NULL, "foo");
-		ensureRootTraversal("foo/bar", NULL, "foo/bar");
-		
-		ensure_equals("root of root", mRoot.rootNode(), &mRoot);
-	}
-	
-	template<> template<>
-	void HTTPNodeTestObject::test<2>()
-	{
-		// simple traversal of a single node
-		
-		LLHTTPNode* helloNode = new LLHTTPNode;
-		mRoot.addNode("hello", helloNode);
-
-		ensureRootTraversal("hello", helloNode, "");
-		ensureRootTraversal("/hello", helloNode, "");
-		ensureRootTraversal("hello/", helloNode, "");
-		ensureRootTraversal("/hello/", helloNode, "");
-
-		ensureRootTraversal("hello/there", NULL, "there");
-		
-		ensure_equals("root of hello", helloNode->rootNode(), &mRoot);
-	}
-
-	template<> template<>
-	void HTTPNodeTestObject::test<3>()
-	{
-		// traversal of mutli-branched tree
-		
-		LLHTTPNode* greekNode = new LLHTTPNode;
-		LLHTTPNode* alphaNode = new LLHTTPNode;
-		LLHTTPNode* betaNode = new LLHTTPNode;
-		LLHTTPNode* gammaNode = new LLHTTPNode;
-		
-		greekNode->addNode("alpha", alphaNode);
-		greekNode->addNode("beta", betaNode);
-		greekNode->addNode("gamma", gammaNode);
-		mRoot.addNode("greek", greekNode);
-		
-		LLHTTPNode* hebrewNode = new LLHTTPNode;
-		LLHTTPNode* alephNode = new LLHTTPNode;
-		
-		hebrewNode->addNode("aleph", alephNode);
-		mRoot.addNode("hebrew", hebrewNode);
-
-		ensureRootTraversal("greek/alpha", alphaNode, "");
-		ensureRootTraversal("greek/beta", betaNode, "");
-		ensureRootTraversal("greek/delta", NULL, "delta");
-		ensureRootTraversal("greek/gamma", gammaNode, "");
-		ensureRootTraversal("hebrew/aleph", alephNode, "");
-
-		ensure_equals("root of greek", greekNode->rootNode(), &mRoot);
-		ensure_equals("root of alpha", alphaNode->rootNode(), &mRoot);
-		ensure_equals("root of beta", betaNode->rootNode(), &mRoot);
-		ensure_equals("root of gamma", gammaNode->rootNode(), &mRoot);
-		ensure_equals("root of hebrew", hebrewNode->rootNode(), &mRoot);
-		ensure_equals("root of aleph", alephNode->rootNode(), &mRoot);
-	}
-
-	template<> template<>
-	void HTTPNodeTestObject::test<4>()
-	{
-		// automatic creation of parent nodes and not overriding existing nodes
-		
-		LLHTTPNode* alphaNode = new LLHTTPNode;
-		LLHTTPNode* betaNode = new LLHTTPNode;
-		LLHTTPNode* gammaNode = new LLHTTPNode;
-		LLHTTPNode* gamma2Node = new LLHTTPNode;
-		
-		mRoot.addNode("greek/alpha", alphaNode);
-		mRoot.addNode("greek/beta", betaNode);
-		
-		mRoot.addNode("greek/gamma", gammaNode);
-		mRoot.addNode("greek/gamma", gamma2Node);
-		
-		LLHTTPNode* alephNode = new LLHTTPNode;
-		
-		mRoot.addNode("hebrew/aleph", alephNode);
-
-		ensureRootTraversal("greek/alpha", alphaNode, "");
-		ensureRootTraversal("greek/beta", betaNode, "");
-		ensureRootTraversal("greek/delta", NULL, "delta");
-		ensureRootTraversal("greek/gamma", gammaNode, "");
-		ensureRootTraversal("hebrew/aleph", alephNode, "");
-
-		ensure_equals("root of alpha", alphaNode->rootNode(), &mRoot);
-		ensure_equals("root of beta", betaNode->rootNode(), &mRoot);
-		ensure_equals("root of gamma", gammaNode->rootNode(), &mRoot);
-		ensure_equals("root of aleph", alephNode->rootNode(), &mRoot);
-	}
-	
-	class IntegerNode : public LLHTTPNode
-	{
-	public:
-		virtual void get(ResponsePtr response, const LLSD& context) const
-		{
-			int n = context["extra"]["value"];
-			
-			LLSD info;
-			info["value"] = n;
-			info["positive"] = n > 0;
-			info["zero"] = n == 0;
-			info["negative"] = n < 0;
-		
-			response->result(info);
-		}
-		
-		virtual bool validate(const std::string& name, LLSD& context) const
-		{
-			int n;
-			std::istringstream i_stream(name);
-			i_stream >> n;
-
-			if (i_stream.fail()  ||  i_stream.get() != EOF)
-			{
-				return false;
-			}
-
-			context["extra"]["value"] = n;
-			return true;
-		}
-	};
-	
-	class SquareNode : public LLHTTPNode
-	{
-	public:
-		virtual void get(ResponsePtr response, const LLSD& context) const
-		{
-			int n = context["extra"]["value"];		
-			response->result(n*n);
-		}
-	};
-	
-	template<> template<>
-	void HTTPNodeTestObject::test<5>()
-	{
-		// wildcard nodes
-		
-		LLHTTPNode* miscNode = new LLHTTPNode;
-		LLHTTPNode* iNode = new IntegerNode;
-		LLHTTPNode* sqNode = new SquareNode;
-		
-		mRoot.addNode("test/misc", miscNode);
-		mRoot.addNode("test/<int>", iNode);
-		mRoot.addNode("test/<int>/square", sqNode);
-		
-		ensureRootTraversal("test/42", iNode, "");
-		ensure_equals("stored integer",
-			context()["extra"]["value"].asInteger(), 42);
-		
-		ensureRootTraversal("test/bob", NULL, "bob");
-		ensure("nothing stored",
-			context()["extra"]["value"].isUndefined());
-			
-		ensureRootTraversal("test/3/square", sqNode, "");
-		ResponsePtr response = Response::create();
-		sqNode->get(LLHTTPNode::ResponsePtr(response), context());
-		ensure_equals("square result", response->mResult.asInteger(), 9);
-	}
-	
-	class AlphaNode : public LLHTTPNode
-	{
-	public:
-		virtual bool handles(const LLSD& remainder, LLSD& context) const
-		{
-			LLSD::array_const_iterator i = remainder.beginArray();
-			LLSD::array_const_iterator end = remainder.endArray();
-			
-			for (; i != end; ++i)
-			{
-				std::string s = i->asString();
-				if (s.empty() || s[0] != 'a')
-				{
-					return false;
-				}
-			}
-			
-			return true;
-		}
-	};
-	
-	template<> template<>
-	void HTTPNodeTestObject::test<6>()
-	{
-		// nodes that handle remainders
-		
-		LLHTTPNode* miscNode = new LLHTTPNode;
-		LLHTTPNode* aNode = new AlphaNode;
-		LLHTTPNode* zNode = new LLHTTPNode;
-		
-		mRoot.addNode("test/misc", miscNode);
-		mRoot.addNode("test/alpha", aNode);
-		mRoot.addNode("test/alpha/zebra", zNode);
-		
-		ensureRootTraversal("test/alpha", aNode, "");
-		ensureRootTraversal("test/alpha/abe", aNode, "abe");
-		ensureRootTraversal("test/alpha/abe/amy", aNode, "abe/amy");
-		ensureRootTraversal("test/alpha/abe/bea", NULL, "abe/bea");
-		ensureRootTraversal("test/alpha/bob", NULL, "bob");
-		ensureRootTraversal("test/alpha/zebra", zNode, "");
-	}
-	
-	template<> template<>
-	void HTTPNodeTestObject::test<7>()
-	{
-		// test auto registration
-		
-		LLHTTPStandardServices::useServices();
-		LLHTTPRegistrar::buildAllServices(mRoot);
-		
-		{
-			LLSD result = get("web/hello");
-			ensure_equals("hello result", result.asString(), "hello");
-		}
-		{
-			LLSD stuff = 3.14159;
-			LLSD result = post("web/echo", stuff);
-			ensure_equals("echo result", result, stuff);
-		}
-	}
-
-	template<> template<>
-	void HTTPNodeTestObject::test<8>()
-	{
-		// test introspection
-		
-		LLHTTPRegistrar::buildAllServices(mRoot);
-		
-		mRoot.addNode("test/misc", new LLHTTPNode);
-		mRoot.addNode("test/<int>", new IntegerNode);
-		mRoot.addNode("test/<int>/square", new SquareNode);
-
-		const LLSD result = get("web/server/api");
-		
-		ensure("result is array", result.isArray());
-		ensure("result size", result.size() >= 2);
-		
-		ensureInArray(result, "web/echo");
-		ensureInArray(result, "web/hello");
-		ensureInArray(result, "test/misc");
-		ensureInArray(result, "test/<int>");
-		ensureInArray(result, "test/<int>/square");
-	}
-	
-	template<> template<>
-	void HTTPNodeTestObject::test<9>()
-	{
-		// test introspection details
-
-		LLHTTPRegistrar::buildAllServices(mRoot);
-
-		const LLSD helloDetails = get("web/server/api/web/hello");
-		
-		ensure_contains("hello description",
-			helloDetails["description"].asString(), "hello");
-		ensure_equals("method name", helloDetails["api"][0].asString(), std::string("GET"));
-		ensureMemberString("hello", helloDetails, "output", "\"hello\"");
-		ensure_contains("hello __file__",
-			helloDetails["__file__"].asString(), "llsdhttpserver.cpp");
-		ensure("hello line", helloDetails["__line__"].isInteger());
-
-
-		const LLSD echoDetails = get("web/server/api/web/echo");
-		
-		ensure_contains("echo description",
-			echoDetails["description"].asString(), "echo");
-		ensure_equals("method name", echoDetails["api"][0].asString(), std::string("POST"));
-		ensureMemberString("echo", echoDetails, "input", "<any>");
-		ensureMemberString("echo", echoDetails, "output", "<the input>");
-		ensure_contains("echo __file__",
-			echoDetails["__file__"].asString(), "llsdhttpserver.cpp");
-		ensure("echo", echoDetails["__line__"].isInteger());
-	}
+    struct HTTPNodeTestData
+    {
+        LLHTTPNode mRoot;
+        LLSD mContext;
+
+        const LLSD& context() { return mContext; }
+
+        std::string remainderPath()
+        {
+            std::ostringstream pathOutput;
+            bool addSlash = false;
+
+            LLSD& remainder = mContext[CONTEXT_REQUEST]["remainder"];
+            for (LLSD::array_const_iterator i = remainder.beginArray();
+                i != remainder.endArray();
+                ++i)
+            {
+                if (addSlash) { pathOutput << '/'; }
+                pathOutput << i->asString();
+                addSlash = true;
+            }
+
+            return pathOutput.str();
+        }
+
+        void ensureRootTraversal(const std::string& path,
+            const LLHTTPNode* expectedNode,
+            const char* expectedRemainder)
+        {
+            mContext.clear();
+
+            const LLHTTPNode* actualNode = mRoot.traverse(path, mContext);
+
+            ensure_equals("traverse " + path + " node",
+                actualNode, expectedNode);
+            ensure_equals("traverse " + path + " remainder",
+                remainderPath(), expectedRemainder);
+        }
+
+        class Response : public LLHTTPNode::Response
+        {
+        public:
+            static LLPointer<Response> create() {return new Response();}
+
+            LLSD mResult;
+
+            void result(const LLSD& result) { mResult = result; }
+            void status(S32 code, const std::string& message) { }
+            void extendedResult(S32 code, const std::string& message, const LLSD& headers) { }
+            void extendedResult(S32 code, const LLSD& result, const LLSD& headers) { }
+
+        private:
+            Response() {;} // Must be accessed through LLPointer.
+        };
+
+        typedef LLPointer<Response> ResponsePtr;
+
+        LLSD get(const std::string& path)
+        {
+            mContext.clear();
+            const LLHTTPNode* node = mRoot.traverse(path, mContext);
+            ensure(path + " found", node != NULL);
+
+            ResponsePtr response = Response::create();
+            node->get(LLHTTPNode::ResponsePtr(response), mContext);
+            return response->mResult;
+        }
+
+        LLSD post(const std::string& path, const LLSD& input)
+        {
+            mContext.clear();
+            const LLHTTPNode* node = mRoot.traverse(path, mContext);
+            ensure(path + " found", node != NULL);
+
+            ResponsePtr response = Response::create();
+            node->post(LLHTTPNode::ResponsePtr(response), mContext, input);
+            return response->mResult;
+        }
+
+        void ensureMemberString(const std::string& name,
+            const LLSD& actualMap, const std::string& member,
+            const std::string& expectedValue)
+        {
+            ensure_equals(name + " " + member,
+                actualMap[member].asString(), expectedValue);
+        }
+
+
+        void ensureInArray(const LLSD& actualArray,
+            const std::string& expectedValue)
+        {
+            LLSD::array_const_iterator i = actualArray.beginArray();
+            LLSD::array_const_iterator end = actualArray.endArray();
+
+            for (; i != end; ++i)
+            {
+                std::string path = i->asString();
+
+                if (path == expectedValue)
+                {
+                    return;
+                }
+            }
+
+            fail("didn't find " + expectedValue);
+        }
+
+    };
+
+    typedef test_group<HTTPNodeTestData>    HTTPNodeTestGroup;
+    typedef HTTPNodeTestGroup::object       HTTPNodeTestObject;
+    HTTPNodeTestGroup httpNodeTestGroup("http node");
+
+    template<> template<>
+    void HTTPNodeTestObject::test<1>()
+    {
+        // traversal of the lone node
+
+        ensureRootTraversal("", &mRoot, "");
+        ensureRootTraversal("/", &mRoot, "");
+        ensureRootTraversal("foo", NULL, "foo");
+        ensureRootTraversal("foo/bar", NULL, "foo/bar");
+
+        ensure_equals("root of root", mRoot.rootNode(), &mRoot);
+    }
+
+    template<> template<>
+    void HTTPNodeTestObject::test<2>()
+    {
+        // simple traversal of a single node
+
+        LLHTTPNode* helloNode = new LLHTTPNode;
+        mRoot.addNode("hello", helloNode);
+
+        ensureRootTraversal("hello", helloNode, "");
+        ensureRootTraversal("/hello", helloNode, "");
+        ensureRootTraversal("hello/", helloNode, "");
+        ensureRootTraversal("/hello/", helloNode, "");
+
+        ensureRootTraversal("hello/there", NULL, "there");
+
+        ensure_equals("root of hello", helloNode->rootNode(), &mRoot);
+    }
+
+    template<> template<>
+    void HTTPNodeTestObject::test<3>()
+    {
+        // traversal of mutli-branched tree
+
+        LLHTTPNode* greekNode = new LLHTTPNode;
+        LLHTTPNode* alphaNode = new LLHTTPNode;
+        LLHTTPNode* betaNode = new LLHTTPNode;
+        LLHTTPNode* gammaNode = new LLHTTPNode;
+
+        greekNode->addNode("alpha", alphaNode);
+        greekNode->addNode("beta", betaNode);
+        greekNode->addNode("gamma", gammaNode);
+        mRoot.addNode("greek", greekNode);
+
+        LLHTTPNode* hebrewNode = new LLHTTPNode;
+        LLHTTPNode* alephNode = new LLHTTPNode;
+
+        hebrewNode->addNode("aleph", alephNode);
+        mRoot.addNode("hebrew", hebrewNode);
+
+        ensureRootTraversal("greek/alpha", alphaNode, "");
+        ensureRootTraversal("greek/beta", betaNode, "");
+        ensureRootTraversal("greek/delta", NULL, "delta");
+        ensureRootTraversal("greek/gamma", gammaNode, "");
+        ensureRootTraversal("hebrew/aleph", alephNode, "");
+
+        ensure_equals("root of greek", greekNode->rootNode(), &mRoot);
+        ensure_equals("root of alpha", alphaNode->rootNode(), &mRoot);
+        ensure_equals("root of beta", betaNode->rootNode(), &mRoot);
+        ensure_equals("root of gamma", gammaNode->rootNode(), &mRoot);
+        ensure_equals("root of hebrew", hebrewNode->rootNode(), &mRoot);
+        ensure_equals("root of aleph", alephNode->rootNode(), &mRoot);
+    }
+
+    template<> template<>
+    void HTTPNodeTestObject::test<4>()
+    {
+        // automatic creation of parent nodes and not overriding existing nodes
+
+        LLHTTPNode* alphaNode = new LLHTTPNode;
+        LLHTTPNode* betaNode = new LLHTTPNode;
+        LLHTTPNode* gammaNode = new LLHTTPNode;
+        LLHTTPNode* gamma2Node = new LLHTTPNode;
+
+        mRoot.addNode("greek/alpha", alphaNode);
+        mRoot.addNode("greek/beta", betaNode);
+
+        mRoot.addNode("greek/gamma", gammaNode);
+        mRoot.addNode("greek/gamma", gamma2Node);
+
+        LLHTTPNode* alephNode = new LLHTTPNode;
+
+        mRoot.addNode("hebrew/aleph", alephNode);
+
+        ensureRootTraversal("greek/alpha", alphaNode, "");
+        ensureRootTraversal("greek/beta", betaNode, "");
+        ensureRootTraversal("greek/delta", NULL, "delta");
+        ensureRootTraversal("greek/gamma", gammaNode, "");
+        ensureRootTraversal("hebrew/aleph", alephNode, "");
+
+        ensure_equals("root of alpha", alphaNode->rootNode(), &mRoot);
+        ensure_equals("root of beta", betaNode->rootNode(), &mRoot);
+        ensure_equals("root of gamma", gammaNode->rootNode(), &mRoot);
+        ensure_equals("root of aleph", alephNode->rootNode(), &mRoot);
+    }
+
+    class IntegerNode : public LLHTTPNode
+    {
+    public:
+        virtual void get(ResponsePtr response, const LLSD& context) const
+        {
+            int n = context["extra"]["value"];
+
+            LLSD info;
+            info["value"] = n;
+            info["positive"] = n > 0;
+            info["zero"] = n == 0;
+            info["negative"] = n < 0;
+
+            response->result(info);
+        }
+
+        virtual bool validate(const std::string& name, LLSD& context) const
+        {
+            int n;
+            std::istringstream i_stream(name);
+            i_stream >> n;
+
+            if (i_stream.fail()  ||  i_stream.get() != EOF)
+            {
+                return false;
+            }
+
+            context["extra"]["value"] = n;
+            return true;
+        }
+    };
+
+    class SquareNode : public LLHTTPNode
+    {
+    public:
+        virtual void get(ResponsePtr response, const LLSD& context) const
+        {
+            int n = context["extra"]["value"];
+            response->result(n*n);
+        }
+    };
+
+    template<> template<>
+    void HTTPNodeTestObject::test<5>()
+    {
+        // wildcard nodes
+
+        LLHTTPNode* miscNode = new LLHTTPNode;
+        LLHTTPNode* iNode = new IntegerNode;
+        LLHTTPNode* sqNode = new SquareNode;
+
+        mRoot.addNode("test/misc", miscNode);
+        mRoot.addNode("test/<int>", iNode);
+        mRoot.addNode("test/<int>/square", sqNode);
+
+        ensureRootTraversal("test/42", iNode, "");
+        ensure_equals("stored integer",
+            context()["extra"]["value"].asInteger(), 42);
+
+        ensureRootTraversal("test/bob", NULL, "bob");
+        ensure("nothing stored",
+            context()["extra"]["value"].isUndefined());
+
+        ensureRootTraversal("test/3/square", sqNode, "");
+        ResponsePtr response = Response::create();
+        sqNode->get(LLHTTPNode::ResponsePtr(response), context());
+        ensure_equals("square result", response->mResult.asInteger(), 9);
+    }
+
+    class AlphaNode : public LLHTTPNode
+    {
+    public:
+        virtual bool handles(const LLSD& remainder, LLSD& context) const
+        {
+            LLSD::array_const_iterator i = remainder.beginArray();
+            LLSD::array_const_iterator end = remainder.endArray();
+
+            for (; i != end; ++i)
+            {
+                std::string s = i->asString();
+                if (s.empty() || s[0] != 'a')
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    };
+
+    template<> template<>
+    void HTTPNodeTestObject::test<6>()
+    {
+        // nodes that handle remainders
+
+        LLHTTPNode* miscNode = new LLHTTPNode;
+        LLHTTPNode* aNode = new AlphaNode;
+        LLHTTPNode* zNode = new LLHTTPNode;
+
+        mRoot.addNode("test/misc", miscNode);
+        mRoot.addNode("test/alpha", aNode);
+        mRoot.addNode("test/alpha/zebra", zNode);
+
+        ensureRootTraversal("test/alpha", aNode, "");
+        ensureRootTraversal("test/alpha/abe", aNode, "abe");
+        ensureRootTraversal("test/alpha/abe/amy", aNode, "abe/amy");
+        ensureRootTraversal("test/alpha/abe/bea", NULL, "abe/bea");
+        ensureRootTraversal("test/alpha/bob", NULL, "bob");
+        ensureRootTraversal("test/alpha/zebra", zNode, "");
+    }
+
+    template<> template<>
+    void HTTPNodeTestObject::test<7>()
+    {
+        // test auto registration
+
+        LLHTTPStandardServices::useServices();
+        LLHTTPRegistrar::buildAllServices(mRoot);
+
+        {
+            LLSD result = get("web/hello");
+            ensure_equals("hello result", result.asString(), "hello");
+        }
+        {
+            LLSD stuff = 3.14159;
+            LLSD result = post("web/echo", stuff);
+            ensure_equals("echo result", result, stuff);
+        }
+    }
+
+    template<> template<>
+    void HTTPNodeTestObject::test<8>()
+    {
+        // test introspection
+
+        LLHTTPRegistrar::buildAllServices(mRoot);
+
+        mRoot.addNode("test/misc", new LLHTTPNode);
+        mRoot.addNode("test/<int>", new IntegerNode);
+        mRoot.addNode("test/<int>/square", new SquareNode);
+
+        const LLSD result = get("web/server/api");
+
+        ensure("result is array", result.isArray());
+        ensure("result size", result.size() >= 2);
+
+        ensureInArray(result, "web/echo");
+        ensureInArray(result, "web/hello");
+        ensureInArray(result, "test/misc");
+        ensureInArray(result, "test/<int>");
+        ensureInArray(result, "test/<int>/square");
+    }
+
+    template<> template<>
+    void HTTPNodeTestObject::test<9>()
+    {
+        // test introspection details
+
+        LLHTTPRegistrar::buildAllServices(mRoot);
+
+        const LLSD helloDetails = get("web/server/api/web/hello");
+
+        ensure_contains("hello description",
+            helloDetails["description"].asString(), "hello");
+        ensure_equals("method name", helloDetails["api"][0].asString(), std::string("GET"));
+        ensureMemberString("hello", helloDetails, "output", "\"hello\"");
+        ensure_contains("hello __file__",
+            helloDetails["__file__"].asString(), "llsdhttpserver.cpp");
+        ensure("hello line", helloDetails["__line__"].isInteger());
+
+
+        const LLSD echoDetails = get("web/server/api/web/echo");
+
+        ensure_contains("echo description",
+            echoDetails["description"].asString(), "echo");
+        ensure_equals("method name", echoDetails["api"][0].asString(), std::string("POST"));
+        ensureMemberString("echo", echoDetails, "input", "<any>");
+        ensureMemberString("echo", echoDetails, "output", "<the input>");
+        ensure_contains("echo __file__",
+            echoDetails["__file__"].asString(), "llsdhttpserver.cpp");
+        ensure("echo", echoDetails["__line__"].isInteger());
+    }
 }
diff --git a/indra/test/lliohttpserver_tut.cpp b/indra/test/lliohttpserver_tut.cpp
index 1513446788..7034f4a063 100644
--- a/indra/test/lliohttpserver_tut.cpp
+++ b/indra/test/lliohttpserver_tut.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file lliohttpserver_tut.cpp
  * @date   May 2006
  * @brief HTTP server unit tests
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2006&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -38,313 +38,313 @@
 
 namespace tut
 {
-	class HTTPServiceTestData
-	{
-	public:
-		class DelayedEcho : public LLHTTPNode
-		{
-			HTTPServiceTestData* mTester;
-
-		public:
-			DelayedEcho(HTTPServiceTestData* tester) : mTester(tester) { }
-
-			void post(ResponsePtr response, const LLSD& context, const LLSD& input) const
-			{
-				ensure("response already set", mTester->mResponse == ResponsePtr(NULL));
-				mTester->mResponse = response;
-				mTester->mResult = input;
-			}
-		};
-
-		class WireHello : public LLIOPipe
-		{
-		protected:
-			virtual EStatus process_impl(
-				const LLChannelDescriptors& channels,
-				buffer_ptr_t& buffer,
-				bool& eos,
-				LLSD& context,
-				LLPumpIO* pump)
-			{
-				if(!eos) return STATUS_BREAK;
-				LLSD sd = "yo!";
-				LLBufferStream ostr(channels, buffer.get());
-				ostr << LLSDXMLStreamer(sd);
-				return STATUS_DONE;
-			}
-		};
-
-		HTTPServiceTestData()
-			: mResponse(NULL)
-		{
-			LLHTTPStandardServices::useServices();
-			LLHTTPRegistrar::buildAllServices(mRoot);
-			mRoot.addNode("/delayed/echo", new DelayedEcho(this));
-			mRoot.addNode("/wire/hello", new LLHTTPNodeForPipe<WireHello>);
-		}
-
-		~HTTPServiceTestData()
-		{
-		}
-		
-		LLHTTPNode mRoot;
-		LLHTTPNode::ResponsePtr mResponse;
-		LLSD mResult;
-
-		void pumpPipe(LLPumpIO* pump, S32 iterations)
-		{
-			while(iterations > 0)
-			{
-				pump->pump();
-				pump->callback();
-				--iterations;
-			}
-		}
-
-		std::string makeRequest(
-			const std::string& name,
-			const std::string& httpRequest,
-			bool timeout = false)
-		{
-			LLPipeStringInjector* injector = new LLPipeStringInjector(httpRequest);
-			LLPipeStringExtractor* extractor = new LLPipeStringExtractor();
-			
-			apr_pool_t* pool;
-			apr_pool_create(&pool, NULL);
-
-			LLPumpIO* pump;
-			pump = new LLPumpIO(pool);
-
-			LLPumpIO::chain_t chain;
-			LLSD context;
-
-			chain.push_back(LLIOPipe::ptr_t(injector));
-			LLIOHTTPServer::createPipe(chain, mRoot, LLSD());
-			chain.push_back(LLIOPipe::ptr_t(extractor));
-
-			pump->addChain(chain, DEFAULT_CHAIN_EXPIRY_SECS);
-
-			pumpPipe(pump, 10);
-			if(mResponse.notNull() && (! timeout)) 
-			{
-				mResponse->result(mResult);
-				mResponse = NULL;
-			}
-			pumpPipe(pump, 10);
-			
-			std::string httpResult = extractor->string();
-
-			chain.clear();
-			delete pump;
-			apr_pool_destroy(pool);
-
-			if(mResponse.notNull() && timeout)
-			{
-				mResponse->result(mResult);
-				mResponse = NULL;
-			}
-			
-			return httpResult;
-		}
-		
-		std::string httpGET(const std::string& uri, 
-							bool timeout = false)
-		{
-			std::string httpRequest = "GET " + uri + " HTTP/1.0\r\n\r\n";
-			return makeRequest(uri, httpRequest, timeout);
-		}
-		
-		std::string httpPOST(const std::string& uri,
-			const std::string& body,
-			bool timeout,
-			const std::string& evilExtra = "")
-		{
-			std::ostringstream httpRequest;
-			httpRequest << "POST " + uri + " HTTP/1.0\r\n";
-			httpRequest << "Content-Length: " << body.size() << "\r\n";
-			httpRequest << "\r\n";
-			httpRequest << body;
-			httpRequest << evilExtra;
-				
-			return makeRequest(uri, httpRequest.str(), timeout);
-		}
-
-		std::string httpPOST(const std::string& uri,
-			const std::string& body,
-			const std::string& evilExtra = "")
-		{
-			bool timeout = false;
-			return httpPOST(uri, body, timeout, evilExtra);
-		}
-	};
-
-	typedef test_group<HTTPServiceTestData>		HTTPServiceTestGroup;
-	typedef HTTPServiceTestGroup::object		HTTPServiceTestObject;
-	HTTPServiceTestGroup httpServiceTestGroup("http service");
-
-	template<> template<>
-	void HTTPServiceTestObject::test<1>()
-	{
-		std::string result = httpGET("web/hello");
-		
-		ensure_starts_with("web/hello status", result,
-			"HTTP/1.0 200 OK\r\n");
-						
-		ensure_contains("web/hello content type", result,
-			"Content-Type: application/llsd+xml\r\n");
-
-		ensure_contains("web/hello content length", result,
-			"Content-Length: 36\r\n");
-
-		ensure_contains("web/hello content", result,
-			"\r\n"
-			"<llsd><string>hello</string></llsd>"
-			);
-	}
-	
-	template<> template<>
-	void HTTPServiceTestObject::test<2>()
-	{
-		// test various HTTP errors
-		
-		std::string actual;
-
-		actual = httpGET("web/missing");
-		ensure_starts_with("web/missing 404", actual,
-			"HTTP/1.0 404 Not Found\r\n");
-
-		actual = httpGET("web/echo");			
-		ensure_starts_with("web/echo 405", actual,
-			"HTTP/1.0 405 Method Not Allowed\r\n");
-	}
-	
-	template<> template<>
-	void HTTPServiceTestObject::test<3>()
-	{
-		// test POST & content-length handling
-		
-		std::string result;
-		
-		result = httpPOST("web/echo",
-			"<llsd><integer>42</integer></llsd>");
-			
-		ensure_starts_with("web/echo status", result,
-			"HTTP/1.0 200 OK\r\n");
-						
-		ensure_contains("web/echo content type", result,
-			"Content-Type: application/llsd+xml\r\n");
-
-		ensure_contains("web/echo content length", result,
-			"Content-Length: 35\r\n");
-
-		ensure_contains("web/hello content", result,
-			"\r\n"
-			"<llsd><integer>42</integer></llsd>"
-			);
+    class HTTPServiceTestData
+    {
+    public:
+        class DelayedEcho : public LLHTTPNode
+        {
+            HTTPServiceTestData* mTester;
+
+        public:
+            DelayedEcho(HTTPServiceTestData* tester) : mTester(tester) { }
+
+            void post(ResponsePtr response, const LLSD& context, const LLSD& input) const
+            {
+                ensure("response already set", mTester->mResponse == ResponsePtr(NULL));
+                mTester->mResponse = response;
+                mTester->mResult = input;
+            }
+        };
+
+        class WireHello : public LLIOPipe
+        {
+        protected:
+            virtual EStatus process_impl(
+                const LLChannelDescriptors& channels,
+                buffer_ptr_t& buffer,
+                bool& eos,
+                LLSD& context,
+                LLPumpIO* pump)
+            {
+                if(!eos) return STATUS_BREAK;
+                LLSD sd = "yo!";
+                LLBufferStream ostr(channels, buffer.get());
+                ostr << LLSDXMLStreamer(sd);
+                return STATUS_DONE;
+            }
+        };
+
+        HTTPServiceTestData()
+            : mResponse(NULL)
+        {
+            LLHTTPStandardServices::useServices();
+            LLHTTPRegistrar::buildAllServices(mRoot);
+            mRoot.addNode("/delayed/echo", new DelayedEcho(this));
+            mRoot.addNode("/wire/hello", new LLHTTPNodeForPipe<WireHello>);
+        }
+
+        ~HTTPServiceTestData()
+        {
+        }
+
+        LLHTTPNode mRoot;
+        LLHTTPNode::ResponsePtr mResponse;
+        LLSD mResult;
+
+        void pumpPipe(LLPumpIO* pump, S32 iterations)
+        {
+            while(iterations > 0)
+            {
+                pump->pump();
+                pump->callback();
+                --iterations;
+            }
+        }
+
+        std::string makeRequest(
+            const std::string& name,
+            const std::string& httpRequest,
+            bool timeout = false)
+        {
+            LLPipeStringInjector* injector = new LLPipeStringInjector(httpRequest);
+            LLPipeStringExtractor* extractor = new LLPipeStringExtractor();
+
+            apr_pool_t* pool;
+            apr_pool_create(&pool, NULL);
+
+            LLPumpIO* pump;
+            pump = new LLPumpIO(pool);
+
+            LLPumpIO::chain_t chain;
+            LLSD context;
+
+            chain.push_back(LLIOPipe::ptr_t(injector));
+            LLIOHTTPServer::createPipe(chain, mRoot, LLSD());
+            chain.push_back(LLIOPipe::ptr_t(extractor));
+
+            pump->addChain(chain, DEFAULT_CHAIN_EXPIRY_SECS);
+
+            pumpPipe(pump, 10);
+            if(mResponse.notNull() && (! timeout))
+            {
+                mResponse->result(mResult);
+                mResponse = NULL;
+            }
+            pumpPipe(pump, 10);
+
+            std::string httpResult = extractor->string();
+
+            chain.clear();
+            delete pump;
+            apr_pool_destroy(pool);
+
+            if(mResponse.notNull() && timeout)
+            {
+                mResponse->result(mResult);
+                mResponse = NULL;
+            }
+
+            return httpResult;
+        }
+
+        std::string httpGET(const std::string& uri,
+                            bool timeout = false)
+        {
+            std::string httpRequest = "GET " + uri + " HTTP/1.0\r\n\r\n";
+            return makeRequest(uri, httpRequest, timeout);
+        }
+
+        std::string httpPOST(const std::string& uri,
+            const std::string& body,
+            bool timeout,
+            const std::string& evilExtra = "")
+        {
+            std::ostringstream httpRequest;
+            httpRequest << "POST " + uri + " HTTP/1.0\r\n";
+            httpRequest << "Content-Length: " << body.size() << "\r\n";
+            httpRequest << "\r\n";
+            httpRequest << body;
+            httpRequest << evilExtra;
+
+            return makeRequest(uri, httpRequest.str(), timeout);
+        }
+
+        std::string httpPOST(const std::string& uri,
+            const std::string& body,
+            const std::string& evilExtra = "")
+        {
+            bool timeout = false;
+            return httpPOST(uri, body, timeout, evilExtra);
+        }
+    };
+
+    typedef test_group<HTTPServiceTestData>     HTTPServiceTestGroup;
+    typedef HTTPServiceTestGroup::object        HTTPServiceTestObject;
+    HTTPServiceTestGroup httpServiceTestGroup("http service");
+
+    template<> template<>
+    void HTTPServiceTestObject::test<1>()
+    {
+        std::string result = httpGET("web/hello");
+
+        ensure_starts_with("web/hello status", result,
+            "HTTP/1.0 200 OK\r\n");
+
+        ensure_contains("web/hello content type", result,
+            "Content-Type: application/llsd+xml\r\n");
+
+        ensure_contains("web/hello content length", result,
+            "Content-Length: 36\r\n");
+
+        ensure_contains("web/hello content", result,
+            "\r\n"
+            "<llsd><string>hello</string></llsd>"
+            );
+    }
+
+    template<> template<>
+    void HTTPServiceTestObject::test<2>()
+    {
+        // test various HTTP errors
+
+        std::string actual;
+
+        actual = httpGET("web/missing");
+        ensure_starts_with("web/missing 404", actual,
+            "HTTP/1.0 404 Not Found\r\n");
+
+        actual = httpGET("web/echo");
+        ensure_starts_with("web/echo 405", actual,
+            "HTTP/1.0 405 Method Not Allowed\r\n");
+    }
+
+    template<> template<>
+    void HTTPServiceTestObject::test<3>()
+    {
+        // test POST & content-length handling
+
+        std::string result;
+
+        result = httpPOST("web/echo",
+            "<llsd><integer>42</integer></llsd>");
+
+        ensure_starts_with("web/echo status", result,
+            "HTTP/1.0 200 OK\r\n");
+
+        ensure_contains("web/echo content type", result,
+            "Content-Type: application/llsd+xml\r\n");
+
+        ensure_contains("web/echo content length", result,
+            "Content-Length: 35\r\n");
+
+        ensure_contains("web/hello content", result,
+            "\r\n"
+            "<llsd><integer>42</integer></llsd>"
+            );
 
 /* TO DO: this test doesn't pass!!
-		
-		result = httpPOST("web/echo",
-			"<llsd><string>evil</string></llsd>",
-			"really!  evil!!!");
-			
-		ensure_equals("web/echo evil result", result,
-			"HTTP/1.0 200 OK\r\n"
-			"Content-Length: 34\r\n"
-			"\r\n"
-			"<llsd><string>evil</string></llsd>"
-			);
+
+        result = httpPOST("web/echo",
+            "<llsd><string>evil</string></llsd>",
+            "really!  evil!!!");
+
+        ensure_equals("web/echo evil result", result,
+            "HTTP/1.0 200 OK\r\n"
+            "Content-Length: 34\r\n"
+            "\r\n"
+            "<llsd><string>evil</string></llsd>"
+            );
 */
-	}
+    }
+
+    template<> template<>
+    void HTTPServiceTestObject::test<4>()
+    {
+        // test calling things based on pipes
+
+        std::string result;
+
+        result = httpGET("wire/hello");
 
-	template<> template<>
-	void HTTPServiceTestObject::test<4>()
-	{
-		// test calling things based on pipes
+        ensure_contains("wire/hello", result, "yo!");
+    }
 
-		std::string result;
+    template<> template<>
+    void HTTPServiceTestObject::test<5>()
+    {
+        // test timeout before async response
+        std::string result;
+
+        bool timeout = true;
+        result = httpPOST("delayed/echo",
+            "<llsd><string>agent99</string></llsd>", timeout);
 
-		result = httpGET("wire/hello");
+        ensure_equals("timeout delayed/echo status", result, std::string(""));
+    }
+
+    template<> template<>
+    void HTTPServiceTestObject::test<6>()
+    {
+        // test delayed service
+        std::string result;
 
-		ensure_contains("wire/hello", result, "yo!");
-	}
+        result = httpPOST("delayed/echo",
+            "<llsd><string>agent99</string></llsd>");
+
+        ensure_starts_with("delayed/echo status", result,
+            "HTTP/1.0 200 OK\r\n");
+
+        ensure_contains("delayed/echo content", result,
+            "\r\n"
+            "<llsd><string>agent99</string></llsd>"
+            );
+    }
+
+    template<> template<>
+    void HTTPServiceTestObject::test<7>()
+    {
+        // test large request
+        std::stringstream stream;
+
+        //U32 size = 36 * 1024 * 1024;
+        //U32 size = 36 * 1024;
+        //std::vector<char> data(size);
+        //memset(&(data[0]), '1', size);
+        //data[size - 1] = '\0';
+
+
+        //std::string result = httpPOST("web/echo", &(data[0]));
+
+        stream << "<llsd><array>";
+        for(U32 i = 0; i < 1000000; ++i)
+        {
+            stream << "<integer>42</integer>";
+        }
+        stream << "</array></llsd>";
+        LL_INFOS() << "HTTPServiceTestObject::test<7>"
+                << stream.str().length() << LL_ENDL;
+        std::string result = httpPOST("web/echo", stream.str());
+        ensure_starts_with("large echo status", result, "HTTP/1.0 200 OK\r\n");
+    }
 
     template<> template<>
-	void HTTPServiceTestObject::test<5>()
+    void HTTPServiceTestObject::test<8>()
     {
-		// test timeout before async response
-		std::string result;
-
-		bool timeout = true;
-		result = httpPOST("delayed/echo",
-			"<llsd><string>agent99</string></llsd>", timeout);
-
-		ensure_equals("timeout delayed/echo status", result, std::string(""));
-	}
-
-	template<> template<>
-	void HTTPServiceTestObject::test<6>()
-	{
-		// test delayed service		
-		std::string result;
-		
-		result = httpPOST("delayed/echo",
-			"<llsd><string>agent99</string></llsd>");
-			
-		ensure_starts_with("delayed/echo status", result,
-			"HTTP/1.0 200 OK\r\n");
-						
-		ensure_contains("delayed/echo content", result,
-			"\r\n"
-			"<llsd><string>agent99</string></llsd>"
-			);
-	}
-
-	template<> template<>
-	void HTTPServiceTestObject::test<7>()
-	{
-		// test large request
-		std::stringstream stream;
-
-		//U32 size = 36 * 1024 * 1024;
-		//U32 size = 36 * 1024;
-		//std::vector<char> data(size);
-		//memset(&(data[0]), '1', size);
-		//data[size - 1] = '\0';
-
-		
-		//std::string result = httpPOST("web/echo", &(data[0]));
-
-		stream << "<llsd><array>";
-		for(U32 i = 0; i < 1000000; ++i)
-		{
-			stream << "<integer>42</integer>";
-		}
-		stream << "</array></llsd>";
-		LL_INFOS() << "HTTPServiceTestObject::test<7>"
-				<< stream.str().length() << LL_ENDL;
-		std::string result = httpPOST("web/echo", stream.str());
-		ensure_starts_with("large echo status", result, "HTTP/1.0 200 OK\r\n");
-	}
-
-	template<> template<>
-	void HTTPServiceTestObject::test<8>()
-	{
-		// test the OPTIONS http method -- the default implementation
-		// should return the X-Documentation-URL
-		std::ostringstream http_request;
-		http_request << "OPTIONS /  HTTP/1.0\r\nHost: localhost\r\n\r\n";
-		bool timeout = false;
-		std::string result = makeRequest("/", http_request.str(), timeout);
-		ensure_starts_with("OPTIONS verb ok", result, "HTTP/1.0 200 OK\r\n");
-		ensure_contains(
-			"Doc url header exists",
-			result,
-			"X-Documentation-URL: http://localhost");
-	}
-
-
-	/* TO DO:
-		test generation of not found and method not allowed errors
-	*/
+        // test the OPTIONS http method -- the default implementation
+        // should return the X-Documentation-URL
+        std::ostringstream http_request;
+        http_request << "OPTIONS /  HTTP/1.0\r\nHost: localhost\r\n\r\n";
+        bool timeout = false;
+        std::string result = makeRequest("/", http_request.str(), timeout);
+        ensure_starts_with("OPTIONS verb ok", result, "HTTP/1.0 200 OK\r\n");
+        ensure_contains(
+            "Doc url header exists",
+            result,
+            "X-Documentation-URL: http://localhost");
+    }
+
+
+    /* TO DO:
+        test generation of not found and method not allowed errors
+    */
 }
diff --git a/indra/test/llmessageconfig_tut.cpp b/indra/test/llmessageconfig_tut.cpp
index df2151b1b1..93443467a2 100644
--- a/indra/test/llmessageconfig_tut.cpp
+++ b/indra/test/llmessageconfig_tut.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llmessageconfig_tut.cpp
  * @date   March 2007
  * @brief LLMessageConfig unit tests
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2006&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -36,201 +36,201 @@
 
 namespace tut
 {
-	struct LLMessageConfigTestData {
-		std::string mTestConfigDir;
-
-		LLMessageConfigTestData()
-		{
-			LLUUID random;
-			random.generate();
-			// generate temp dir
-			std::ostringstream oStr;
-#if LL_WINDOWS 
-			oStr << "llmessage-config-test-" << random;
+    struct LLMessageConfigTestData {
+        std::string mTestConfigDir;
+
+        LLMessageConfigTestData()
+        {
+            LLUUID random;
+            random.generate();
+            // generate temp dir
+            std::ostringstream oStr;
+#if LL_WINDOWS
+            oStr << "llmessage-config-test-" << random;
 #else
-			oStr << "/tmp/llmessage-config-test-" << random;
+            oStr << "/tmp/llmessage-config-test-" << random;
 #endif
-			mTestConfigDir = oStr.str();
-			LLFile::mkdir(mTestConfigDir);
-			writeConfigFile(LLSD());
-			LLMessageConfig::initClass("simulator", mTestConfigDir);
-		}
-
-		~LLMessageConfigTestData()
-		{
-			// rm contents of temp dir
-			int rmfile = LLFile::remove((mTestConfigDir + "/message.xml"));
-			ensure_equals("rmfile value", rmfile, 0);
-			// rm temp dir
-			int rmdir = LLFile::rmdir(mTestConfigDir);
-			ensure_equals("rmdir value", rmdir, 0);
-		}
-
-		void writeConfigFile(const LLSD& config)
-		{
-			llofstream file((mTestConfigDir + "/message.xml").c_str());
-			if (file.is_open())
-			{
-				LLSDSerialize::toPrettyXML(config, file);
-			}
-			file.close();
-		}
-	};
-	
-	typedef test_group<LLMessageConfigTestData> LLMessageConfigTestGroup;
-	typedef LLMessageConfigTestGroup::object LLMessageConfigTestObject;
-	LLMessageConfigTestGroup llMessageConfigTestGroup("LLMessageConfig");
-	
-	template<> template<>
-	void LLMessageConfigTestObject::test<1>()
-		// tests server defaults
-	{
-		LLSD config;
-		config["serverDefaults"]["simulator"] = "template";
-		LLMessageConfig::useConfig(config);
-		ensure_equals("Ensure server default is not template",
-					  LLMessageConfig::getServerDefaultFlavor(),
-					  LLMessageConfig::TEMPLATE_FLAVOR);
-	}
-
-	template<> template<>
-	void LLMessageConfigTestObject::test<2>()
-		// tests message flavors
-	{
-		LLSD config;
-		config["serverDefaults"]["simulator"] = "template";
-		config["messages"]["msg1"]["flavor"] = "template";
-		config["messages"]["msg2"]["flavor"] = "llsd";
-		LLMessageConfig::useConfig(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 flavor defaults
-	{
-		LLSD config;
-		config["serverDefaults"]["simulator"] = "llsd";
-		config["messages"]["msg1"]["trusted-sender"] = true;
-		LLMessageConfig::useConfig(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;
-		config["serverDefaults"]["simulator"] = "template";
-		config["messages"]["msg1"]["flavor"] = "llsd";
-		config["messages"]["msg1"]["trusted-sender"] = false;
-		config["messages"]["msg2"]["flavor"] = "llsd";
-		config["messages"]["msg2"]["trusted-sender"] = true;
-		LLMessageConfig::useConfig(config);
-		ensure_equals("Ensure untrusted is untrusted",
-					  LLMessageConfig::getSenderTrustedness("msg1"),
-					  LLMessageConfig::UNTRUSTED);
-		ensure_equals("Ensure trusted is trusted",
-					  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 flavor
-	{
-		LLSD config;
-		config["serverDefaults"]["simulator"] = "template";
-		config["messages"]["msg1"]["flavor"] = "llsd";
-		LLMessageConfig::useConfig(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>()
-	{
-		LLSD config;
-		config["capBans"]["MapLayer"] = true;
-		config["capBans"]["MapLayerGod"] = false;
-		LLMessageConfig::useConfig(config);
-		ensure_equals("Ensure cap ban true MapLayer",
-					  LLMessageConfig::isCapBanned("MapLayer"),
-					  true);
-		ensure_equals("Ensure cap ban false",
-					  LLMessageConfig::isCapBanned("MapLayerGod"),
-					  false);
-	}
-
-	template<> template<>
-	void LLMessageConfigTestObject::test<7>()
-		// tests that config changes are picked up/refreshed periodically
-	{
-		LLSD config;
-		config["serverDefaults"]["simulator"] = "llsd";
-		writeConfigFile(config);
-
-		// 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);
-	}
-
-	template<> template<>
-	void LLMessageConfigTestObject::test<8>()
-		// tests that config changes are picked up/refreshed periodically
-	{
-		LLSD config;
-		config["serverDefaults"]["simulator"] = "template";
-		config["messages"]["msg1"]["flavor"] = "llsd";
-		config["messages"]["msg1"]["only-send-latest"] = true;
-		config["messages"]["msg2"]["flavor"] = "llsd";
-		config["messages"]["msg2"]["only-send-latest"] = false;
-		LLMessageConfig::useConfig(config);
-		ensure_equals("Ensure msg1 exists, sent latest-only",
-					  LLMessageConfig::onlySendLatest("msg1"),
-					  true);
-		ensure_equals("Ensure msg2 exists, sent latest-only",
-					  LLMessageConfig::onlySendLatest("msg2"),
-					  false);
-	}
-
-	template<> template<>
-	void LLMessageConfigTestObject::test<9>()
-		 // tests that event queue max is reloaded
-	{
-		LLSD config;
-		config["maxQueuedEvents"] = 200;
-		LLMessageConfig::useConfig(config);
-		ensure_equals("Ensure setting maxQueuedEvents",
-					  LLMessageConfig::getMaxQueuedEvents(),
-					  200);
-
-		LLMessageConfig::useConfig(LLSD());
-		ensure_equals("Ensure default of event queue max 100",
-					  LLMessageConfig::getMaxQueuedEvents(),
-					  100);
-	}	 
+            mTestConfigDir = oStr.str();
+            LLFile::mkdir(mTestConfigDir);
+            writeConfigFile(LLSD());
+            LLMessageConfig::initClass("simulator", mTestConfigDir);
+        }
+
+        ~LLMessageConfigTestData()
+        {
+            // rm contents of temp dir
+            int rmfile = LLFile::remove((mTestConfigDir + "/message.xml"));
+            ensure_equals("rmfile value", rmfile, 0);
+            // rm temp dir
+            int rmdir = LLFile::rmdir(mTestConfigDir);
+            ensure_equals("rmdir value", rmdir, 0);
+        }
+
+        void writeConfigFile(const LLSD& config)
+        {
+            llofstream file((mTestConfigDir + "/message.xml").c_str());
+            if (file.is_open())
+            {
+                LLSDSerialize::toPrettyXML(config, file);
+            }
+            file.close();
+        }
+    };
+
+    typedef test_group<LLMessageConfigTestData> LLMessageConfigTestGroup;
+    typedef LLMessageConfigTestGroup::object LLMessageConfigTestObject;
+    LLMessageConfigTestGroup llMessageConfigTestGroup("LLMessageConfig");
+
+    template<> template<>
+    void LLMessageConfigTestObject::test<1>()
+        // tests server defaults
+    {
+        LLSD config;
+        config["serverDefaults"]["simulator"] = "template";
+        LLMessageConfig::useConfig(config);
+        ensure_equals("Ensure server default is not template",
+                      LLMessageConfig::getServerDefaultFlavor(),
+                      LLMessageConfig::TEMPLATE_FLAVOR);
+    }
+
+    template<> template<>
+    void LLMessageConfigTestObject::test<2>()
+        // tests message flavors
+    {
+        LLSD config;
+        config["serverDefaults"]["simulator"] = "template";
+        config["messages"]["msg1"]["flavor"] = "template";
+        config["messages"]["msg2"]["flavor"] = "llsd";
+        LLMessageConfig::useConfig(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 flavor defaults
+    {
+        LLSD config;
+        config["serverDefaults"]["simulator"] = "llsd";
+        config["messages"]["msg1"]["trusted-sender"] = true;
+        LLMessageConfig::useConfig(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;
+        config["serverDefaults"]["simulator"] = "template";
+        config["messages"]["msg1"]["flavor"] = "llsd";
+        config["messages"]["msg1"]["trusted-sender"] = false;
+        config["messages"]["msg2"]["flavor"] = "llsd";
+        config["messages"]["msg2"]["trusted-sender"] = true;
+        LLMessageConfig::useConfig(config);
+        ensure_equals("Ensure untrusted is untrusted",
+                      LLMessageConfig::getSenderTrustedness("msg1"),
+                      LLMessageConfig::UNTRUSTED);
+        ensure_equals("Ensure trusted is trusted",
+                      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 flavor
+    {
+        LLSD config;
+        config["serverDefaults"]["simulator"] = "template";
+        config["messages"]["msg1"]["flavor"] = "llsd";
+        LLMessageConfig::useConfig(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>()
+    {
+        LLSD config;
+        config["capBans"]["MapLayer"] = true;
+        config["capBans"]["MapLayerGod"] = false;
+        LLMessageConfig::useConfig(config);
+        ensure_equals("Ensure cap ban true MapLayer",
+                      LLMessageConfig::isCapBanned("MapLayer"),
+                      true);
+        ensure_equals("Ensure cap ban false",
+                      LLMessageConfig::isCapBanned("MapLayerGod"),
+                      false);
+    }
+
+    template<> template<>
+    void LLMessageConfigTestObject::test<7>()
+        // tests that config changes are picked up/refreshed periodically
+    {
+        LLSD config;
+        config["serverDefaults"]["simulator"] = "llsd";
+        writeConfigFile(config);
+
+        // 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);
+    }
+
+    template<> template<>
+    void LLMessageConfigTestObject::test<8>()
+        // tests that config changes are picked up/refreshed periodically
+    {
+        LLSD config;
+        config["serverDefaults"]["simulator"] = "template";
+        config["messages"]["msg1"]["flavor"] = "llsd";
+        config["messages"]["msg1"]["only-send-latest"] = true;
+        config["messages"]["msg2"]["flavor"] = "llsd";
+        config["messages"]["msg2"]["only-send-latest"] = false;
+        LLMessageConfig::useConfig(config);
+        ensure_equals("Ensure msg1 exists, sent latest-only",
+                      LLMessageConfig::onlySendLatest("msg1"),
+                      true);
+        ensure_equals("Ensure msg2 exists, sent latest-only",
+                      LLMessageConfig::onlySendLatest("msg2"),
+                      false);
+    }
+
+    template<> template<>
+    void LLMessageConfigTestObject::test<9>()
+         // tests that event queue max is reloaded
+    {
+        LLSD config;
+        config["maxQueuedEvents"] = 200;
+        LLMessageConfig::useConfig(config);
+        ensure_equals("Ensure setting maxQueuedEvents",
+                      LLMessageConfig::getMaxQueuedEvents(),
+                      200);
+
+        LLMessageConfig::useConfig(LLSD());
+        ensure_equals("Ensure default of event queue max 100",
+                      LLMessageConfig::getMaxQueuedEvents(),
+                      100);
+    }
 }
diff --git a/indra/test/llmessagetemplateparser_tut.cpp b/indra/test/llmessagetemplateparser_tut.cpp
index 39f834a9fc..f665fdde4d 100644
--- a/indra/test/llmessagetemplateparser_tut.cpp
+++ b/indra/test/llmessagetemplateparser_tut.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llmessagetemplateparser_tut.cpp
  * @date April 2007
  * @brief LLMessageTemplateParser unit tests
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2006&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -31,338 +31,338 @@
 
 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 LLMessageStringTable::getInstance()->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 LL_ERRS() 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;
-	}
-
-	template<> template<> 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;
-	}
-
-	
+    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 LLMessageStringTable::getInstance()->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 LL_ERRS() 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;
+    }
+
+    template<> template<> 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
index e6ccd5ecb7..ebee89f9fa 100644
--- a/indra/test/llpermissions_tut.cpp
+++ b/indra/test/llpermissions_tut.cpp
@@ -7,25 +7,25 @@
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
- 
+
 #include <tut/tut.hpp>
 #include "linden_common.h"
 
@@ -37,455 +37,455 @@
 
 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()) && (! permissions.isOwned())));
-	}
-
-	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 ", ! 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) && (! is_group_owned))); 
-
-		perm.init(creator,LLUUID::null,lastOwner,group);
-		perm.getOwnership(uuid,is_group_owned);
-		ensure("3:getOwnership:failed ", ((uuid == group) && 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 ", 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 ", ! perm.setOwnerAndGroup(agent,owner2,group2,is_atomic));
-		
-		// should be able to change - agent and owner same as current owner
-		ensure("setOwnerAndGroup():failed ", 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 ", 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 ", perm.setBaseBits(agent, set, bits));
-		ensure("setOwnerBits():failed ", perm.setOwnerBits(agent, set, bits));
-
-		LLUUID agent1("9c8eca51-53d5-42a7-bb58-cef070395db8");
-		ensure("setBaseBits():failed ", ! perm.setBaseBits(agent1, set, bits));
-		ensure("setOwnerBits():failed ", ! 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 ", perm.setGroupBits(agent,group, set, bits));
-		ensure("setEveryoneBits():failed ", perm.setEveryoneBits(agent,group, set, bits));
-		ensure("setNextOwnerBits():failed ", perm.setNextOwnerBits(agent,group, set, bits));
-
-		LLUUID agent1("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");
-		ensure("setGroupBits():failed ", ! perm.setGroupBits(agent1,group, set, bits));
-		ensure("setEveryoneBits():failed ", ! perm.setEveryoneBits(agent1,group, set, bits));
-		ensure("setNextOwnerBits():failed ", ! perm.setNextOwnerBits(agent1,group, set, bits));
-	}
-
-	template<> template<>
-	void permission_object_t::test<13>()
-	{
-		LLPermissions perm;
-		LLUUID agent;
-		LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");		
-		U32 bits = 10;
-		ensure("allowOperationBy():failed ", perm.allowOperationBy(bits,agent,group));
-
-		LLUUID agent1("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");
-		LLUUID creator("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");	
-		LLUUID owner("68edcf47-ccd7-45b8-9f90-1649d7f12806"); 
-		LLUUID lastOwner("5e47a0dc-97bf-44e0-8b40-de06718cee9d"); 
-		perm.init(creator,owner,lastOwner,group);
-		ensure("allowOperationBy():failed ", 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 ", perm.allowModifyBy(agent));
-		ensure("2:allowModifyBy():failed ", perm.allowModifyBy(agent,group));
-				
-		LLUUID agent1("9c8eca51-53d5-42a7-bb58-cef070395db8"); 
-		ensure("3:allowModifyBy():failed ", perm.allowModifyBy(agent1));
-		ensure("4:allowModifyBy():failed ", 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 ", perm.allowModifyBy(agent));
-		ensure("2:allowCopyBy():failed ", perm.allowModifyBy(agent,group));
-				
-		LLUUID agent1("9c8eca51-53d5-42a7-bb58-cef070395db8"); 
-		ensure("3:allowCopyBy():failed ", perm.allowCopyBy(agent1));
-		ensure("4:allowCopyBy():failed ", 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 ", perm.allowMoveBy(agent));
-		ensure("2:allowMoveBy():failed ", perm.allowMoveBy(agent,group));
-
-		LLUUID agent1("9c8eca51-53d5-42a7-bb58-cef070395db8"); 
-		ensure("3:allowMoveBy():failed ", perm.allowMoveBy(agent1));
-		ensure("4:allowMoveBy():failed ", 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 ", perm.allowTransferTo(agent));
-		
-		perm.init(creator,owner,lastOwner,group);
-		ensure("2:allowMoveBy():failed ", perm.allowTransferTo(agent));
-	}
-
-	template<> template<>
-	void permission_object_t::test<18>()
-	{
-		LLPermissions perm,perm1;
-		ensure_equals("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_equals("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_not_equals("2:Operator==:failed ", perm, perm1);
-	}
-
-	template<> template<>
-	void permission_object_t::test<20>()
-	{
-		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_equals("exportStream()/importStream():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);
-		std::ostringstream stream1, stream2;
-		stream1 << perm;
-		perm1.init(creator,owner,lastOwner,group);
-		stream2 << perm1;
-		ensure_equals("1:operator << failed", stream1.str(), stream2.str());
-	}
-
-	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);
-		
-		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<23>()
-	{
-		LLAggregatePermissions AggrPermission;	
-		LLAggregatePermissions AggrPermission1;	
-		ensure_equals("getU8() function failed", AggrPermission.getU8(), 0);
-		ensure("isEmpty() function failed", AggrPermission.isEmpty());
-		AggrPermission.getValue(PERM_TRANSFER);
-		ensure_equals("getValue() function failed", AggrPermission.getValue(PERM_TRANSFER), 0x00);
-
-		AggrPermission.aggregate(PERM_ITEM_UNRESTRICTED);
-		ensure("aggregate() function failed", ! AggrPermission.isEmpty());
-
-		AggrPermission1.aggregate(AggrPermission);
-		ensure("aggregate() function failed", ! AggrPermission1.isEmpty());
-
-		std::ostringstream stream1;
-		stream1 << AggrPermission;
-		ensure_equals("operator<< failed", stream1.str(), "{PI_COPY=All, PI_MODIFY=All, PI_TRANSFER=All}");
-	}
+    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()) && (! permissions.isOwned())));
+    }
+
+    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 ", ! 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) && (! is_group_owned)));
+
+        perm.init(creator,LLUUID::null,lastOwner,group);
+        perm.getOwnership(uuid,is_group_owned);
+        ensure("3:getOwnership:failed ", ((uuid == group) && 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 ", 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 ", ! perm.setOwnerAndGroup(agent,owner2,group2,is_atomic));
+
+        // should be able to change - agent and owner same as current owner
+        ensure("setOwnerAndGroup():failed ", 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 ", 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 ", perm.setBaseBits(agent, set, bits));
+        ensure("setOwnerBits():failed ", perm.setOwnerBits(agent, set, bits));
+
+        LLUUID agent1("9c8eca51-53d5-42a7-bb58-cef070395db8");
+        ensure("setBaseBits():failed ", ! perm.setBaseBits(agent1, set, bits));
+        ensure("setOwnerBits():failed ", ! 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 ", perm.setGroupBits(agent,group, set, bits));
+        ensure("setEveryoneBits():failed ", perm.setEveryoneBits(agent,group, set, bits));
+        ensure("setNextOwnerBits():failed ", perm.setNextOwnerBits(agent,group, set, bits));
+
+        LLUUID agent1("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");
+        ensure("setGroupBits():failed ", ! perm.setGroupBits(agent1,group, set, bits));
+        ensure("setEveryoneBits():failed ", ! perm.setEveryoneBits(agent1,group, set, bits));
+        ensure("setNextOwnerBits():failed ", ! perm.setNextOwnerBits(agent1,group, set, bits));
+    }
+
+    template<> template<>
+    void permission_object_t::test<13>()
+    {
+        LLPermissions perm;
+        LLUUID agent;
+        LLUUID group("9c8eca51-53d5-42a7-bb58-cef070395db8");
+        U32 bits = 10;
+        ensure("allowOperationBy():failed ", perm.allowOperationBy(bits,agent,group));
+
+        LLUUID agent1("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");
+        LLUUID creator("abf0d56b-82e5-47a2-a8ad-74741bb2c29e");
+        LLUUID owner("68edcf47-ccd7-45b8-9f90-1649d7f12806");
+        LLUUID lastOwner("5e47a0dc-97bf-44e0-8b40-de06718cee9d");
+        perm.init(creator,owner,lastOwner,group);
+        ensure("allowOperationBy():failed ", 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 ", perm.allowModifyBy(agent));
+        ensure("2:allowModifyBy():failed ", perm.allowModifyBy(agent,group));
+
+        LLUUID agent1("9c8eca51-53d5-42a7-bb58-cef070395db8");
+        ensure("3:allowModifyBy():failed ", perm.allowModifyBy(agent1));
+        ensure("4:allowModifyBy():failed ", 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 ", perm.allowModifyBy(agent));
+        ensure("2:allowCopyBy():failed ", perm.allowModifyBy(agent,group));
+
+        LLUUID agent1("9c8eca51-53d5-42a7-bb58-cef070395db8");
+        ensure("3:allowCopyBy():failed ", perm.allowCopyBy(agent1));
+        ensure("4:allowCopyBy():failed ", 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 ", perm.allowMoveBy(agent));
+        ensure("2:allowMoveBy():failed ", perm.allowMoveBy(agent,group));
+
+        LLUUID agent1("9c8eca51-53d5-42a7-bb58-cef070395db8");
+        ensure("3:allowMoveBy():failed ", perm.allowMoveBy(agent1));
+        ensure("4:allowMoveBy():failed ", 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 ", perm.allowTransferTo(agent));
+
+        perm.init(creator,owner,lastOwner,group);
+        ensure("2:allowMoveBy():failed ", perm.allowTransferTo(agent));
+    }
+
+    template<> template<>
+    void permission_object_t::test<18>()
+    {
+        LLPermissions perm,perm1;
+        ensure_equals("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_equals("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_not_equals("2:Operator==:failed ", perm, perm1);
+    }
+
+    template<> template<>
+    void permission_object_t::test<20>()
+    {
+        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_equals("exportStream()/importStream():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);
+        std::ostringstream stream1, stream2;
+        stream1 << perm;
+        perm1.init(creator,owner,lastOwner,group);
+        stream2 << perm1;
+        ensure_equals("1:operator << failed", stream1.str(), stream2.str());
+    }
+
+    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);
+
+        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<23>()
+    {
+        LLAggregatePermissions AggrPermission;
+        LLAggregatePermissions AggrPermission1;
+        ensure_equals("getU8() function failed", AggrPermission.getU8(), 0);
+        ensure("isEmpty() function failed", AggrPermission.isEmpty());
+        AggrPermission.getValue(PERM_TRANSFER);
+        ensure_equals("getValue() function failed", AggrPermission.getValue(PERM_TRANSFER), 0x00);
+
+        AggrPermission.aggregate(PERM_ITEM_UNRESTRICTED);
+        ensure("aggregate() function failed", ! AggrPermission.isEmpty());
+
+        AggrPermission1.aggregate(AggrPermission);
+        ensure("aggregate() function failed", ! AggrPermission1.isEmpty());
+
+        std::ostringstream stream1;
+        stream1 << AggrPermission;
+        ensure_equals("operator<< failed", stream1.str(), "{PI_COPY=All, PI_MODIFY=All, PI_TRANSFER=All}");
+    }
 }
diff --git a/indra/test/llpipeutil.cpp b/indra/test/llpipeutil.cpp
index bb706b58d5..c64cf21326 100644
--- a/indra/test/llpipeutil.cpp
+++ b/indra/test/llpipeutil.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llpipeutil.cpp
  * @date 2006-05-18
  * @brief Utility pipe fittings for injecting and extracting strings
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2006&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -41,33 +41,33 @@
 
 F32 pump_loop(LLPumpIO* pump, F32 seconds)
 {
-	LLTimer timer;
-	timer.setTimerExpirySec(seconds);
-	while(!timer.hasExpired())
-	{
-		LLFrameTimer::updateFrameTime();			
-		pump->pump();
-		pump->callback();
-	}
-	return timer.getElapsedTimeF32();
+    LLTimer timer;
+    timer.setTimerExpirySec(seconds);
+    while(!timer.hasExpired())
+    {
+        LLFrameTimer::updateFrameTime();
+        pump->pump();
+        pump->callback();
+    }
+    return timer.getElapsedTimeF32();
 }
 
-//virtual 
+//virtual
 LLIOPipe::EStatus LLPipeStringInjector::process_impl(
-		const LLChannelDescriptors& channels,
-		buffer_ptr_t& buffer,
-		bool& eos,
-		LLSD& context,
-		LLPumpIO* pump)
+        const LLChannelDescriptors& channels,
+        buffer_ptr_t& buffer,
+        bool& eos,
+        LLSD& context,
+        LLPumpIO* pump)
 {
-	buffer->append(channels.out(), (U8*) mString.data(), mString.size());
-	eos = true;
-	return STATUS_DONE;
+    buffer->append(channels.out(), (U8*) mString.data(), mString.size());
+    eos = true;
+    return STATUS_DONE;
 }
 
 
 LLIOPipe::EStatus LLPipeStringExtractor::process_impl(
-	const LLChannelDescriptors& channels,
+    const LLChannelDescriptors& channels,
     buffer_ptr_t& buffer,
     bool& eos,
     LLSD& context,
@@ -76,108 +76,108 @@ LLIOPipe::EStatus LLPipeStringExtractor::process_impl(
     if(!eos) return STATUS_BREAK;
     if(!pump || !buffer) return STATUS_PRECONDITION_NOT_MET;
 
-	LLBufferStream istr(channels, buffer.get());
-	std::ostringstream ostr;
-	while (istr.good())
-	{
-		char buf[1024];		/* Flawfinder: ignore */
-		istr.read(buf, sizeof(buf));	/* Flawfinder: ignore */
-		ostr.write(buf, istr.gcount());
-	}
-	mString = ostr.str();
-	mDone = true;
-	
-	return STATUS_DONE;
+    LLBufferStream istr(channels, buffer.get());
+    std::ostringstream ostr;
+    while (istr.good())
+    {
+        char buf[1024];     /* Flawfinder: ignore */
+        istr.read(buf, sizeof(buf));    /* Flawfinder: ignore */
+        ostr.write(buf, istr.gcount());
+    }
+    mString = ostr.str();
+    mDone = true;
+
+    return STATUS_DONE;
 }
 
 
 // virtual
 LLIOPipe::EStatus LLIOFuzz::process_impl(
-	const LLChannelDescriptors& channels,
-	buffer_ptr_t& buffer,
-	bool& eos,
-	LLSD& context,
-	LLPumpIO* pump)
+    const LLChannelDescriptors& channels,
+    buffer_ptr_t& buffer,
+    bool& eos,
+    LLSD& context,
+    LLPumpIO* pump)
 {
-	while(mByteCount)
-	{
-		std::vector<U8> data;
-		data.reserve(10000);
-		int size = llmin(10000, mByteCount);
-		std::generate_n(
-			std::back_insert_iterator< std::vector<U8> >(data),
-			size,
-			rand);
-		buffer->append(channels.out(), &data[0], size);
-		mByteCount -= size;
-	}
-	return STATUS_OK;
+    while(mByteCount)
+    {
+        std::vector<U8> data;
+        data.reserve(10000);
+        int size = llmin(10000, mByteCount);
+        std::generate_n(
+            std::back_insert_iterator< std::vector<U8> >(data),
+            size,
+            rand);
+        buffer->append(channels.out(), &data[0], size);
+        mByteCount -= size;
+    }
+    return STATUS_OK;
 }
 
 struct random_ascii_generator
 {
-	random_ascii_generator() {}
-	U8 operator()()
-	{
-		int rv = rand();
-		rv %= (127 - 32);
-		rv += 32;
-		return rv;
-	}
+    random_ascii_generator() {}
+    U8 operator()()
+    {
+        int rv = rand();
+        rv %= (127 - 32);
+        rv += 32;
+        return rv;
+    }
 };
 
 // virtual
 LLIOPipe::EStatus LLIOASCIIFuzz::process_impl(
-	const LLChannelDescriptors& channels,
-	buffer_ptr_t& buffer,
-	bool& eos,
-	LLSD& context,
-	LLPumpIO* pump)
+    const LLChannelDescriptors& channels,
+    buffer_ptr_t& buffer,
+    bool& eos,
+    LLSD& context,
+    LLPumpIO* pump)
 {
-	while(mByteCount)
-	{
-		std::vector<U8> data;
-		data.reserve(10000);
-		int size = llmin(10000, mByteCount);
-		std::generate_n(
-			std::back_insert_iterator< std::vector<U8> >(data),
-			size,
-			random_ascii_generator());
-		buffer->append(channels.out(), &data[0], size);
-		mByteCount -= size;
-	}
-	return STATUS_OK;
+    while(mByteCount)
+    {
+        std::vector<U8> data;
+        data.reserve(10000);
+        int size = llmin(10000, mByteCount);
+        std::generate_n(
+            std::back_insert_iterator< std::vector<U8> >(data),
+            size,
+            random_ascii_generator());
+        buffer->append(channels.out(), &data[0], size);
+        mByteCount -= size;
+    }
+    return STATUS_OK;
 }
 
 // virtual
 LLIOPipe::EStatus LLIONull::process_impl(
-	const LLChannelDescriptors& channels,
-	buffer_ptr_t& buffer,
-	bool& eos,
-	LLSD& context,
-	LLPumpIO* pump)
+    const LLChannelDescriptors& channels,
+    buffer_ptr_t& buffer,
+    bool& eos,
+    LLSD& context,
+    LLPumpIO* pump)
 {
-	return STATUS_OK;
+    return STATUS_OK;
 }
 
 // virtual
 LLIOPipe::EStatus LLIOSleeper::process_impl(
-	const LLChannelDescriptors& channels,
-	buffer_ptr_t& buffer,
-	bool& eos,
-	LLSD& context,
-	LLPumpIO* pump)
+    const LLChannelDescriptors& channels,
+    buffer_ptr_t& buffer,
+    bool& eos,
+    LLSD& context,
+    LLPumpIO* pump)
 {
-	if(!mRespond)
-	{
-		LL_DEBUGS() << "LLIOSleeper::process_impl() sleeping." << LL_ENDL;
-		mRespond = true;
-		static const F64 SLEEP_TIME = 2.0;
-		pump->sleepChain(SLEEP_TIME);
-		return STATUS_BREAK;
-	}
-	LL_DEBUGS() << "LLIOSleeper::process_impl() responding." << LL_ENDL;
-	LLBufferStream ostr(channels, buffer.get());
-	ostr << "huh? sorry, I was sleeping." << std::endl;
-	return STATUS_DONE;
+    if(!mRespond)
+    {
+        LL_DEBUGS() << "LLIOSleeper::process_impl() sleeping." << LL_ENDL;
+        mRespond = true;
+        static const F64 SLEEP_TIME = 2.0;
+        pump->sleepChain(SLEEP_TIME);
+        return STATUS_BREAK;
+    }
+    LL_DEBUGS() << "LLIOSleeper::process_impl() responding." << LL_ENDL;
+    LLBufferStream ostr(channels, buffer.get());
+    ostr << "huh? sorry, I was sleeping." << std::endl;
+    return STATUS_DONE;
 }
diff --git a/indra/test/llpipeutil.h b/indra/test/llpipeutil.h
index 5deb26764f..97d9e1c85c 100644
--- a/indra/test/llpipeutil.h
+++ b/indra/test/llpipeutil.h
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llpipeutil.h
  * @date 2006-05-18
  * @brief Utility pipe fittings for injecting and extracting strings
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2006&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -43,34 +43,34 @@ F32 pump_loop(LLPumpIO* pump, F32 seconds);
 class LLPipeStringInjector : public LLIOPipe
 {
 public:
-	LLPipeStringInjector(const std::string& string)
-		: mString(string)
-		{ }
-	  
+    LLPipeStringInjector(const std::string& string)
+        : mString(string)
+        { }
+
 protected:
     virtual EStatus process_impl(
-		const LLChannelDescriptors& channels,
-		buffer_ptr_t& buffer,
-		bool& eos,
-		LLSD& context,
-		LLPumpIO* pump);
+        const LLChannelDescriptors& channels,
+        buffer_ptr_t& buffer,
+        bool& eos,
+        LLSD& context,
+        LLPumpIO* pump);
 
 private:
-	std::string mString;
+    std::string mString;
 };
 
 
 class LLPipeStringExtractor : public LLIOPipe
 {
 public:
-	LLPipeStringExtractor() : mDone(false) { }
-	
-	bool done() { return mDone; }
-	std::string string() { return mString; }
-	
+    LLPipeStringExtractor() : mDone(false) { }
+
+    bool done() { return mDone; }
+    std::string string() { return mString; }
+
 protected:
-	// LLIOPipe API implementation.
-	virtual EStatus process_impl(
+    // LLIOPipe API implementation.
+    virtual EStatus process_impl(
         const LLChannelDescriptors& channels,
         LLIOPipe::buffer_ptr_t& buffer,
         bool& eos,
@@ -78,8 +78,8 @@ protected:
         LLPumpIO* pump);
 
 private:
-	bool mDone;
-	std::string mString;
+    bool mDone;
+    std::string mString;
 };
 
 /**
@@ -88,18 +88,18 @@ private:
 class LLIOFuzz : public LLIOPipe
 {
 public:
-	LLIOFuzz(int byte_count) : mByteCount(byte_count) {}
-	  
+    LLIOFuzz(int byte_count) : mByteCount(byte_count) {}
+
 protected:
     virtual EStatus process_impl(
-		const LLChannelDescriptors& channels,
-		buffer_ptr_t& buffer,
-		bool& eos,
-		LLSD& context,
-		LLPumpIO* pump);
+        const LLChannelDescriptors& channels,
+        buffer_ptr_t& buffer,
+        bool& eos,
+        LLSD& context,
+        LLPumpIO* pump);
 
 private:
-	int mByteCount;
+    int mByteCount;
 };
 
 /**
@@ -108,18 +108,18 @@ private:
 class LLIOASCIIFuzz : public LLIOPipe
 {
 public:
-	LLIOASCIIFuzz(int byte_count) : mByteCount(byte_count) {}
-	  
+    LLIOASCIIFuzz(int byte_count) : mByteCount(byte_count) {}
+
 protected:
     virtual EStatus process_impl(
-		const LLChannelDescriptors& channels,
-		buffer_ptr_t& buffer,
-		bool& eos,
-		LLSD& context,
-		LLPumpIO* pump);
+        const LLChannelDescriptors& channels,
+        buffer_ptr_t& buffer,
+        bool& eos,
+        LLSD& context,
+        LLPumpIO* pump);
 
 private:
-	int mByteCount;
+    int mByteCount;
 };
 
 
@@ -129,15 +129,15 @@ private:
 class LLIONull : public LLIOPipe
 {
 public:
-	LLIONull() {}
-	  
+    LLIONull() {}
+
 protected:
     virtual EStatus process_impl(
-		const LLChannelDescriptors& channels,
-		buffer_ptr_t& buffer,
-		bool& eos,
-		LLSD& context,
-		LLPumpIO* pump);
+        const LLChannelDescriptors& channels,
+        buffer_ptr_t& buffer,
+        bool& eos,
+        LLSD& context,
+        LLPumpIO* pump);
 };
 
 /**
@@ -146,17 +146,17 @@ protected:
 class LLIOSleeper : public LLIOPipe
 {
 public:
-	LLIOSleeper() : mRespond(false) {}
-	  
+    LLIOSleeper() : mRespond(false) {}
+
 protected:
     virtual EStatus process_impl(
-		const LLChannelDescriptors& channels,
-		buffer_ptr_t& buffer,
-		bool& eos,
-		LLSD& context,
-		LLPumpIO* pump);
+        const LLChannelDescriptors& channels,
+        buffer_ptr_t& buffer,
+        bool& eos,
+        LLSD& context,
+        LLPumpIO* pump);
 private:
-	bool mRespond;
+    bool mRespond;
 
 };
 
diff --git a/indra/test/llsaleinfo_tut.cpp b/indra/test/llsaleinfo_tut.cpp
index b7b207610f..1a4ead00b6 100644
--- a/indra/test/llsaleinfo_tut.cpp
+++ b/indra/test/llsaleinfo_tut.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file LLSaleInfo_tut.cpp
  * @author Adroit
  * @date 2007-03
@@ -7,21 +7,21 @@
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -33,162 +33,162 @@
 
 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);
-		const 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>()
-	{
-		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("importStream() fn failed ",
-			llsaleinfo.getSalePrice() == llsaleinfo1.getSalePrice() &&
-										       llsaleinfo.getSaleType() == llsaleinfo1.getSaleType());		
-	}
-
-	template<> template<>
-	void llsaleinfo_test_t::test<3>()
-	{	
-		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<4>()
-	{
-		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<5>()
-	{
-		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<6>()
-	{
-		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<7>()
-	{
-
-		//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)
-	}
+    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);
+        const 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>()
+    {
+        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("importStream() fn failed ",
+            llsaleinfo.getSalePrice() == llsaleinfo1.getSalePrice() &&
+                                               llsaleinfo.getSaleType() == llsaleinfo1.getSaleType());
+    }
+
+    template<> template<>
+    void llsaleinfo_test_t::test<3>()
+    {
+        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<4>()
+    {
+        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<5>()
+    {
+        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<6>()
+    {
+        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<7>()
+    {
+
+        //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/llsd_new_tut.cpp b/indra/test/llsd_new_tut.cpp
index 458df3361e..cc084df045 100644
--- a/indra/test/llsd_new_tut.cpp
+++ b/indra/test/llsd_new_tut.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llsd_new_tut.cpp
  * @date   February 2006
  * @brief LLSD unit tests
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2006&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2006-2011, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -37,794 +37,794 @@ using std::fpclassify;
 
 namespace tut
 {
-	class SDCleanupCheck
-	{
-	private:
-		U32	mOutstandingAtStart;
-	public:
-		SDCleanupCheck() : mOutstandingAtStart(llsd::outstandingCount()) { }
-		~SDCleanupCheck()
-		{
-			ensure_equals("SDCleanupCheck",
-				llsd::outstandingCount(), mOutstandingAtStart);
-		}
-	};
-
-	class SDAllocationCheck : public SDCleanupCheck
-	{
-	private:
-		std::string mMessage;
-		U32 mExpectedAllocations;
-		U32 mAllocationAtStart;
-	public:
-		SDAllocationCheck(const std::string& message, int expectedAllocations)
-			: mMessage(message),
-			mExpectedAllocations(expectedAllocations),
-			mAllocationAtStart(llsd::allocationCount())
-			{ }
-		~SDAllocationCheck()
-		{
-			ensure_equals(mMessage + " SDAllocationCheck",
-				llsd::allocationCount() - mAllocationAtStart,
-				mExpectedAllocations);
-		}
-	};
-	
-	struct SDTestData {
-		template<class T>
-		static void ensureTypeAndValue(const char* msg, const LLSD& actual,
-			T expectedValue)
-		{
-			LLSDTraits<T> traits;
-			
-			std::string s(msg);
-			
-			ensure(			s + " type",	traits.checkType(actual));
-			ensure_equals(	s + " value",	traits.get(actual), expectedValue);
-		}
-
-		template<class T>
-		static void ensureTypeAndRefValue(const char* msg, const LLSD& actual,
-			const T& expectedValue)
-		{
-			LLSDTraits<const T&> traits;
-			
-			std::string s(msg);
-			
-			ensure(			s + " type",	traits.checkType(actual));
-			ensure_equals(	s + " value",	traits.get(actual), expectedValue);
-		}
-	};
-	
-	typedef test_group<SDTestData>	SDTestGroup;
-	typedef SDTestGroup::object		SDTestObject;
-
-	SDTestGroup sdTestGroup("LLSD(new)");
-	
-	// template<> template<>
-	// void SDTestObject::test<1>()
-	// 	// construction and test of undefined
-	// {
-	// 	SDCleanupCheck check;
-		
-	// 	LLSD u;
-	// 	ensure("is undefined", u.isUndefined());
-	// }
-	
-	template<> template<>
-	void SDTestObject::test<2>()
-		// setting and fetching scalar types
-	{
-		SDCleanupCheck check;
-		
-		LLSD v;
-
-		v = true;		ensureTypeAndValue("set true", v, true);
-		v = false;		ensureTypeAndValue("set false", v, false);
-		v = true;		ensureTypeAndValue("set true again", v, true);
-		
-		v = 42;			ensureTypeAndValue("set to 42", v, 42);
-		v = 0;			ensureTypeAndValue("set to zero", v, 0);
-		v = -12345;		ensureTypeAndValue("set to neg", v, -12345);
-		v = 2000000000;	ensureTypeAndValue("set to big", v, 2000000000);
-		
-		v = 3.14159265359;
-						ensureTypeAndValue("set to pi", v, 3.14159265359);
-						ensure_not_equals("isn't float", v.asReal(),
-							(float)3.14159265359);
-		v = 6.7e256;	ensureTypeAndValue("set to big", v, 6.7e256);
-		
-		LLUUID nullUUID;
-		LLUUID newUUID;
-		newUUID.generate();
-		
-		v = nullUUID;	ensureTypeAndValue("set to null UUID", v, nullUUID);
-		v = newUUID;	ensureTypeAndValue("set to new UUID", v, newUUID);
-		v = nullUUID;	ensureTypeAndValue("set to null again", v, nullUUID);
-		
-		// strings must be tested with two types of string objects
-		std::string s = "now is the time";
-		const char* cs = "for all good zorks";
-
-		v = s;			ensureTypeAndValue("set to std::string", v, s);		
-		v = cs;			ensureTypeAndValue("set to const char*", v, cs);
-	
-		LLDate epoch;
-		LLDate aDay("2001-10-22T10:11:12.00Z");
-		
-		v = epoch;		ensureTypeAndValue("set to epoch", v, epoch);
-		v = aDay;		ensureTypeAndValue("set to a day", v, aDay);
-		
-		LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/");
-		
-		v = path;		ensureTypeAndValue("set to a uri", v, path);
-		
-		const char source[] = "once in a blue moon";
-		std::vector<U8> data;
-		copy(&source[0], &source[sizeof(source)], back_inserter(data));
-		
-		v = data;		ensureTypeAndRefValue("set to data", v, data);
-		
-		v.clear();
-		ensure("reset to undefined", v.type() == LLSD::TypeUndefined);
-	}
-	
-	template<> template<>
-	void SDTestObject::test<3>()
-		// construction via scalar values
-		// tests both constructor and initialize forms
-	{
-		SDCleanupCheck check;
-		
-		LLSD b1(true);	ensureTypeAndValue("construct boolean", b1, true);
-		LLSD b2 = true;	ensureTypeAndValue("initialize  boolean", b2, true);
-		LLSD i1(42);	ensureTypeAndValue("construct int", i1, 42);
-		LLSD i2 =42;	ensureTypeAndValue("initialize  int", i2, 42);
-		LLSD d1(1.2);	ensureTypeAndValue("construct double", d1, 1.2);
-		LLSD d2 = 1.2;	ensureTypeAndValue("initialize double", d2, 1.2);
-		
-		LLUUID newUUID;
-		newUUID.generate();
-		LLSD u1(newUUID);
-						ensureTypeAndValue("construct UUID", u1, newUUID);
-		LLSD u2 = newUUID;
-						ensureTypeAndValue("initialize UUID", u2, newUUID);
-		
-		LLSD ss1(std::string("abc"));
-						ensureTypeAndValue("construct std::string", ss1, "abc");
-		LLSD ss2 = std::string("abc");
-						ensureTypeAndValue("initialize std::string",ss2, "abc");
-		LLSD sl1(std::string("def"));
-						ensureTypeAndValue("construct std::string", sl1, "def");
-		LLSD sl2 = std::string("def");
-						ensureTypeAndValue("initialize std::string", sl2, "def");
-		LLSD sc1("ghi");
-						ensureTypeAndValue("construct const char*", sc1, "ghi");
-		LLSD sc2 = "ghi";
-						ensureTypeAndValue("initialize const char*",sc2, "ghi");
-
-		LLDate aDay("2001-10-22T10:11:12.00Z");
-		LLSD t1(aDay);	ensureTypeAndValue("construct LLDate", t1, aDay);
-		LLSD t2 = aDay;	ensureTypeAndValue("initialize LLDate", t2, aDay);
-
-		LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/");
-		LLSD p1(path);	ensureTypeAndValue("construct LLURI", p1, path);
-		LLSD p2 = path;	ensureTypeAndValue("initialize LLURI", p2, path);
-
-		const char source[] = "once in a blue moon";
-		std::vector<U8> data;
-		copy(&source[0], &source[sizeof(source)], back_inserter(data));
-		LLSD x1(data);	ensureTypeAndRefValue("construct vector<U8>", x1, data);
-		LLSD x2 = data;	ensureTypeAndRefValue("initialize vector<U8>", x2, data);
-	}
-	
-	void checkConversions(const char* msg, const LLSD& v,
-		LLSD::Boolean eBoolean, LLSD::Integer eInteger,
-		LLSD::Real eReal, const LLSD::String& eString)
-	{
-		std::string s(msg);
-		
-		ensure_equals(s+" to bool",	v.asBoolean(),	eBoolean);
-		ensure_equals(s+" to int",	v.asInteger(),	eInteger);
-		if (eReal == eReal)
-		{
-			ensure_equals(s+" to real",	v.asReal(),		eReal);
-			ensure_equals(s+" to string",	v.asString(),	eString);
-		}
-		else
-		{
-			int left  = fpclassify(v.asReal());
-			int right = fpclassify(eReal);
-
-			ensure_equals(s+" to real", 	left, 			right);
-			// ensure_equals(s+" to string", v.asString(), eString);
-			// I've commented this check out, since there doesn't
-			// seem to be uniform string representation for NaN on
-			// all platforms. For example, on my Ubuntu 8.10 laptop
-			// with libc 2.11.1, sqrt(-1.0) will return '-nan', not
-			// 'nan'.
-		}
-	}
-	
-	template<> template<>
-	void SDTestObject::test<4>()
-		// conversion between undefined and basic scalar types:
-		//	boolean, integer, real and string
-	{
-		SDCleanupCheck check;
-		
-		LLSD v;			checkConversions("untitled", v, false, 0, 0.0, "");
-		
-		v = false;		checkConversions("false", v, false, 0, 0.0, "");
-		v = true;		checkConversions("true", v, true, 1, 1.0, "true");
-		
-		v = 0;			checkConversions("zero", v, false, 0, 0.0, "0");
-		v = 1;			checkConversions("one", v, true, 1, 1.0, "1");
-		v = -33;		checkConversions("neg33", v, true, -33, -33.0, "-33");
-		
-		v = 0.0;		checkConversions("0.0", v, false, 0, 0.0, "0");
-		v = 0.5;		checkConversions("point5", v, true, 0, 0.5, "0.5");
-		v = 0.9;		checkConversions("point9", v, true, 0, 0.9, "0.9");
-		v = -3.9;		checkConversions("neg3dot9", v, true, -3, -3.9, "-3.9");
-		// Get rid of NaN test. First, some libraries don't reliably return
-		// NaN for sqrt(-1.0) -- meaning that I don't even know how to
-		// portably, reliably produce a NaN value. Second, we observe failures
-		// on different platforms in the asString() test. But LLSD's
-		// ImplReal::asString() does not itself recognize NaN! It merely
-		// passes the value through to llformat(), which passes it through to
-		// the library vsnprintf(). That is, even when we do produce NaN,
-		// we're not testing any LLSD code: we're testing the local library's
-		// vsnprintf() function, which (empirically) produces idiosyncratic
-		// results. This is just not a good test case.
-//		v = sqrt(-1.0);	checkConversions("NaN", v, false, 0, sqrt(-1.0), "nan");
-
-		v = "";			checkConversions("empty", v, false, 0, 0.0, "");
-		v = "0";		checkConversions("digit0", v, true, 0, 0.0, "0");
-		v = "10";		checkConversions("digit10", v, true, 10, 10.0, "10");
-		v = "-2.345";	checkConversions("decdigits", v,
-							true, -2, -2.345, "-2.345");
-		v = "apple";	checkConversions("apple", v, true, 0, 0.0, "apple");
-		v = "33bob";	checkConversions("digialpha", v, true, 0, 0.0, "33bob");
-		v = " ";		checkConversions("space", v, true, 0, 0.0, " ");
-		v = "\n";		checkConversions("newline", v, true, 0, 0.0, "\n");
-	}
-	
-	template<class T>
-	void checkRoundTrip(const std::string& msg, const LLSD& actual,
-		const char* sExpected, T vExpected)
-	{
-		std::string str = actual.asString();
-		
-		if (sExpected) {
-			ensure_equals(msg + " string", str, sExpected);
-		}
-		
-		LLSD u(str);
-		LLSDTraits<T> traits;
-		
-		ensure_equals(msg + " value", traits.get(u), vExpected);
-	}
-	
-	
-	template<> template<>
-	void SDTestObject::test<5>()
-		// conversion of String to and from UUID, Date and URI.
-	{
-		SDCleanupCheck check;
-		
-		LLSD v;
-		
-		LLUUID nullUUID;
-		LLUUID someUUID;
-		someUUID.generate();
-		
-		v = nullUUID;	checkRoundTrip("null uuid", v,
-							"00000000-0000-0000-0000-000000000000", nullUUID);
-		v = someUUID;	checkRoundTrip("random uuid", v, 0, someUUID);
-		
-		LLDate epoch;
-		LLDate beta("2003-04-30T04:00:00Z");
-		LLDate oneOh("2003-06-23T04:00:00Z");
-		
-		v = epoch;		checkRoundTrip("epoch date", v, 0, epoch);
-		v = beta;		checkRoundTrip("beta date", v,
-							"2003-04-30T04:00:00Z", beta);
-		v = oneOh;		checkRoundTrip("1.0 date", v,
-							"2003-06-23T04:00:00Z", oneOh);
-		
-		LLURI empty;
-		LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/");
-		LLURI mail("mailto:zero.linden@secondlife.com");
-		
-		v = empty;		checkRoundTrip("empty URI", v, 0, empty);
-		v = path;		checkRoundTrip("path URI", v,
-							"http://slurl.com/secondlife/Ambleside/57/104/26/",
-							path);
-		v = mail;		checkRoundTrip("mail URI", v,
-							"mailto:zero.linden@secondlife.com", mail);
-	}
-	
-	template<> template<>
-	void SDTestObject::test<6>()
-		// copy construction and assignment
-		// checking for shared values after constr. or assignment
-		// checking in both the same type and change of type case
-	{
-		SDCleanupCheck check;
-		
-		{
-			LLSD v = 42;
-		
-			LLSD w0(v);
-			ensureTypeAndValue("int constr.", w0, 42);
-			
-			LLSD w1(v);
-			w1 = 13;
-			ensureTypeAndValue("int constr. change case 1", w1, 13);
-			ensureTypeAndValue("int constr. change case 2", v, 42);
-			
-			LLSD w2(v);
-			v = 7;
-			ensureTypeAndValue("int constr. change case 3", w2, 42);
-			ensureTypeAndValue("int constr. change case 4", v, 7);
-		}
-
-		{
-			LLSD v = 42;
-		
-			LLSD w1(v);
-			w1 = "bob";
-			ensureTypeAndValue("string constr. change case 1", w1, "bob");
-			ensureTypeAndValue("string constr. change case 2", v, 42);
-			
-			LLSD w2(v);
-			v = "amy";
-			ensureTypeAndValue("string constr. change case 3", w2, 42);
-			ensureTypeAndValue("string constr. change case 4", v, "amy");
-		}
-
-		{
-			LLSD v = 42;
-		
-			LLSD w0;
-			w0 = v;
-			ensureTypeAndValue("int assign", w0, 42);
-			
-			LLSD w1;
-			w1 = v;
-			w1 = 13;
-			ensureTypeAndValue("int assign change case 1", w1, 13);
-			ensureTypeAndValue("int assign change case 2", v, 42);
-			
-			LLSD w2;
-			w2 = v;
-			v = 7;
-			ensureTypeAndValue("int assign change case 3", w2, 42);
-			ensureTypeAndValue("int assign change case 4", v, 7);
-		}
-
-		{
-			LLSD v = 42;
-		
-			LLSD w1;
-			w1 = v;
-			w1 = "bob";
-			ensureTypeAndValue("string assign change case 1", w1, "bob");
-			ensureTypeAndValue("string assign change case 2", v, 42);
-			
-			LLSD w2;
-			w2 = v;
-			v = "amy";
-			ensureTypeAndValue("string assign change case 3", w2, 42);
-			ensureTypeAndValue("string assign change case 4", v, "amy");
-		}
-	}
-	
-	
-	template<> template<>
-	void SDTestObject::test<7>()
-		// Test assignment and casting to various scalar types.  These
-		// assignments should invoke the right conversion without it being
-		// mentioned explicitly.  The few exceptions are marked SAD.
-	{
-		SDCleanupCheck check;
-		
-		LLSD v("  42.375");
-		
-		bool b = false;
-		b = v;				ensure_equals("assign to bool", b, true);
-		b = (bool)v;		ensure_equals("cast to bool", b, true);
-		
-		int i = 99;
-		i = v;				ensure_equals("assign to int", i, 42);
-		i = (int)v;			ensure_equals("cast to int", i, 42);
-		
-		double d = 3.14159;
-		d = v;				ensure_equals("assign to double", d, 42.375);
-		d = (double)v;		ensure_equals("cast to double", d, 42.375);
-		
-		std::string s = "yo";
-// SAD	s = v;				ensure_equals("assign to string", s, "  42.375");
-		s = (std::string)v;	ensure_equals("cast to string", s, "  42.375");
-
-		std::string uuidStr = "b1e50c2b-b627-4d23-8a86-a65d97b6319b";
-		v = uuidStr;
-		LLUUID u;
-		u = v;
-					ensure_equals("assign to LLUUID", u, LLUUID(uuidStr));
-// SAD	u = (LLUUID)v;
-//					ensure_equals("cast to LLUUID", u, LLUUID(uuidStr));
-		
-		std::string dateStr = "2005-10-24T15:00:00Z";
-		v = dateStr;
-		LLDate date;
-		date = v;
-					ensure_equals("assign to LLDate", date.asString(), dateStr);
-// SAD	date = (LLDate)v;
-//					ensure_equals("cast to LLDate", date.asString(), dateStr);
-		
-		std::string uriStr = "http://secondlife.com";
-		v = uriStr;
-		LLURI uri;
-		uri = v;
-					ensure_equals("assign to LLURI", uri.asString(), uriStr);
-// SAD 	uri = (LLURI)v;
-//					ensure_equals("cast to LLURI", uri.asString(), uriStr);
-	}
-	
-	template<> template<>
-	void SDTestObject::test<8>()
-		// Test construction of various scalar types from LLSD.
-		// Test both construction and initialization forms.
-		// These should invoke the right conversion without it being
-		// mentioned explicitly.  The few exceptions are marked SAD.
-	{
-		SDCleanupCheck check;
-		
-		LLSD v("  42.375");
-		
-		bool b1(v);		ensure_equals("contruct bool", b1, true);
-		bool b2 = v;	ensure_equals("initialize bool", b2, true);
-				
-		int i1(v);		ensure_equals("contruct int", i1, 42);
-		int i2 = v;		ensure_equals("initialize int", i2, 42);
-		
-		double d1(v);	ensure_equals("contruct double", d1, 42.375);
-		double d2 = v;	ensure_equals("initialize double", d2, 42.375);
-		
-		std::string s1(v);
-		std::string s2 = v;
-						ensure_equals("contruct string", s1, "  42.375");
-						ensure_equals("initialize string", s2, "  42.375");
-
-		std::string t1(v);
-		std::string t2 = v.asString();		// SAD
-						ensure_equals("contruct std::string", t1, "  42.375");
-						ensure_equals("initialize std::string", t2, "  42.375");
-
-		std::string uuidStr = "b1e50c2b-b627-4d23-8a86-a65d97b6319b";
-		v = uuidStr;
-		LLUUID uuid1(v.asUUID());		// SAD
-		LLUUID uuid2 = v;
-				ensure_equals("contruct LLUUID", uuid1, LLUUID(uuidStr));
-				ensure_equals("initialize LLUUID", uuid2, LLUUID(uuidStr));
-
-		std::string dateStr = "2005-10-24T15:00:00Z";
-		v = dateStr;
-		LLDate date1(v.asDate());		// SAD
-		LLDate date2 = v;
-				ensure_equals("contruct LLDate", date1.asString(), dateStr);
-				ensure_equals("initialize LLDate", date2.asString(), dateStr);
-				
-		std::string uriStr = "http://secondlife.com";
-		v = uriStr;
-		LLURI uri1(v.asURI());			// SAD
-		LLURI uri2 = v;
-				ensure_equals("contruct LLURI", uri1.asString(), uriStr);
-				ensure_equals("initialize LLURI", uri2.asString(), uriStr);
-	}
-	
-	
-	template<> template<>
-	void SDTestObject::test<9>()
-		// test to make sure v is interpreted as a bool in a various
-		// scenarios.
-	{
-		SDCleanupCheck check;
-		
-		LLSD v = "0";
-		// magic value that is interpreted as boolean true, but integer false!
-		
-		ensure_equals("trinary operator bool", (v ? true : false), true);
-		ensure_equals("convert to int, then bool",
-											((int)v ? true : false), false);
-
-		if(v)
-		{
-			ensure("if converted to bool", true);
-		}
-		else
-		{
-			fail("bool did not convert to a bool in if statement.");
-		}
-
-		if(!v)
-		{
-			fail("bool did not convert to a bool in negated if statement.");
-		}
-	}
-	
-	template<> template<>
-	void SDTestObject::test<10>()
-		// map operations
-	{
-		SDCleanupCheck check;
-		
-		LLSD v;
-		ensure("undefined has no members", !v.has("amy"));
-		ensure("undefined get() is undefined", v.get("bob").isUndefined());
-		
-		v = LLSD::emptyMap();
-		ensure("empty map is a map", v.isMap());
-		ensure("empty map has no members", !v.has("cam"));
-		ensure("empty map get() is undefined", v.get("don").isUndefined());
-		
-		v.clear();
-		v.insert("eli", 43);
-		ensure("insert converts to map", v.isMap());
-		ensure("inserted key is present", v.has("eli"));
-		ensureTypeAndValue("inserted value", v.get("eli"), 43);
-		
-		v.insert("fra", false);
-		ensure("first key still present", v.has("eli"));
-		ensure("second key is present", v.has("fra"));
-		ensureTypeAndValue("first value", v.get("eli"), 43);
-		ensureTypeAndValue("second value", v.get("fra"), false);
-		
-		v.erase("eli");
-		ensure("first key now gone", !v.has("eli"));
-		ensure("second key still present", v.has("fra"));
-		ensure("first value gone", v.get("eli").isUndefined());
-		ensureTypeAndValue("second value sill there", v.get("fra"), false);
-		
-		v.erase("fra");
-		ensure("second key now gone", !v.has("fra"));
-		ensure("second value gone", v.get("fra").isUndefined());
-		
-		v["gil"] = (std::string)"good morning";
-		ensure("third key present", v.has("gil"));
-		ensureTypeAndValue("third key value", v.get("gil"), "good morning");
-		
-		const LLSD& cv = v;	// FIX ME IF POSSIBLE
-		ensure("missing key", cv["ham"].isUndefined());
-		ensure("key not present", !v.has("ham"));
-	
-		LLSD w = 43;
-		const LLSD& cw = w;	// FIX ME IF POSSIBLE
-		int i = cw["ian"];
-		ensureTypeAndValue("other missing value", i, 0);
-		ensure("other missing key", !w.has("ian"));
-		ensure("no conversion", w.isInteger());
-		
-		LLSD x;
-		x = v;
-		ensure("copy map type", x.isMap());
-		ensureTypeAndValue("copy map value gil", x.get("gil"), "good morning");
-	}
-	
-	
-	template<> template<>
-	void SDTestObject::test<11>()
-		// array operations
-	{
-		SDCleanupCheck check;
-		
-		LLSD v;
-		ensure_equals("undefined has no size", v.size(), 0);
-		ensure("undefined get() is undefined", v.get(0).isUndefined());
-		
-		v = LLSD::emptyArray();
-		ensure("empty array is an array", v.isArray());
-		ensure_equals("empty array has no size", v.size(), 0);
-		ensure("empty map get() is undefined", v.get(0).isUndefined());
-		
-		v.clear();
-		v.append(88);
-		v.append("noodle");
-		v.append(true);
-		ensure_equals("appened array size", v.size(), 3);
-		ensure("append array is an array", v.isArray());
-		ensureTypeAndValue("append 0", v[0], 88);
-		ensureTypeAndValue("append 1", v[1], "noodle");
-		ensureTypeAndValue("append 2", v[2], true);
-		
-		v.insert(0, 77);
-		v.insert(2, "soba");
-		v.insert(4, false);
-		ensure_equals("inserted array size", v.size(), 6);
-		ensureTypeAndValue("post insert 0", v[0], 77);
-		ensureTypeAndValue("post insert 1", v[1], 88);
-		ensureTypeAndValue("post insert 2", v[2], "soba");
-		ensureTypeAndValue("post insert 3", v[3], "noodle");
-		ensureTypeAndValue("post insert 4", v[4], false);
-		ensureTypeAndValue("post insert 5", v[5], true);
-		
-		ensureTypeAndValue("get 1", v.get(1), 88);
-		v.set(1, "hot");
-		ensureTypeAndValue("set 1", v.get(1), "hot");
-		
-		v.erase(3);
-		ensure_equals("post erase array size", v.size(), 5);
-		ensureTypeAndValue("post erase 0", v[0], 77);
-		ensureTypeAndValue("post erase 1", v[1], "hot");
-		ensureTypeAndValue("post erase 2", v[2], "soba");
-		ensureTypeAndValue("post erase 3", v[3], false);
-		ensureTypeAndValue("post erase 4", v[4], true);
-		
-		v.append(34);
-		ensure_equals("size after append", v.size(), 6);
-		ensureTypeAndValue("post append 5", v[5], 34);
-
-		LLSD w;
-		w = v;
-		ensure("copy array type", w.isArray());
-		ensure_equals("copy array size", w.size(), 6);
-		ensureTypeAndValue("copy array 0", w[0], 77);
-		ensureTypeAndValue("copy array 1", w[1], "hot");
-		ensureTypeAndValue("copy array 2", w[2], "soba");
-		ensureTypeAndValue("copy array 3", w[3], false);
-		ensureTypeAndValue("copy array 4", w[4], true);
-		ensureTypeAndValue("copy array 5", w[5], 34);
-	}
-
-
-	template<> template<>
-	void SDTestObject::test<12>()
-		// no sharing
-	{
-		SDCleanupCheck check;
-		
-		LLSD a = 99;
-		LLSD b = a;
-		a = 34;
-		ensureTypeAndValue("top level original changed",	a, 34);
-		ensureTypeAndValue("top level copy unaltered",		b, 99);
-		b = a;
-		b = 66;
-		ensureTypeAndValue("top level original unaltered",	a, 34);
-		ensureTypeAndValue("top level copy changed",		b, 66);
-
-		a[0] = "uno";
-		a[1] = 99;
-		a[2] = 1.414;
-		b = a;
-		a[1] = 34;
-		ensureTypeAndValue("array member original changed",	a[1], 34);
-		ensureTypeAndValue("array member copy unaltered",	b[1], 99);
-		b = a;
-		b[1] = 66;
-		ensureTypeAndValue("array member original unaltered", a[1], 34);
-		ensureTypeAndValue("array member copy changed",		b[1], 66);
-		
-		a["alpha"] = "uno";
-		a["beta"] = 99;
-		a["gamma"] = 1.414;
-		b = a;
-		a["beta"] = 34;
-		ensureTypeAndValue("map member original changed",	a["beta"], 34);
-		ensureTypeAndValue("map member copy unaltered",		b["beta"], 99);
-		b = a;
-		b["beta"] = 66;
-		ensureTypeAndValue("map member original unaltered",	a["beta"], 34);
-		ensureTypeAndValue("map member copy changed",		b["beta"], 66);
-	}
-	
-	template<> template<>
-	void SDTestObject::test<13>()
-		// sharing implementation
-	{
-		SDCleanupCheck check;
-		
-		{
-			SDAllocationCheck check("copy construct undefinded", 0);
-			LLSD v;
-			LLSD w = v;
-		}
-		
-		{
-			SDAllocationCheck check("assign undefined", 0);
-			LLSD v;
-			LLSD w;
-			w = v;
-		}
-		
-		{
-			SDAllocationCheck check("assign integer value", 1);
-			LLSD v = 45;
-			v = 33;
-			v = 0;
-		}
-
-		{
-			SDAllocationCheck check("copy construct integer", 1);
-			LLSD v = 45;
-			LLSD w = v;
-		}
-
-		{
-			SDAllocationCheck check("assign integer", 1);
-			LLSD v = 45;
-			LLSD w;
-			w = v;
-		}
-		
-		{
-			SDAllocationCheck check("avoids extra clone", 2);
-			LLSD v = 45;
-			LLSD w = v;
-			w = "nice day";
-		}
-
-		{
-			SDAllocationCheck check("shared values test for threaded work", 9);
-
-			//U32 start_llsd_count = LLSD::outstandingCount();
-
-			LLSD m = LLSD::emptyMap();
-
-			m["one"] = 1;
-			m["two"] = 2;
-			m["one_copy"] = m["one"];			// 3 (m, "one" and "two")
-
-			m["undef_one"] = LLSD();
-			m["undef_two"] = LLSD();
-			m["undef_one_copy"] = m["undef_one"];
-
-			{	// Ensure first_array gets freed to avoid counting it
-				LLSD first_array = LLSD::emptyArray();
-				first_array.append(1.0f);
-				first_array.append(2.0f);			
-				first_array.append(3.0f);			// 7
-
-				m["array"] = first_array;
-				m["array_clone"] = first_array;
-				m["array_copy"] = m["array"];		// 7
-			}
-
-			m["string_one"] = "string one value";
-			m["string_two"] = "string two value";
-			m["string_one_copy"] = m["string_one"];		// 9
-
-			//U32 llsd_object_count = LLSD::outstandingCount();
-			//std::cout << "Using " << (llsd_object_count - start_llsd_count) << " LLSD objects" << std::endl;
-
-			//m.dumpStats();
-		}
-	}
-
-	template<> template<>
-	void SDTestObject::test<14>()
-		// make sure that assignment of char* NULL in a string does not crash.
-	{
-		LLSD v;
-		v = (const char*)NULL;
-		ensure("type is a string", v.isString());
-	}
-
-	/* TO DO:
-		conversion of undefined to UUID, Date, URI and Binary
-		conversion of undefined to map and array
-		test map operations
-		test array operations
-		test array extension
-		
-		test copying and assign maps and arrays (clone)
-		test iteration over map
-		test iteration over array
-		test iteration over scalar
-
-		test empty map and empty array are indeed shared
-		test serializations
-	*/
+    class SDCleanupCheck
+    {
+    private:
+        U32 mOutstandingAtStart;
+    public:
+        SDCleanupCheck() : mOutstandingAtStart(llsd::outstandingCount()) { }
+        ~SDCleanupCheck()
+        {
+            ensure_equals("SDCleanupCheck",
+                llsd::outstandingCount(), mOutstandingAtStart);
+        }
+    };
+
+    class SDAllocationCheck : public SDCleanupCheck
+    {
+    private:
+        std::string mMessage;
+        U32 mExpectedAllocations;
+        U32 mAllocationAtStart;
+    public:
+        SDAllocationCheck(const std::string& message, int expectedAllocations)
+            : mMessage(message),
+            mExpectedAllocations(expectedAllocations),
+            mAllocationAtStart(llsd::allocationCount())
+            { }
+        ~SDAllocationCheck()
+        {
+            ensure_equals(mMessage + " SDAllocationCheck",
+                llsd::allocationCount() - mAllocationAtStart,
+                mExpectedAllocations);
+        }
+    };
+
+    struct SDTestData {
+        template<class T>
+        static void ensureTypeAndValue(const char* msg, const LLSD& actual,
+            T expectedValue)
+        {
+            LLSDTraits<T> traits;
+
+            std::string s(msg);
+
+            ensure(         s + " type",    traits.checkType(actual));
+            ensure_equals(  s + " value",   traits.get(actual), expectedValue);
+        }
+
+        template<class T>
+        static void ensureTypeAndRefValue(const char* msg, const LLSD& actual,
+            const T& expectedValue)
+        {
+            LLSDTraits<const T&> traits;
+
+            std::string s(msg);
+
+            ensure(         s + " type",    traits.checkType(actual));
+            ensure_equals(  s + " value",   traits.get(actual), expectedValue);
+        }
+    };
+
+    typedef test_group<SDTestData>  SDTestGroup;
+    typedef SDTestGroup::object     SDTestObject;
+
+    SDTestGroup sdTestGroup("LLSD(new)");
+
+    // template<> template<>
+    // void SDTestObject::test<1>()
+    //  // construction and test of undefined
+    // {
+    //  SDCleanupCheck check;
+
+    //  LLSD u;
+    //  ensure("is undefined", u.isUndefined());
+    // }
+
+    template<> template<>
+    void SDTestObject::test<2>()
+        // setting and fetching scalar types
+    {
+        SDCleanupCheck check;
+
+        LLSD v;
+
+        v = true;       ensureTypeAndValue("set true", v, true);
+        v = false;      ensureTypeAndValue("set false", v, false);
+        v = true;       ensureTypeAndValue("set true again", v, true);
+
+        v = 42;         ensureTypeAndValue("set to 42", v, 42);
+        v = 0;          ensureTypeAndValue("set to zero", v, 0);
+        v = -12345;     ensureTypeAndValue("set to neg", v, -12345);
+        v = 2000000000; ensureTypeAndValue("set to big", v, 2000000000);
+
+        v = 3.14159265359;
+                        ensureTypeAndValue("set to pi", v, 3.14159265359);
+                        ensure_not_equals("isn't float", v.asReal(),
+                            (float)3.14159265359);
+        v = 6.7e256;    ensureTypeAndValue("set to big", v, 6.7e256);
+
+        LLUUID nullUUID;
+        LLUUID newUUID;
+        newUUID.generate();
+
+        v = nullUUID;   ensureTypeAndValue("set to null UUID", v, nullUUID);
+        v = newUUID;    ensureTypeAndValue("set to new UUID", v, newUUID);
+        v = nullUUID;   ensureTypeAndValue("set to null again", v, nullUUID);
+
+        // strings must be tested with two types of string objects
+        std::string s = "now is the time";
+        const char* cs = "for all good zorks";
+
+        v = s;          ensureTypeAndValue("set to std::string", v, s);
+        v = cs;         ensureTypeAndValue("set to const char*", v, cs);
+
+        LLDate epoch;
+        LLDate aDay("2001-10-22T10:11:12.00Z");
+
+        v = epoch;      ensureTypeAndValue("set to epoch", v, epoch);
+        v = aDay;       ensureTypeAndValue("set to a day", v, aDay);
+
+        LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/");
+
+        v = path;       ensureTypeAndValue("set to a uri", v, path);
+
+        const char source[] = "once in a blue moon";
+        std::vector<U8> data;
+        copy(&source[0], &source[sizeof(source)], back_inserter(data));
+
+        v = data;       ensureTypeAndRefValue("set to data", v, data);
+
+        v.clear();
+        ensure("reset to undefined", v.type() == LLSD::TypeUndefined);
+    }
+
+    template<> template<>
+    void SDTestObject::test<3>()
+        // construction via scalar values
+        // tests both constructor and initialize forms
+    {
+        SDCleanupCheck check;
+
+        LLSD b1(true);  ensureTypeAndValue("construct boolean", b1, true);
+        LLSD b2 = true; ensureTypeAndValue("initialize  boolean", b2, true);
+        LLSD i1(42);    ensureTypeAndValue("construct int", i1, 42);
+        LLSD i2 =42;    ensureTypeAndValue("initialize  int", i2, 42);
+        LLSD d1(1.2);   ensureTypeAndValue("construct double", d1, 1.2);
+        LLSD d2 = 1.2;  ensureTypeAndValue("initialize double", d2, 1.2);
+
+        LLUUID newUUID;
+        newUUID.generate();
+        LLSD u1(newUUID);
+                        ensureTypeAndValue("construct UUID", u1, newUUID);
+        LLSD u2 = newUUID;
+                        ensureTypeAndValue("initialize UUID", u2, newUUID);
+
+        LLSD ss1(std::string("abc"));
+                        ensureTypeAndValue("construct std::string", ss1, "abc");
+        LLSD ss2 = std::string("abc");
+                        ensureTypeAndValue("initialize std::string",ss2, "abc");
+        LLSD sl1(std::string("def"));
+                        ensureTypeAndValue("construct std::string", sl1, "def");
+        LLSD sl2 = std::string("def");
+                        ensureTypeAndValue("initialize std::string", sl2, "def");
+        LLSD sc1("ghi");
+                        ensureTypeAndValue("construct const char*", sc1, "ghi");
+        LLSD sc2 = "ghi";
+                        ensureTypeAndValue("initialize const char*",sc2, "ghi");
+
+        LLDate aDay("2001-10-22T10:11:12.00Z");
+        LLSD t1(aDay);  ensureTypeAndValue("construct LLDate", t1, aDay);
+        LLSD t2 = aDay; ensureTypeAndValue("initialize LLDate", t2, aDay);
+
+        LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/");
+        LLSD p1(path);  ensureTypeAndValue("construct LLURI", p1, path);
+        LLSD p2 = path; ensureTypeAndValue("initialize LLURI", p2, path);
+
+        const char source[] = "once in a blue moon";
+        std::vector<U8> data;
+        copy(&source[0], &source[sizeof(source)], back_inserter(data));
+        LLSD x1(data);  ensureTypeAndRefValue("construct vector<U8>", x1, data);
+        LLSD x2 = data; ensureTypeAndRefValue("initialize vector<U8>", x2, data);
+    }
+
+    void checkConversions(const char* msg, const LLSD& v,
+        LLSD::Boolean eBoolean, LLSD::Integer eInteger,
+        LLSD::Real eReal, const LLSD::String& eString)
+    {
+        std::string s(msg);
+
+        ensure_equals(s+" to bool", v.asBoolean(),  eBoolean);
+        ensure_equals(s+" to int",  v.asInteger(),  eInteger);
+        if (eReal == eReal)
+        {
+            ensure_equals(s+" to real", v.asReal(),     eReal);
+            ensure_equals(s+" to string",   v.asString(),   eString);
+        }
+        else
+        {
+            int left  = fpclassify(v.asReal());
+            int right = fpclassify(eReal);
+
+            ensure_equals(s+" to real",     left,           right);
+            // ensure_equals(s+" to string", v.asString(), eString);
+            // I've commented this check out, since there doesn't
+            // seem to be uniform string representation for NaN on
+            // all platforms. For example, on my Ubuntu 8.10 laptop
+            // with libc 2.11.1, sqrt(-1.0) will return '-nan', not
+            // 'nan'.
+        }
+    }
+
+    template<> template<>
+    void SDTestObject::test<4>()
+        // conversion between undefined and basic scalar types:
+        //  boolean, integer, real and string
+    {
+        SDCleanupCheck check;
+
+        LLSD v;         checkConversions("untitled", v, false, 0, 0.0, "");
+
+        v = false;      checkConversions("false", v, false, 0, 0.0, "");
+        v = true;       checkConversions("true", v, true, 1, 1.0, "true");
+
+        v = 0;          checkConversions("zero", v, false, 0, 0.0, "0");
+        v = 1;          checkConversions("one", v, true, 1, 1.0, "1");
+        v = -33;        checkConversions("neg33", v, true, -33, -33.0, "-33");
+
+        v = 0.0;        checkConversions("0.0", v, false, 0, 0.0, "0");
+        v = 0.5;        checkConversions("point5", v, true, 0, 0.5, "0.5");
+        v = 0.9;        checkConversions("point9", v, true, 0, 0.9, "0.9");
+        v = -3.9;       checkConversions("neg3dot9", v, true, -3, -3.9, "-3.9");
+        // Get rid of NaN test. First, some libraries don't reliably return
+        // NaN for sqrt(-1.0) -- meaning that I don't even know how to
+        // portably, reliably produce a NaN value. Second, we observe failures
+        // on different platforms in the asString() test. But LLSD's
+        // ImplReal::asString() does not itself recognize NaN! It merely
+        // passes the value through to llformat(), which passes it through to
+        // the library vsnprintf(). That is, even when we do produce NaN,
+        // we're not testing any LLSD code: we're testing the local library's
+        // vsnprintf() function, which (empirically) produces idiosyncratic
+        // results. This is just not a good test case.
+//      v = sqrt(-1.0); checkConversions("NaN", v, false, 0, sqrt(-1.0), "nan");
+
+        v = "";         checkConversions("empty", v, false, 0, 0.0, "");
+        v = "0";        checkConversions("digit0", v, true, 0, 0.0, "0");
+        v = "10";       checkConversions("digit10", v, true, 10, 10.0, "10");
+        v = "-2.345";   checkConversions("decdigits", v,
+                            true, -2, -2.345, "-2.345");
+        v = "apple";    checkConversions("apple", v, true, 0, 0.0, "apple");
+        v = "33bob";    checkConversions("digialpha", v, true, 0, 0.0, "33bob");
+        v = " ";        checkConversions("space", v, true, 0, 0.0, " ");
+        v = "\n";       checkConversions("newline", v, true, 0, 0.0, "\n");
+    }
+
+    template<class T>
+    void checkRoundTrip(const std::string& msg, const LLSD& actual,
+        const char* sExpected, T vExpected)
+    {
+        std::string str = actual.asString();
+
+        if (sExpected) {
+            ensure_equals(msg + " string", str, sExpected);
+        }
+
+        LLSD u(str);
+        LLSDTraits<T> traits;
+
+        ensure_equals(msg + " value", traits.get(u), vExpected);
+    }
+
+
+    template<> template<>
+    void SDTestObject::test<5>()
+        // conversion of String to and from UUID, Date and URI.
+    {
+        SDCleanupCheck check;
+
+        LLSD v;
+
+        LLUUID nullUUID;
+        LLUUID someUUID;
+        someUUID.generate();
+
+        v = nullUUID;   checkRoundTrip("null uuid", v,
+                            "00000000-0000-0000-0000-000000000000", nullUUID);
+        v = someUUID;   checkRoundTrip("random uuid", v, 0, someUUID);
+
+        LLDate epoch;
+        LLDate beta("2003-04-30T04:00:00Z");
+        LLDate oneOh("2003-06-23T04:00:00Z");
+
+        v = epoch;      checkRoundTrip("epoch date", v, 0, epoch);
+        v = beta;       checkRoundTrip("beta date", v,
+                            "2003-04-30T04:00:00Z", beta);
+        v = oneOh;      checkRoundTrip("1.0 date", v,
+                            "2003-06-23T04:00:00Z", oneOh);
+
+        LLURI empty;
+        LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/");
+        LLURI mail("mailto:zero.linden@secondlife.com");
+
+        v = empty;      checkRoundTrip("empty URI", v, 0, empty);
+        v = path;       checkRoundTrip("path URI", v,
+                            "http://slurl.com/secondlife/Ambleside/57/104/26/",
+                            path);
+        v = mail;       checkRoundTrip("mail URI", v,
+                            "mailto:zero.linden@secondlife.com", mail);
+    }
+
+    template<> template<>
+    void SDTestObject::test<6>()
+        // copy construction and assignment
+        // checking for shared values after constr. or assignment
+        // checking in both the same type and change of type case
+    {
+        SDCleanupCheck check;
+
+        {
+            LLSD v = 42;
+
+            LLSD w0(v);
+            ensureTypeAndValue("int constr.", w0, 42);
+
+            LLSD w1(v);
+            w1 = 13;
+            ensureTypeAndValue("int constr. change case 1", w1, 13);
+            ensureTypeAndValue("int constr. change case 2", v, 42);
+
+            LLSD w2(v);
+            v = 7;
+            ensureTypeAndValue("int constr. change case 3", w2, 42);
+            ensureTypeAndValue("int constr. change case 4", v, 7);
+        }
+
+        {
+            LLSD v = 42;
+
+            LLSD w1(v);
+            w1 = "bob";
+            ensureTypeAndValue("string constr. change case 1", w1, "bob");
+            ensureTypeAndValue("string constr. change case 2", v, 42);
+
+            LLSD w2(v);
+            v = "amy";
+            ensureTypeAndValue("string constr. change case 3", w2, 42);
+            ensureTypeAndValue("string constr. change case 4", v, "amy");
+        }
+
+        {
+            LLSD v = 42;
+
+            LLSD w0;
+            w0 = v;
+            ensureTypeAndValue("int assign", w0, 42);
+
+            LLSD w1;
+            w1 = v;
+            w1 = 13;
+            ensureTypeAndValue("int assign change case 1", w1, 13);
+            ensureTypeAndValue("int assign change case 2", v, 42);
+
+            LLSD w2;
+            w2 = v;
+            v = 7;
+            ensureTypeAndValue("int assign change case 3", w2, 42);
+            ensureTypeAndValue("int assign change case 4", v, 7);
+        }
+
+        {
+            LLSD v = 42;
+
+            LLSD w1;
+            w1 = v;
+            w1 = "bob";
+            ensureTypeAndValue("string assign change case 1", w1, "bob");
+            ensureTypeAndValue("string assign change case 2", v, 42);
+
+            LLSD w2;
+            w2 = v;
+            v = "amy";
+            ensureTypeAndValue("string assign change case 3", w2, 42);
+            ensureTypeAndValue("string assign change case 4", v, "amy");
+        }
+    }
+
+
+    template<> template<>
+    void SDTestObject::test<7>()
+        // Test assignment and casting to various scalar types.  These
+        // assignments should invoke the right conversion without it being
+        // mentioned explicitly.  The few exceptions are marked SAD.
+    {
+        SDCleanupCheck check;
+
+        LLSD v("  42.375");
+
+        bool b = false;
+        b = v;              ensure_equals("assign to bool", b, true);
+        b = (bool)v;        ensure_equals("cast to bool", b, true);
+
+        int i = 99;
+        i = v;              ensure_equals("assign to int", i, 42);
+        i = (int)v;         ensure_equals("cast to int", i, 42);
+
+        double d = 3.14159;
+        d = v;              ensure_equals("assign to double", d, 42.375);
+        d = (double)v;      ensure_equals("cast to double", d, 42.375);
+
+        std::string s = "yo";
+// SAD  s = v;              ensure_equals("assign to string", s, "  42.375");
+        s = (std::string)v; ensure_equals("cast to string", s, "  42.375");
+
+        std::string uuidStr = "b1e50c2b-b627-4d23-8a86-a65d97b6319b";
+        v = uuidStr;
+        LLUUID u;
+        u = v;
+                    ensure_equals("assign to LLUUID", u, LLUUID(uuidStr));
+// SAD  u = (LLUUID)v;
+//                  ensure_equals("cast to LLUUID", u, LLUUID(uuidStr));
+
+        std::string dateStr = "2005-10-24T15:00:00Z";
+        v = dateStr;
+        LLDate date;
+        date = v;
+                    ensure_equals("assign to LLDate", date.asString(), dateStr);
+// SAD  date = (LLDate)v;
+//                  ensure_equals("cast to LLDate", date.asString(), dateStr);
+
+        std::string uriStr = "http://secondlife.com";
+        v = uriStr;
+        LLURI uri;
+        uri = v;
+                    ensure_equals("assign to LLURI", uri.asString(), uriStr);
+// SAD  uri = (LLURI)v;
+//                  ensure_equals("cast to LLURI", uri.asString(), uriStr);
+    }
+
+    template<> template<>
+    void SDTestObject::test<8>()
+        // Test construction of various scalar types from LLSD.
+        // Test both construction and initialization forms.
+        // These should invoke the right conversion without it being
+        // mentioned explicitly.  The few exceptions are marked SAD.
+    {
+        SDCleanupCheck check;
+
+        LLSD v("  42.375");
+
+        bool b1(v);     ensure_equals("contruct bool", b1, true);
+        bool b2 = v;    ensure_equals("initialize bool", b2, true);
+
+        int i1(v);      ensure_equals("contruct int", i1, 42);
+        int i2 = v;     ensure_equals("initialize int", i2, 42);
+
+        double d1(v);   ensure_equals("contruct double", d1, 42.375);
+        double d2 = v;  ensure_equals("initialize double", d2, 42.375);
+
+        std::string s1(v);
+        std::string s2 = v;
+                        ensure_equals("contruct string", s1, "  42.375");
+                        ensure_equals("initialize string", s2, "  42.375");
+
+        std::string t1(v);
+        std::string t2 = v.asString();      // SAD
+                        ensure_equals("contruct std::string", t1, "  42.375");
+                        ensure_equals("initialize std::string", t2, "  42.375");
+
+        std::string uuidStr = "b1e50c2b-b627-4d23-8a86-a65d97b6319b";
+        v = uuidStr;
+        LLUUID uuid1(v.asUUID());       // SAD
+        LLUUID uuid2 = v;
+                ensure_equals("contruct LLUUID", uuid1, LLUUID(uuidStr));
+                ensure_equals("initialize LLUUID", uuid2, LLUUID(uuidStr));
+
+        std::string dateStr = "2005-10-24T15:00:00Z";
+        v = dateStr;
+        LLDate date1(v.asDate());       // SAD
+        LLDate date2 = v;
+                ensure_equals("contruct LLDate", date1.asString(), dateStr);
+                ensure_equals("initialize LLDate", date2.asString(), dateStr);
+
+        std::string uriStr = "http://secondlife.com";
+        v = uriStr;
+        LLURI uri1(v.asURI());          // SAD
+        LLURI uri2 = v;
+                ensure_equals("contruct LLURI", uri1.asString(), uriStr);
+                ensure_equals("initialize LLURI", uri2.asString(), uriStr);
+    }
+
+
+    template<> template<>
+    void SDTestObject::test<9>()
+        // test to make sure v is interpreted as a bool in a various
+        // scenarios.
+    {
+        SDCleanupCheck check;
+
+        LLSD v = "0";
+        // magic value that is interpreted as boolean true, but integer false!
+
+        ensure_equals("trinary operator bool", (v ? true : false), true);
+        ensure_equals("convert to int, then bool",
+                                            ((int)v ? true : false), false);
+
+        if(v)
+        {
+            ensure("if converted to bool", true);
+        }
+        else
+        {
+            fail("bool did not convert to a bool in if statement.");
+        }
+
+        if(!v)
+        {
+            fail("bool did not convert to a bool in negated if statement.");
+        }
+    }
+
+    template<> template<>
+    void SDTestObject::test<10>()
+        // map operations
+    {
+        SDCleanupCheck check;
+
+        LLSD v;
+        ensure("undefined has no members", !v.has("amy"));
+        ensure("undefined get() is undefined", v.get("bob").isUndefined());
+
+        v = LLSD::emptyMap();
+        ensure("empty map is a map", v.isMap());
+        ensure("empty map has no members", !v.has("cam"));
+        ensure("empty map get() is undefined", v.get("don").isUndefined());
+
+        v.clear();
+        v.insert("eli", 43);
+        ensure("insert converts to map", v.isMap());
+        ensure("inserted key is present", v.has("eli"));
+        ensureTypeAndValue("inserted value", v.get("eli"), 43);
+
+        v.insert("fra", false);
+        ensure("first key still present", v.has("eli"));
+        ensure("second key is present", v.has("fra"));
+        ensureTypeAndValue("first value", v.get("eli"), 43);
+        ensureTypeAndValue("second value", v.get("fra"), false);
+
+        v.erase("eli");
+        ensure("first key now gone", !v.has("eli"));
+        ensure("second key still present", v.has("fra"));
+        ensure("first value gone", v.get("eli").isUndefined());
+        ensureTypeAndValue("second value sill there", v.get("fra"), false);
+
+        v.erase("fra");
+        ensure("second key now gone", !v.has("fra"));
+        ensure("second value gone", v.get("fra").isUndefined());
+
+        v["gil"] = (std::string)"good morning";
+        ensure("third key present", v.has("gil"));
+        ensureTypeAndValue("third key value", v.get("gil"), "good morning");
+
+        const LLSD& cv = v; // FIX ME IF POSSIBLE
+        ensure("missing key", cv["ham"].isUndefined());
+        ensure("key not present", !v.has("ham"));
+
+        LLSD w = 43;
+        const LLSD& cw = w; // FIX ME IF POSSIBLE
+        int i = cw["ian"];
+        ensureTypeAndValue("other missing value", i, 0);
+        ensure("other missing key", !w.has("ian"));
+        ensure("no conversion", w.isInteger());
+
+        LLSD x;
+        x = v;
+        ensure("copy map type", x.isMap());
+        ensureTypeAndValue("copy map value gil", x.get("gil"), "good morning");
+    }
+
+
+    template<> template<>
+    void SDTestObject::test<11>()
+        // array operations
+    {
+        SDCleanupCheck check;
+
+        LLSD v;
+        ensure_equals("undefined has no size", v.size(), 0);
+        ensure("undefined get() is undefined", v.get(0).isUndefined());
+
+        v = LLSD::emptyArray();
+        ensure("empty array is an array", v.isArray());
+        ensure_equals("empty array has no size", v.size(), 0);
+        ensure("empty map get() is undefined", v.get(0).isUndefined());
+
+        v.clear();
+        v.append(88);
+        v.append("noodle");
+        v.append(true);
+        ensure_equals("appened array size", v.size(), 3);
+        ensure("append array is an array", v.isArray());
+        ensureTypeAndValue("append 0", v[0], 88);
+        ensureTypeAndValue("append 1", v[1], "noodle");
+        ensureTypeAndValue("append 2", v[2], true);
+
+        v.insert(0, 77);
+        v.insert(2, "soba");
+        v.insert(4, false);
+        ensure_equals("inserted array size", v.size(), 6);
+        ensureTypeAndValue("post insert 0", v[0], 77);
+        ensureTypeAndValue("post insert 1", v[1], 88);
+        ensureTypeAndValue("post insert 2", v[2], "soba");
+        ensureTypeAndValue("post insert 3", v[3], "noodle");
+        ensureTypeAndValue("post insert 4", v[4], false);
+        ensureTypeAndValue("post insert 5", v[5], true);
+
+        ensureTypeAndValue("get 1", v.get(1), 88);
+        v.set(1, "hot");
+        ensureTypeAndValue("set 1", v.get(1), "hot");
+
+        v.erase(3);
+        ensure_equals("post erase array size", v.size(), 5);
+        ensureTypeAndValue("post erase 0", v[0], 77);
+        ensureTypeAndValue("post erase 1", v[1], "hot");
+        ensureTypeAndValue("post erase 2", v[2], "soba");
+        ensureTypeAndValue("post erase 3", v[3], false);
+        ensureTypeAndValue("post erase 4", v[4], true);
+
+        v.append(34);
+        ensure_equals("size after append", v.size(), 6);
+        ensureTypeAndValue("post append 5", v[5], 34);
+
+        LLSD w;
+        w = v;
+        ensure("copy array type", w.isArray());
+        ensure_equals("copy array size", w.size(), 6);
+        ensureTypeAndValue("copy array 0", w[0], 77);
+        ensureTypeAndValue("copy array 1", w[1], "hot");
+        ensureTypeAndValue("copy array 2", w[2], "soba");
+        ensureTypeAndValue("copy array 3", w[3], false);
+        ensureTypeAndValue("copy array 4", w[4], true);
+        ensureTypeAndValue("copy array 5", w[5], 34);
+    }
+
+
+    template<> template<>
+    void SDTestObject::test<12>()
+        // no sharing
+    {
+        SDCleanupCheck check;
+
+        LLSD a = 99;
+        LLSD b = a;
+        a = 34;
+        ensureTypeAndValue("top level original changed",    a, 34);
+        ensureTypeAndValue("top level copy unaltered",      b, 99);
+        b = a;
+        b = 66;
+        ensureTypeAndValue("top level original unaltered",  a, 34);
+        ensureTypeAndValue("top level copy changed",        b, 66);
+
+        a[0] = "uno";
+        a[1] = 99;
+        a[2] = 1.414;
+        b = a;
+        a[1] = 34;
+        ensureTypeAndValue("array member original changed", a[1], 34);
+        ensureTypeAndValue("array member copy unaltered",   b[1], 99);
+        b = a;
+        b[1] = 66;
+        ensureTypeAndValue("array member original unaltered", a[1], 34);
+        ensureTypeAndValue("array member copy changed",     b[1], 66);
+
+        a["alpha"] = "uno";
+        a["beta"] = 99;
+        a["gamma"] = 1.414;
+        b = a;
+        a["beta"] = 34;
+        ensureTypeAndValue("map member original changed",   a["beta"], 34);
+        ensureTypeAndValue("map member copy unaltered",     b["beta"], 99);
+        b = a;
+        b["beta"] = 66;
+        ensureTypeAndValue("map member original unaltered", a["beta"], 34);
+        ensureTypeAndValue("map member copy changed",       b["beta"], 66);
+    }
+
+    template<> template<>
+    void SDTestObject::test<13>()
+        // sharing implementation
+    {
+        SDCleanupCheck check;
+
+        {
+            SDAllocationCheck check("copy construct undefinded", 0);
+            LLSD v;
+            LLSD w = v;
+        }
+
+        {
+            SDAllocationCheck check("assign undefined", 0);
+            LLSD v;
+            LLSD w;
+            w = v;
+        }
+
+        {
+            SDAllocationCheck check("assign integer value", 1);
+            LLSD v = 45;
+            v = 33;
+            v = 0;
+        }
+
+        {
+            SDAllocationCheck check("copy construct integer", 1);
+            LLSD v = 45;
+            LLSD w = v;
+        }
+
+        {
+            SDAllocationCheck check("assign integer", 1);
+            LLSD v = 45;
+            LLSD w;
+            w = v;
+        }
+
+        {
+            SDAllocationCheck check("avoids extra clone", 2);
+            LLSD v = 45;
+            LLSD w = v;
+            w = "nice day";
+        }
+
+        {
+            SDAllocationCheck check("shared values test for threaded work", 9);
+
+            //U32 start_llsd_count = LLSD::outstandingCount();
+
+            LLSD m = LLSD::emptyMap();
+
+            m["one"] = 1;
+            m["two"] = 2;
+            m["one_copy"] = m["one"];           // 3 (m, "one" and "two")
+
+            m["undef_one"] = LLSD();
+            m["undef_two"] = LLSD();
+            m["undef_one_copy"] = m["undef_one"];
+
+            {   // Ensure first_array gets freed to avoid counting it
+                LLSD first_array = LLSD::emptyArray();
+                first_array.append(1.0f);
+                first_array.append(2.0f);
+                first_array.append(3.0f);           // 7
+
+                m["array"] = first_array;
+                m["array_clone"] = first_array;
+                m["array_copy"] = m["array"];       // 7
+            }
+
+            m["string_one"] = "string one value";
+            m["string_two"] = "string two value";
+            m["string_one_copy"] = m["string_one"];     // 9
+
+            //U32 llsd_object_count = LLSD::outstandingCount();
+            //std::cout << "Using " << (llsd_object_count - start_llsd_count) << " LLSD objects" << std::endl;
+
+            //m.dumpStats();
+        }
+    }
+
+    template<> template<>
+    void SDTestObject::test<14>()
+        // make sure that assignment of char* NULL in a string does not crash.
+    {
+        LLSD v;
+        v = (const char*)NULL;
+        ensure("type is a string", v.isString());
+    }
+
+    /* TO DO:
+        conversion of undefined to UUID, Date, URI and Binary
+        conversion of undefined to map and array
+        test map operations
+        test array operations
+        test array extension
+
+        test copying and assign maps and arrays (clone)
+        test iteration over map
+        test iteration over array
+        test iteration over scalar
+
+        test empty map and empty array are indeed shared
+        test serializations
+    */
 }
 
diff --git a/indra/test/llsdmessagebuilder_tut.cpp b/indra/test/llsdmessagebuilder_tut.cpp
index b65a3fefd5..d85d460198 100644
--- a/indra/test/llsdmessagebuilder_tut.cpp
+++ b/indra/test/llsdmessagebuilder_tut.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llsdmessagebuilder_tut.cpp
  * @date   February 2006
  * @brief LLSDMessageBuilder unit tests
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2006&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -45,793 +45,793 @@
 #include "lltemplatemessagebuilder.h"
 
 namespace tut
-{	
-	static LLTemplateMessageBuilder::message_template_name_map_t templateNameMap;
+{
+    static LLTemplateMessageBuilder::message_template_name_map_t templateNameMap;
 
     LLMsgData* messageData = NULL;
     LLMsgBlkData* messageBlockData = NULL;
 
-	struct LLSDMessageBuilderTestData {
-
-		LLSDMessageBuilderTestData()
-		{
-			messageData = new LLMsgData("testMessage");
-			messageBlockData = new LLMsgBlkData("testBlock", 0);
-		}
-
-		static LLSDMessageBuilder defaultBuilder()
-		{
-			LLSDMessageBuilder builder;
-			builder.newMessage("name");
-			builder.nextBlock("block");
-			return builder;
-		}
-
-		static LLSDMessageReader setReader(const LLSDMessageBuilder& builder)
-		{
-			LLSDMessageReader reader;
-			reader.setMessage("name", builder.getMessage());
-			return reader;
-		}
-
-		static void addValue(LLMsgBlkData* mbd, char* name, void* v, EMsgVariableType type, int size, int data_size = -1)
-		{
-			LLMsgVarData tmp(name, type);
-			tmp.addData(v, size, type, data_size);
-			mbd->mMemberVarData[name] = tmp;
-		}
-
-
-		static LLMessageBlock* defaultTemplateBlock(const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
-		{
-			return createTemplateBlock(_PREHASH_Test0, type, size, block);
-		}
-
-		static LLMessageBlock* createTemplateBlock(const char* name, const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
-		{
-			LLMessageBlock* result = new LLMessageBlock(name, block);
-			if(type != MVT_NULL)
-			{
-				result->addVariable(const_cast<char*>(_PREHASH_Test0), type, size);
-			}
-			return result;
-		}
-
-		static LLTemplateMessageBuilder* defaultTemplateBuilder(LLMessageTemplate& messageTemplate, char* name = const_cast<char*>(_PREHASH_Test0))
-		{
-			templateNameMap[_PREHASH_TestMessage] = &messageTemplate;
-			LLTemplateMessageBuilder* builder = new LLTemplateMessageBuilder(templateNameMap);
-			builder->newMessage(_PREHASH_TestMessage);
-			builder->nextBlock(name);
-			return builder;
-		}
-
-		static LLMessageTemplate defaultTemplate()
-		{
-			return LLMessageTemplate(_PREHASH_TestMessage, 1, MFT_HIGH);
-		}
-	};
-	
-	typedef test_group<LLSDMessageBuilderTestData>	LLSDMessageBuilderTestGroup;
-	typedef LLSDMessageBuilderTestGroup::object		LLSDMessageBuilderTestObject;
-	LLSDMessageBuilderTestGroup llsdMessageBuilderTestGroup("LLSDMessageBuilder");
-	
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<1>()
-		// construction and test of undefined
-	{
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  LLSDMessageReader reader = setReader(builder);
-	}
-	
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<2>()
-		 // BOOL
-	{
-	  BOOL outValue, inValue = TRUE;
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addBOOL("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getBOOL("block", "var", outValue);
-	  ensure_equals("Ensure BOOL", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<3>()
-		 // U8
-	{
-	  U8 outValue, inValue = 2;
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addU8("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getU8("block", "var", outValue);
-	  ensure_equals("Ensure U8", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<4>()
-		 // S16
-	{
-	  S16 outValue, inValue = 90;
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addS16("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getS16("block", "var", outValue);
-	  ensure_equals("Ensure S16", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<5>()
-		 // U16
-	{
-	  U16 outValue, inValue = 3;
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addU16("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getU16("block", "var", outValue);
-	  ensure_equals("Ensure U16", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<6>()
-		 // S32
-	{
-	  S32 outValue, inValue = 44;
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addS32("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getS32("block", "var", outValue);
-	  ensure_equals("Ensure S32", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<7>()
-		 // F32
-	{
-	  F32 outValue, inValue = 121.44f;
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addF32("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getF32("block", "var", outValue);
-	  ensure_equals("Ensure F32", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<8>()
-		 // U32
-	{
-	  U32 outValue, inValue = 88;
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addU32("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getU32("block", "var", outValue);
-	  ensure_equals("Ensure U32", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<9>()
-		 // U64
-	{
-	  U64 outValue, inValue = 121;
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addU64("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getU64("block", "var", outValue);
-	  ensure_equals("Ensure U64", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<10>()
-		 // F64
-	{
-	  F64 outValue, inValue = 3232143.33;
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addF64("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getF64("block", "var", outValue);
-	  ensure_equals("Ensure F64", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<11>()
-		 // Vector3
-	{
-	  LLVector3 outValue, inValue = LLVector3(1,2,3);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addVector3("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getVector3("block", "var", outValue);
-	  ensure_equals("Ensure Vector3", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<12>()
-		 // Vector4
-	{
-	  LLVector4 outValue, inValue = LLVector4(1,2,3,4);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addVector4("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getVector4("block", "var", outValue);
-	  ensure_equals("Ensure Vector4", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<13>()
-		 // Vector3d
-	{
-	  LLVector3d outValue, inValue = LLVector3d(1,2,3);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addVector3d("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getVector3d("block", "var", outValue);
-	  ensure_equals("Ensure Vector3d", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<14>()
-		 // Quaternion
-	{
-	  LLQuaternion outValue, inValue = LLQuaternion(1,LLVector3(2,3,4));
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addQuat("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getQuat("block", "var", outValue);
-	  ensure_equals("Ensure Quaternion", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<15>()
-		 // UUID
-	{
-	  LLUUID outValue, inValue;
-	  inValue.generate();
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addUUID("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getUUID("block", "var", outValue);
-	  ensure_equals("Ensure UUID", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<16>()
-		 // IPAddr
-	{
-	  U32 outValue, inValue = 12344556;
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addIPAddr("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getIPAddr("block", "var", outValue);
-	  ensure_equals("Ensure IPAddr", inValue, outValue);
-	}
-
-	 template<> template<>
-	void LLSDMessageBuilderTestObject::test<17>()
-		 // IPPort
-	{
-		 U16 outValue, inValue = 80;
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addIPPort("var", inValue);
-	  LLSDMessageReader reader = setReader(builder);
-	  reader.getIPPort("block", "var", outValue);
-	  ensure_equals("Ensure IPPort", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<18>()
-	{
-		 std::string outValue, inValue = "testing";
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  builder.addString("var", inValue.c_str());
-	  LLSDMessageReader reader = setReader(builder);
-	  char buffer[MAX_STRING];
-	  reader.getString("block", "var", MAX_STRING, buffer);
-	  outValue = buffer;
-	  ensure_equals("Ensure String", inValue, outValue);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<19>()
-	{
-	  LLMsgBlkData* mbd = new LLMsgBlkData("testBlock", 0);
-	  LLMsgData* md = new LLMsgData("testMessage");
-	  md->addBlock(mbd);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*md);
-	  LLSD output = builder.getMessage();
-
-	  ensure("Ensure message block created when copied from legacy message to llsd", output["testBlock"].isDefined());
-	}
-
-	// MVT_FIXED
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<20>()
-	{
-	  char binData[] = "abcdefghijklmnop";
-
-	  addValue(messageBlockData, (char *)"testBinData", &binData, MVT_FIXED, sizeof(binData));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
-	  ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
-
-	  ensure_memory_matches("Ensure fixed binary data works in a message copied from legacy to llsd",
-		  &v[0], sizeof(binData), binData, sizeof(binData));
-	}
-
-	// MVT_VARIABLE data_size 1 (U8's)
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<21>()
-	{
-	 /* U8 binData[] = "abcdefghijklmnop";
-
-	  addValue(messageBlockData, "testBinData", &binData, MVT_VARIABLE, sizeof(binData), 1);
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
-	  ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
-
-	  ensure_memory_matches("Ensure MVT_VARIABLE U8 binary data works in a message copied from legacy to llsd",
-		  &v[0], sizeof(binData), binData, sizeof(binData));*/
-	}
-
-	// MVT_VARIABLE data_size 2 (U16's)
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<22>()
-	{
-	  U16 binData[] = {1,2,3,4,5,6,7,8,9}; //9 shorts
-
-	  addValue(messageBlockData, (char *)"testBinData", &binData, MVT_VARIABLE, sizeof(binData) >> 1, 2);
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
-	  ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
-
-	  ensure_memory_matches("Ensure MVT_VARIABLE U16 binary data works in a message copied from legacy to llsd",
-		  &v[0], sizeof(binData) >> 1, binData, sizeof(binData) >> 1);
-	}
-
-	// MVT_VARIABLE data_size 4 (S32's)
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<23>()
-	{
-	  U32 binData[] = {9,8,7,6,5,4,3,2,1};
-
-	  addValue(messageBlockData, (char *)"testBinData", &binData, MVT_VARIABLE, sizeof(binData) >> 2, 4);
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
-	  ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
-
-	  ensure_memory_matches("Ensure MVT_VARIABLE S32 binary data works in a message copied from legacy to llsd",
-		  &v[0], sizeof(binData) >> 2, binData, sizeof(binData) >> 2);
-	}
-
-	// MVT_U8
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<24>()
-	{
-	  U8 data = 0xa5;
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_U8, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_U8 data works in a message copied from legacy to llsd",
-		  output["testBlock"][0]["testBinData"].asInteger(), data);
-	}
-
-	// MVT_U16
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<25>()
-	{
-	  U16 data = 0xa55a;
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_U16, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_U16 data works in a message copied from legacy to llsd",
-		  output["testBlock"][0]["testBinData"].asInteger(), data);
-	}
-
-	// MVT_U32
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<26>()
-	{
-	  U32 data = 0xa55a7117;
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_U32, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_U32 data works in a message copied from legacy to llsd",
-		  ll_U32_from_sd(output["testBlock"][0]["testBinData"]), data);
-	}
-
-	// MVT_U64 - crush into an s32: LLSD does not support 64 bit values
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<27>()
-	{
-	  U64 data = U64L(0xa55a711711223344);
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_U64, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_U64 data works in a message copied from legacy to llsd",
-		  ll_U64_from_sd(output["testBlock"][0]["testBinData"]), data);
-	}
-
-	// MVT_S8
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<28>()
-	{
-	  S8 data = -31;
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_S8, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_S8 data works in a message copied from legacy to llsd",
-		  output["testBlock"][0]["testBinData"].asInteger(), data);
-	}
-
-	// MVT_S16
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<29>()
-	{
-	  S16 data = -31;
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_S16, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_S16 data works in a message copied from legacy to llsd",
-		  output["testBlock"][0]["testBinData"].asInteger(), data);
-	}
-
-	// MVT_S32
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<30>()
-	{
-	  S32 data = -3100;
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_S32, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_S32 data works in a message copied from legacy to llsd",
-		  output["testBlock"][0]["testBinData"].asInteger(), data);
-	}
-
-	// MVT_S64 - crush into an s32: LLSD does not support 64 bit values
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<31>()
-	{
-	  S64 data = -31003100;
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_S64, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_S64 data works in a message copied from legacy to llsd",
-		  output["testBlock"][0]["testBinData"].asInteger(), (S32)data);
-	}
-
-	// MVT_F32
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<32>()
-	{
-	  F32 data = 1234.1234f;
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_F32, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_F32 data works in a message copied from legacy to llsd",
-		  output["testBlock"][0]["testBinData"].asReal(), data);
-	}
-
-	// MVT_F64
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<33>()
-	{
-	  F64 data = 1234.1234;
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_F64, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_F64 data works in a message copied from legacy to llsd",
-		  output["testBlock"][0]["testBinData"].asReal(), data);
-	}
-
-	// MVT_LLVector3
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<34>()
-	{
-	  LLVector3 data(1,2,3);
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLVector3, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_LLVector3 data works in a message copied from legacy to llsd",
-		  ll_vector3_from_sd(output["testBlock"][0]["testBinData"]), data);
-	}
-
-	// MVT_LLVector3d
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<35>()
-	{
-	  LLVector3d data(1,2,3);
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLVector3d, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_LLVector3 data works in a message copied from legacy to llsd",
-		  ll_vector3d_from_sd(output["testBlock"][0]["testBinData"]), data);
-	}
-
-	// MVT_LLVector4
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<36>()
-	{
-	  LLVector4 data(1,2,3,4);
-	  LLSD v = ll_sd_from_vector4(data);
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLVector4, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_LLVector4 data works in a message copied from legacy to llsd",
-		  output["testBlock"][0]["testBinData"], v);
-	}
-
-	// MVT_LLQuaternion
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<37>()
-	{
-	  LLQuaternion data(0.3713907f, 0.5570861f, 0.7427813f,0.0f);
-
-	  //we send a quaternion packed into a vec3 (w is infered) - so sizeof(vec) == 12 bytes not 16.
-	  LLVector3 vec = data.packToVector3();
-
-	  addValue(messageBlockData, (char *)"testBinData", &vec, MVT_LLQuaternion, sizeof(vec));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_LLQuaternion data works in a message copied from legacy to llsd",
-		  ll_quaternion_from_sd(output["testBlock"][0]["testBinData"]), data);
-	}
-
-	// MVT_LLUUID
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<38>()
-	{
-	  LLUUID data("01234567-0123-0123-0123-234567abcdef");
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLUUID, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-	 
-	  std::string v = output["testBlock"][0]["testBinData"].asUUID().asString();
-
-	  ensure_equals("Ensure MVT_LLUUID data works in a message copied from legacy to llsd",
-		  output["testBlock"][0]["testBinData"].asUUID(), data);
-	}
-
-	// MVT_BOOL
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<39>()
-	{
-	  BOOL valueTrue = true;
-	  BOOL valueFalse = false;
-
-	  LLMsgData* md = new LLMsgData("testMessage");
-	  LLMsgBlkData* mbd = new LLMsgBlkData("testBlock", 0);
-	  addValue(mbd, (char *)"testBoolFalse", &valueFalse, MVT_BOOL, sizeof(BOOL));
-	  addValue(mbd, (char *)"testBoolTrue", &valueTrue, MVT_BOOL, sizeof(BOOL));
-	  md->addBlock(mbd);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*md);
-	  LLSD output = builder.getMessage();
-
-	  ensure("Ensure bools work in a message copied from legacy to llsd",
-		  output["testBlock"][0]["testBoolTrue"].asBoolean() && !output["testBlock"][0]["testBoolFalse"].asBoolean());
-	}
-
-	// MVT_IP_ADDR
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<40>()
-	{
-	  U32 data(0xff887766);
-	  LLSD v = ll_sd_from_ipaddr(data);
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_IP_ADDR, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_IP_ADDR data works in a message copied from legacy to llsd",
-		  output["testBlock"][0]["testBinData"], v);
-	}
-
-	// MVT_IP_PORT
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<41>()
-	{
-	  U16 data = 0xff88;
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_IP_PORT, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  ensure_equals("Ensure MVT_IP_PORT data works in a message copied from legacy to llsd",
-		  output["testBlock"][0]["testBinData"].asInteger(), data);
-	}
-
-	// MVT_U16Vec3
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<42>()
-	{
-	  U16 data[3] = {0,1,2};
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_U16Vec3, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
-	  ensure("Ensure MVT_U16Vec3 data copied from legacy to llsd give a valid vector", v.size() > 0);
-
-	  ensure_memory_matches("Ensure MVT_U16Vec3 data works in a message copied from legacy to llsd",
-		  (U16*)&v[0], 6, data, 6);
-	}
-
-	// MVT_U16Quat
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<43>()
-	{
-	  U16 data[4] = {0,1,2,4};
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_U16Quat, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
-	  ensure("Ensure MVT_U16Quat data copied from legacy to llsd give a valid vector", v.size() > 0);
-
-	  ensure_memory_matches("Ensure MVT_U16Quat data works in a message copied from legacy to llsd",
-		  (U16*)&v[0], 8, data, 8);
-	}
-
-	// MVT_S16Array
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<44>()
-	{
-	  S16 data[19] = {0,-1,2,-4,5,-6,7,-8,9,-10,11,-12,13,-14,15,16,17,18};
-
-	  addValue(messageBlockData, (char *)"testBinData", &data, MVT_S16Array, sizeof(data));
-	  messageData->addBlock(messageBlockData);
-	  LLSDMessageBuilder builder = defaultBuilder();
-	  
-	  builder.copyFromMessageData(*messageData);
-	  LLSD output = builder.getMessage();
-
-	  std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
-	  ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
-
-	  ensure_memory_matches("Ensure MVT_S16Array data works in a message copied from legacy to llsd",
-		  (U16*)&v[0], 19, data, 19);
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<45>()
-	{
-		LLMessageTemplate messageTemplate = defaultTemplate();
-		messageTemplate.addBlock(defaultTemplateBlock(MVT_U8, 1));
-		U8 inValue = 2;
-		LLTemplateMessageBuilder* template_builder = defaultTemplateBuilder(messageTemplate);
-		template_builder->addU8(_PREHASH_Test0, inValue);
-
-		LLSDMessageBuilder builder;
-		builder.copyFromMessageData(*template_builder->getCurrentMessage());
-		LLSD output = builder.getMessage();
-		
-		ensure_equals(output["Test0"][0]["Test0"].asInteger(), 2);
-
-	}
-
-	template<> template<>
-	void LLSDMessageBuilderTestObject::test<46>()
-	{
-		LLMessageTemplate messageTemplate = defaultTemplate();
-		messageTemplate.addBlock(defaultTemplateBlock(MVT_VARIABLE, 1));
-		std::string inValue = "testing";
-		LLTemplateMessageBuilder* builder = defaultTemplateBuilder(messageTemplate);
-		builder->addString(_PREHASH_Test0, inValue.c_str());
-
-		LLSDMessageBuilder sd_builder;
-		sd_builder.copyFromMessageData(*builder->getCurrentMessage());
-		LLSD output = sd_builder.getMessage();
-		
-		ensure_equals(output["Test0"][0]["Test0"].asString(), std::string("testing"));
-	}
+    struct LLSDMessageBuilderTestData {
+
+        LLSDMessageBuilderTestData()
+        {
+            messageData = new LLMsgData("testMessage");
+            messageBlockData = new LLMsgBlkData("testBlock", 0);
+        }
+
+        static LLSDMessageBuilder defaultBuilder()
+        {
+            LLSDMessageBuilder builder;
+            builder.newMessage("name");
+            builder.nextBlock("block");
+            return builder;
+        }
+
+        static LLSDMessageReader setReader(const LLSDMessageBuilder& builder)
+        {
+            LLSDMessageReader reader;
+            reader.setMessage("name", builder.getMessage());
+            return reader;
+        }
+
+        static void addValue(LLMsgBlkData* mbd, char* name, void* v, EMsgVariableType type, int size, int data_size = -1)
+        {
+            LLMsgVarData tmp(name, type);
+            tmp.addData(v, size, type, data_size);
+            mbd->mMemberVarData[name] = tmp;
+        }
+
+
+        static LLMessageBlock* defaultTemplateBlock(const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
+        {
+            return createTemplateBlock(_PREHASH_Test0, type, size, block);
+        }
+
+        static LLMessageBlock* createTemplateBlock(const char* name, const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
+        {
+            LLMessageBlock* result = new LLMessageBlock(name, block);
+            if(type != MVT_NULL)
+            {
+                result->addVariable(const_cast<char*>(_PREHASH_Test0), type, size);
+            }
+            return result;
+        }
+
+        static LLTemplateMessageBuilder* defaultTemplateBuilder(LLMessageTemplate& messageTemplate, char* name = const_cast<char*>(_PREHASH_Test0))
+        {
+            templateNameMap[_PREHASH_TestMessage] = &messageTemplate;
+            LLTemplateMessageBuilder* builder = new LLTemplateMessageBuilder(templateNameMap);
+            builder->newMessage(_PREHASH_TestMessage);
+            builder->nextBlock(name);
+            return builder;
+        }
+
+        static LLMessageTemplate defaultTemplate()
+        {
+            return LLMessageTemplate(_PREHASH_TestMessage, 1, MFT_HIGH);
+        }
+    };
+
+    typedef test_group<LLSDMessageBuilderTestData>  LLSDMessageBuilderTestGroup;
+    typedef LLSDMessageBuilderTestGroup::object     LLSDMessageBuilderTestObject;
+    LLSDMessageBuilderTestGroup llsdMessageBuilderTestGroup("LLSDMessageBuilder");
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<1>()
+        // construction and test of undefined
+    {
+      LLSDMessageBuilder builder = defaultBuilder();
+      LLSDMessageReader reader = setReader(builder);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<2>()
+         // BOOL
+    {
+      BOOL outValue, inValue = TRUE;
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addBOOL("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getBOOL("block", "var", outValue);
+      ensure_equals("Ensure BOOL", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<3>()
+         // U8
+    {
+      U8 outValue, inValue = 2;
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addU8("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getU8("block", "var", outValue);
+      ensure_equals("Ensure U8", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<4>()
+         // S16
+    {
+      S16 outValue, inValue = 90;
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addS16("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getS16("block", "var", outValue);
+      ensure_equals("Ensure S16", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<5>()
+         // U16
+    {
+      U16 outValue, inValue = 3;
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addU16("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getU16("block", "var", outValue);
+      ensure_equals("Ensure U16", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<6>()
+         // S32
+    {
+      S32 outValue, inValue = 44;
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addS32("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getS32("block", "var", outValue);
+      ensure_equals("Ensure S32", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<7>()
+         // F32
+    {
+      F32 outValue, inValue = 121.44f;
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addF32("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getF32("block", "var", outValue);
+      ensure_equals("Ensure F32", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<8>()
+         // U32
+    {
+      U32 outValue, inValue = 88;
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addU32("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getU32("block", "var", outValue);
+      ensure_equals("Ensure U32", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<9>()
+         // U64
+    {
+      U64 outValue, inValue = 121;
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addU64("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getU64("block", "var", outValue);
+      ensure_equals("Ensure U64", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<10>()
+         // F64
+    {
+      F64 outValue, inValue = 3232143.33;
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addF64("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getF64("block", "var", outValue);
+      ensure_equals("Ensure F64", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<11>()
+         // Vector3
+    {
+      LLVector3 outValue, inValue = LLVector3(1,2,3);
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addVector3("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getVector3("block", "var", outValue);
+      ensure_equals("Ensure Vector3", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<12>()
+         // Vector4
+    {
+      LLVector4 outValue, inValue = LLVector4(1,2,3,4);
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addVector4("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getVector4("block", "var", outValue);
+      ensure_equals("Ensure Vector4", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<13>()
+         // Vector3d
+    {
+      LLVector3d outValue, inValue = LLVector3d(1,2,3);
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addVector3d("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getVector3d("block", "var", outValue);
+      ensure_equals("Ensure Vector3d", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<14>()
+         // Quaternion
+    {
+      LLQuaternion outValue, inValue = LLQuaternion(1,LLVector3(2,3,4));
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addQuat("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getQuat("block", "var", outValue);
+      ensure_equals("Ensure Quaternion", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<15>()
+         // UUID
+    {
+      LLUUID outValue, inValue;
+      inValue.generate();
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addUUID("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getUUID("block", "var", outValue);
+      ensure_equals("Ensure UUID", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<16>()
+         // IPAddr
+    {
+      U32 outValue, inValue = 12344556;
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addIPAddr("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getIPAddr("block", "var", outValue);
+      ensure_equals("Ensure IPAddr", inValue, outValue);
+    }
+
+     template<> template<>
+    void LLSDMessageBuilderTestObject::test<17>()
+         // IPPort
+    {
+         U16 outValue, inValue = 80;
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addIPPort("var", inValue);
+      LLSDMessageReader reader = setReader(builder);
+      reader.getIPPort("block", "var", outValue);
+      ensure_equals("Ensure IPPort", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<18>()
+    {
+         std::string outValue, inValue = "testing";
+      LLSDMessageBuilder builder = defaultBuilder();
+      builder.addString("var", inValue.c_str());
+      LLSDMessageReader reader = setReader(builder);
+      char buffer[MAX_STRING];
+      reader.getString("block", "var", MAX_STRING, buffer);
+      outValue = buffer;
+      ensure_equals("Ensure String", inValue, outValue);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<19>()
+    {
+      LLMsgBlkData* mbd = new LLMsgBlkData("testBlock", 0);
+      LLMsgData* md = new LLMsgData("testMessage");
+      md->addBlock(mbd);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*md);
+      LLSD output = builder.getMessage();
+
+      ensure("Ensure message block created when copied from legacy message to llsd", output["testBlock"].isDefined());
+    }
+
+    // MVT_FIXED
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<20>()
+    {
+      char binData[] = "abcdefghijklmnop";
+
+      addValue(messageBlockData, (char *)"testBinData", &binData, MVT_FIXED, sizeof(binData));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
+      ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
+
+      ensure_memory_matches("Ensure fixed binary data works in a message copied from legacy to llsd",
+          &v[0], sizeof(binData), binData, sizeof(binData));
+    }
+
+    // MVT_VARIABLE data_size 1 (U8's)
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<21>()
+    {
+     /* U8 binData[] = "abcdefghijklmnop";
+
+      addValue(messageBlockData, "testBinData", &binData, MVT_VARIABLE, sizeof(binData), 1);
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
+      ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
+
+      ensure_memory_matches("Ensure MVT_VARIABLE U8 binary data works in a message copied from legacy to llsd",
+          &v[0], sizeof(binData), binData, sizeof(binData));*/
+    }
+
+    // MVT_VARIABLE data_size 2 (U16's)
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<22>()
+    {
+      U16 binData[] = {1,2,3,4,5,6,7,8,9}; //9 shorts
+
+      addValue(messageBlockData, (char *)"testBinData", &binData, MVT_VARIABLE, sizeof(binData) >> 1, 2);
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
+      ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
+
+      ensure_memory_matches("Ensure MVT_VARIABLE U16 binary data works in a message copied from legacy to llsd",
+          &v[0], sizeof(binData) >> 1, binData, sizeof(binData) >> 1);
+    }
+
+    // MVT_VARIABLE data_size 4 (S32's)
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<23>()
+    {
+      U32 binData[] = {9,8,7,6,5,4,3,2,1};
+
+      addValue(messageBlockData, (char *)"testBinData", &binData, MVT_VARIABLE, sizeof(binData) >> 2, 4);
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
+      ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
+
+      ensure_memory_matches("Ensure MVT_VARIABLE S32 binary data works in a message copied from legacy to llsd",
+          &v[0], sizeof(binData) >> 2, binData, sizeof(binData) >> 2);
+    }
+
+    // MVT_U8
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<24>()
+    {
+      U8 data = 0xa5;
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_U8, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_U8 data works in a message copied from legacy to llsd",
+          output["testBlock"][0]["testBinData"].asInteger(), data);
+    }
+
+    // MVT_U16
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<25>()
+    {
+      U16 data = 0xa55a;
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_U16, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_U16 data works in a message copied from legacy to llsd",
+          output["testBlock"][0]["testBinData"].asInteger(), data);
+    }
+
+    // MVT_U32
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<26>()
+    {
+      U32 data = 0xa55a7117;
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_U32, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_U32 data works in a message copied from legacy to llsd",
+          ll_U32_from_sd(output["testBlock"][0]["testBinData"]), data);
+    }
+
+    // MVT_U64 - crush into an s32: LLSD does not support 64 bit values
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<27>()
+    {
+      U64 data = U64L(0xa55a711711223344);
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_U64, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_U64 data works in a message copied from legacy to llsd",
+          ll_U64_from_sd(output["testBlock"][0]["testBinData"]), data);
+    }
+
+    // MVT_S8
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<28>()
+    {
+      S8 data = -31;
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_S8, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_S8 data works in a message copied from legacy to llsd",
+          output["testBlock"][0]["testBinData"].asInteger(), data);
+    }
+
+    // MVT_S16
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<29>()
+    {
+      S16 data = -31;
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_S16, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_S16 data works in a message copied from legacy to llsd",
+          output["testBlock"][0]["testBinData"].asInteger(), data);
+    }
+
+    // MVT_S32
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<30>()
+    {
+      S32 data = -3100;
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_S32, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_S32 data works in a message copied from legacy to llsd",
+          output["testBlock"][0]["testBinData"].asInteger(), data);
+    }
+
+    // MVT_S64 - crush into an s32: LLSD does not support 64 bit values
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<31>()
+    {
+      S64 data = -31003100;
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_S64, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_S64 data works in a message copied from legacy to llsd",
+          output["testBlock"][0]["testBinData"].asInteger(), (S32)data);
+    }
+
+    // MVT_F32
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<32>()
+    {
+      F32 data = 1234.1234f;
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_F32, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_F32 data works in a message copied from legacy to llsd",
+          output["testBlock"][0]["testBinData"].asReal(), data);
+    }
+
+    // MVT_F64
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<33>()
+    {
+      F64 data = 1234.1234;
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_F64, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_F64 data works in a message copied from legacy to llsd",
+          output["testBlock"][0]["testBinData"].asReal(), data);
+    }
+
+    // MVT_LLVector3
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<34>()
+    {
+      LLVector3 data(1,2,3);
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLVector3, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_LLVector3 data works in a message copied from legacy to llsd",
+          ll_vector3_from_sd(output["testBlock"][0]["testBinData"]), data);
+    }
+
+    // MVT_LLVector3d
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<35>()
+    {
+      LLVector3d data(1,2,3);
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLVector3d, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_LLVector3 data works in a message copied from legacy to llsd",
+          ll_vector3d_from_sd(output["testBlock"][0]["testBinData"]), data);
+    }
+
+    // MVT_LLVector4
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<36>()
+    {
+      LLVector4 data(1,2,3,4);
+      LLSD v = ll_sd_from_vector4(data);
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLVector4, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_LLVector4 data works in a message copied from legacy to llsd",
+          output["testBlock"][0]["testBinData"], v);
+    }
+
+    // MVT_LLQuaternion
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<37>()
+    {
+      LLQuaternion data(0.3713907f, 0.5570861f, 0.7427813f,0.0f);
+
+      //we send a quaternion packed into a vec3 (w is infered) - so sizeof(vec) == 12 bytes not 16.
+      LLVector3 vec = data.packToVector3();
+
+      addValue(messageBlockData, (char *)"testBinData", &vec, MVT_LLQuaternion, sizeof(vec));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_LLQuaternion data works in a message copied from legacy to llsd",
+          ll_quaternion_from_sd(output["testBlock"][0]["testBinData"]), data);
+    }
+
+    // MVT_LLUUID
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<38>()
+    {
+      LLUUID data("01234567-0123-0123-0123-234567abcdef");
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLUUID, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      std::string v = output["testBlock"][0]["testBinData"].asUUID().asString();
+
+      ensure_equals("Ensure MVT_LLUUID data works in a message copied from legacy to llsd",
+          output["testBlock"][0]["testBinData"].asUUID(), data);
+    }
+
+    // MVT_BOOL
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<39>()
+    {
+      BOOL valueTrue = true;
+      BOOL valueFalse = false;
+
+      LLMsgData* md = new LLMsgData("testMessage");
+      LLMsgBlkData* mbd = new LLMsgBlkData("testBlock", 0);
+      addValue(mbd, (char *)"testBoolFalse", &valueFalse, MVT_BOOL, sizeof(BOOL));
+      addValue(mbd, (char *)"testBoolTrue", &valueTrue, MVT_BOOL, sizeof(BOOL));
+      md->addBlock(mbd);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*md);
+      LLSD output = builder.getMessage();
+
+      ensure("Ensure bools work in a message copied from legacy to llsd",
+          output["testBlock"][0]["testBoolTrue"].asBoolean() && !output["testBlock"][0]["testBoolFalse"].asBoolean());
+    }
+
+    // MVT_IP_ADDR
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<40>()
+    {
+      U32 data(0xff887766);
+      LLSD v = ll_sd_from_ipaddr(data);
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_IP_ADDR, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_IP_ADDR data works in a message copied from legacy to llsd",
+          output["testBlock"][0]["testBinData"], v);
+    }
+
+    // MVT_IP_PORT
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<41>()
+    {
+      U16 data = 0xff88;
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_IP_PORT, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      ensure_equals("Ensure MVT_IP_PORT data works in a message copied from legacy to llsd",
+          output["testBlock"][0]["testBinData"].asInteger(), data);
+    }
+
+    // MVT_U16Vec3
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<42>()
+    {
+      U16 data[3] = {0,1,2};
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_U16Vec3, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
+      ensure("Ensure MVT_U16Vec3 data copied from legacy to llsd give a valid vector", v.size() > 0);
+
+      ensure_memory_matches("Ensure MVT_U16Vec3 data works in a message copied from legacy to llsd",
+          (U16*)&v[0], 6, data, 6);
+    }
+
+    // MVT_U16Quat
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<43>()
+    {
+      U16 data[4] = {0,1,2,4};
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_U16Quat, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
+      ensure("Ensure MVT_U16Quat data copied from legacy to llsd give a valid vector", v.size() > 0);
+
+      ensure_memory_matches("Ensure MVT_U16Quat data works in a message copied from legacy to llsd",
+          (U16*)&v[0], 8, data, 8);
+    }
+
+    // MVT_S16Array
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<44>()
+    {
+      S16 data[19] = {0,-1,2,-4,5,-6,7,-8,9,-10,11,-12,13,-14,15,16,17,18};
+
+      addValue(messageBlockData, (char *)"testBinData", &data, MVT_S16Array, sizeof(data));
+      messageData->addBlock(messageBlockData);
+      LLSDMessageBuilder builder = defaultBuilder();
+
+      builder.copyFromMessageData(*messageData);
+      LLSD output = builder.getMessage();
+
+      std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
+      ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
+
+      ensure_memory_matches("Ensure MVT_S16Array data works in a message copied from legacy to llsd",
+          (U16*)&v[0], 19, data, 19);
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<45>()
+    {
+        LLMessageTemplate messageTemplate = defaultTemplate();
+        messageTemplate.addBlock(defaultTemplateBlock(MVT_U8, 1));
+        U8 inValue = 2;
+        LLTemplateMessageBuilder* template_builder = defaultTemplateBuilder(messageTemplate);
+        template_builder->addU8(_PREHASH_Test0, inValue);
+
+        LLSDMessageBuilder builder;
+        builder.copyFromMessageData(*template_builder->getCurrentMessage());
+        LLSD output = builder.getMessage();
+
+        ensure_equals(output["Test0"][0]["Test0"].asInteger(), 2);
+
+    }
+
+    template<> template<>
+    void LLSDMessageBuilderTestObject::test<46>()
+    {
+        LLMessageTemplate messageTemplate = defaultTemplate();
+        messageTemplate.addBlock(defaultTemplateBlock(MVT_VARIABLE, 1));
+        std::string inValue = "testing";
+        LLTemplateMessageBuilder* builder = defaultTemplateBuilder(messageTemplate);
+        builder->addString(_PREHASH_Test0, inValue.c_str());
+
+        LLSDMessageBuilder sd_builder;
+        sd_builder.copyFromMessageData(*builder->getCurrentMessage());
+        LLSD output = sd_builder.getMessage();
+
+        ensure_equals(output["Test0"][0]["Test0"].asString(), std::string("testing"));
+    }
 
 }
 
diff --git a/indra/test/llsdmessagereader_tut.cpp b/indra/test/llsdmessagereader_tut.cpp
index 3c402765d8..1d39fed0cb 100644
--- a/indra/test/llsdmessagereader_tut.cpp
+++ b/indra/test/llsdmessagereader_tut.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llsdmessagereader_tut.cpp
  * @date   February 2006
  * @brief LLSDMessageReader unit tests
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2006&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -39,286 +39,286 @@
 #include "llsdutil_math.h"
 
 namespace tut
-{	
-	struct LLSDMessageReaderTestData {
-		static void ensureMessageName(const std::string& msg_name,
-									const LLSD& msg_data,
-									const std::string& expected_name)
-		{
-			LLSDMessageReader msg;
-			msg.setMessage(LLMessageStringTable::getInstance()->getString(msg_name.c_str()), msg_data);
-			ensure_equals("Ensure name", std::string(msg.getMessageName()), 
-						  expected_name);
-		}
+{
+    struct LLSDMessageReaderTestData {
+        static void ensureMessageName(const std::string& msg_name,
+                                    const LLSD& msg_data,
+                                    const std::string& expected_name)
+        {
+            LLSDMessageReader msg;
+            msg.setMessage(LLMessageStringTable::getInstance()->getString(msg_name.c_str()), msg_data);
+            ensure_equals("Ensure name", std::string(msg.getMessageName()),
+                          expected_name);
+        }
+
+        static void ensureNumberOfBlocks(const LLSD& msg_data,
+                                    const std::string& block,
+                                    S32 expected_number)
+        {
+            LLSDMessageReader msg;
+            msg.setMessage("fakename", msg_data);
+            ensure_equals("Ensure number of blocks", msg.getNumberOfBlocks(block.c_str()),
+                          expected_number);
+        }
+
+        static void ensureMessageSize(const LLSD& msg_data,
+                                    S32 expected_size)
+        {
+            LLSDMessageReader msg;
+            msg.setMessage("fakename", msg_data);
+            ensure_equals(  "Ensure size",  msg.getMessageSize(), expected_size);
+        }
+
+        static void ensureBool(const LLSD& msg_data,
+                                const std::string& block,
+                                const std::string& var,
+                                S32 blocknum,
+                                BOOL expected)
+        {
+            LLSDMessageReader msg;
+            msg.setMessage("fakename", msg_data);
+            BOOL test_data;
+            msg.getBOOL(block.c_str(), var.c_str(), test_data, blocknum);
+            ensure_equals(  "Ensure bool field", test_data, expected);
+        }
+    };
+
+    typedef test_group<LLSDMessageReaderTestData>   LLSDMessageReaderTestGroup;
+    typedef LLSDMessageReaderTestGroup::object      LLSDMessageReaderTestObject;
+    LLSDMessageReaderTestGroup llsdMessageReaderTestGroup("LLSDMessageReader");
+
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<1>()
+        // construction and test of empty LLSD
+    {
+        LLSD message = LLSD::emptyMap();
+
+        ensureMessageName("", message, "");
+        ensureNumberOfBlocks(message, "Fakeblock", 0);
+        ensureMessageSize(message, 0);
+    }
+
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<2>()
+        // construction and test of simple message with one block
+    {
+        LLSD message = LLSD::emptyMap();
+        message["block1"] = LLSD::emptyArray();
+        message["block1"][0] = LLSD::emptyMap();
+        message["block1"][0]["Field1"] = 0;
 
-		static void ensureNumberOfBlocks(const LLSD& msg_data,
-									const std::string& block,
-									S32 expected_number)
-		{
-			LLSDMessageReader msg;
-			msg.setMessage("fakename", msg_data);
-			ensure_equals("Ensure number of blocks", msg.getNumberOfBlocks(block.c_str()), 
-						  expected_number);
-		}
+        ensureMessageName("name2", message, "name2");
+        ensureNumberOfBlocks(message, "block1", 1);
+        ensureMessageSize(message, 0);
+    }
 
-		static void ensureMessageSize(const LLSD& msg_data,
-									S32 expected_size)
-		{
-			LLSDMessageReader msg;
-			msg.setMessage("fakename", msg_data);
-			ensure_equals(	"Ensure size",	msg.getMessageSize(), expected_size);
-		}
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<3>()
+        // multiple blocks
+    {
+        LLSD message = LLSD::emptyMap();
+        message["block1"] = LLSD::emptyArray();
+        BOOL bool_true = TRUE;
+        BOOL bool_false = FALSE;
+        message["block1"][0] = LLSD::emptyMap();
+        message["block1"][0]["BoolField1"] = bool_true;
+        message["block1"][1] = LLSD::emptyMap();
+        message["block1"][1]["BoolField1"] = bool_false;
+        message["block1"][1]["BoolField2"] = bool_true;
 
-		static void ensureBool(const LLSD& msg_data,
-								const std::string& block,
-								const std::string& var,
-								S32 blocknum,
-								BOOL expected)
-		{
-			LLSDMessageReader msg;
-			msg.setMessage("fakename", msg_data);
-			BOOL test_data;
-			msg.getBOOL(block.c_str(), var.c_str(), test_data, blocknum);
- 			ensure_equals(	"Ensure bool field", test_data, expected);
- 		}
- 	};
-	
- 	typedef test_group<LLSDMessageReaderTestData>	LLSDMessageReaderTestGroup;
- 	typedef LLSDMessageReaderTestGroup::object		LLSDMessageReaderTestObject;
- 	LLSDMessageReaderTestGroup llsdMessageReaderTestGroup("LLSDMessageReader");
-	
- 	template<> template<>
- 	void LLSDMessageReaderTestObject::test<1>()
- 		// construction and test of empty LLSD
- 	{
- 		LLSD message = LLSD::emptyMap();
+        ensureMessageName("name3", message, "name3");
+        ensureBool(message, "block1", "BoolField1", 0, TRUE);
+        ensureBool(message, "block1", "BoolField1", 1, FALSE);
+        ensureBool(message, "block1", "BoolField2", 1, TRUE);
+        ensureNumberOfBlocks(message, "block1", 2);
+        ensureMessageSize(message, 0);
+    }
 
- 		ensureMessageName("", message, "");
- 		ensureNumberOfBlocks(message, "Fakeblock", 0);
- 		ensureMessageSize(message, 0);
- 	}
-	
- 	template<> template<>
- 	void LLSDMessageReaderTestObject::test<2>()
- 		// construction and test of simple message with one block
- 	{
- 		LLSD message = LLSD::emptyMap();
- 		message["block1"] = LLSD::emptyArray();
- 		message["block1"][0] = LLSD::emptyMap();
- 		message["block1"][0]["Field1"] = 0;
+    template<typename T>
+    LLSDMessageReader testType(const T& value)
+    {
+        LLSD message = LLSD::emptyMap();
+        message["block"][0]["var"] = value;
+        LLSDMessageReader msg;
+        msg.setMessage("fakename", message);
+        return msg;
+    }
 
- 		ensureMessageName("name2", message, "name2");
- 		ensureNumberOfBlocks(message, "block1", 1);
- 		ensureMessageSize(message, 0);
- 	}
-	
- 	template<> template<>
- 	void LLSDMessageReaderTestObject::test<3>()
- 		// multiple blocks
- 	{
- 		LLSD message = LLSD::emptyMap();
- 		message["block1"] = LLSD::emptyArray();
- 		BOOL bool_true = TRUE;
- 		BOOL bool_false = FALSE;
- 		message["block1"][0] = LLSD::emptyMap();
- 		message["block1"][0]["BoolField1"] = bool_true;
-		message["block1"][1] = LLSD::emptyMap();
- 		message["block1"][1]["BoolField1"] = bool_false;
- 		message["block1"][1]["BoolField2"] = bool_true;
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<4>()
+        // S8
+    {
+        S8 outValue, inValue = -3;
+        LLSDMessageReader msg = testType(inValue);
+        msg.getS8("block", "var", outValue);
+        ensure_equals("Ensure S8", outValue, inValue);
+    }
+    template<> template<>
+    void
+    LLSDMessageReaderTestObject::test<5>()
+        // U8
+    {
+        U8 outValue, inValue = 2;
+        LLSDMessageReader msg = testType(inValue);
+        msg.getU8("block", "var", outValue);
+        ensure_equals("Ensure U8", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<6>()
+        // S16
+    {
+        S16 outValue, inValue = 90;
+        LLSDMessageReader msg = testType(inValue);
+        msg.getS16("block", "var", outValue);
+        ensure_equals("Ensure S16", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<7>()
+        // U16
+    {
+        U16 outValue, inValue = 3;
+        LLSDMessageReader msg = testType(inValue);
+        msg.getU16("block", "var", outValue);
+        ensure_equals("Ensure S16", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<8>()
+        // S32
+    {
+        S32 outValue, inValue = 44;
+        LLSDMessageReader msg = testType(inValue);
+        msg.getS32("block", "var", outValue);
+        ensure_equals("Ensure S32", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<9>()
+        // F32
+    {
+        F32 outValue, inValue = 121.44f;
+        LLSDMessageReader msg = testType(inValue);
+        msg.getF32("block", "var", outValue);
+        ensure_equals("Ensure F32", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<10>()
+        // U32
+    {
+        U32 outValue, inValue = 88;
+        LLSD sdValue = ll_sd_from_U32(inValue);
+        LLSDMessageReader msg = testType(sdValue);
+        msg.getU32("block", "var", outValue);
+        ensure_equals("Ensure U32", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<11>()
+        // U64
+    {
+        U64 outValue, inValue = 121;
+        LLSD sdValue = ll_sd_from_U64(inValue);
+        LLSDMessageReader msg = testType(sdValue);
+        msg.getU64("block", "var", outValue);
+        ensure_equals("Ensure U64", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<12>()
+        // F64
+    {
+        F64 outValue, inValue = 3232143.33;
+        LLSDMessageReader msg = testType(inValue);
+        msg.getF64("block", "var", outValue);
+        ensure_equals("Ensure F64", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<13>()
+        // String
+    {
+         std::string outValue, inValue = "testing";
+        LLSDMessageReader msg = testType<std::string>(inValue.c_str());
 
- 		ensureMessageName("name3", message, "name3");
- 		ensureBool(message, "block1", "BoolField1", 0, TRUE);
- 		ensureBool(message, "block1", "BoolField1", 1, FALSE);
- 		ensureBool(message, "block1", "BoolField2", 1, TRUE);
- 		ensureNumberOfBlocks(message, "block1", 2);
- 		ensureMessageSize(message, 0);
- 	}
-	
- 	template<typename T>
- 	LLSDMessageReader testType(const T& value)
- 	{
- 		LLSD message = LLSD::emptyMap();
- 		message["block"][0]["var"] = value;
- 		LLSDMessageReader msg;
- 		msg.setMessage("fakename", message);
- 		return msg;
- 	}
+        char buffer[MAX_STRING];
+        msg.getString("block", "var", MAX_STRING, buffer);
+        outValue = buffer;
+        ensure_equals("Ensure String", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<14>()
+        // Vector3
+    {
+         LLVector3 outValue, inValue = LLVector3(1,2,3);
+        LLSD sdValue = ll_sd_from_vector3(inValue);
+        LLSDMessageReader msg = testType(sdValue);
+        msg.getVector3("block", "var", outValue);
+        ensure_equals("Ensure Vector3", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<15>()
+        // Vector4
+    {
+        LLVector4 outValue, inValue = LLVector4(1,2,3,4);
+        LLSD sdValue = ll_sd_from_vector4(inValue);
+        LLSDMessageReader msg = testType(sdValue);
+        msg.getVector4("block", "var", outValue);
+        ensure_equals("Ensure Vector4", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<16>()
+        // Vector3d
+    {
+         LLVector3d outValue, inValue = LLVector3d(1,2,3);
+         LLSD sdValue = ll_sd_from_vector3d(inValue);
+        LLSDMessageReader msg = testType(sdValue);
+        msg.getVector3d("block", "var", outValue);
+        ensure_equals("Ensure Vector3d", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<17>()
+        // Quaternion
+    {
+        LLQuaternion outValue, inValue = LLQuaternion(1,LLVector3(2,3,4));
+        LLSD sdValue = ll_sd_from_quaternion(inValue);
+        LLSDMessageReader msg = testType(sdValue);
+        msg.getQuat("block", "var", outValue);
+        ensure_equals("Ensure Quaternion", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<18>()
+        // UUID
+    {
+        LLUUID outValue, inValue;
+        inValue.generate();
+        LLSDMessageReader msg = testType(inValue);
+        msg.getUUID("block", "var", outValue);
+        ensure_equals("Ensure UUID", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<19>()
+        // IPAddr
+    {
+        U32 outValue, inValue = 12344556;
+        LLSD sdValue = ll_sd_from_ipaddr(inValue);
+        LLSDMessageReader msg = testType(sdValue);
+        msg.getIPAddr("block", "var", outValue);
+        ensure_equals("Ensure IPAddr", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<20>()
+        // IPPort
+    {
+        U16 outValue, inValue = 80;
+        LLSDMessageReader msg = testType(inValue);
+        msg.getIPPort("block", "var", outValue);
+        ensure_equals("Ensure IPPort", outValue, inValue);
+    }
+    template<> template<>
+    void LLSDMessageReaderTestObject::test<21>()
+        // Binary
+    {
+        std::vector<U8> outValue(2), inValue(2);
+        inValue[0] = 0;
+        inValue[1] = 1;
 
- 	template<> template<>
- 	void LLSDMessageReaderTestObject::test<4>()
- 		// S8
- 	{
- 		S8 outValue, inValue = -3;
- 		LLSDMessageReader msg = testType(inValue);
- 		msg.getS8("block", "var", outValue);
- 		ensure_equals("Ensure S8", outValue, inValue);
- 	}
- 	template<> template<>
- 	void 
-	LLSDMessageReaderTestObject::test<5>()
-		// U8
-	{
-		U8 outValue, inValue = 2;
-		LLSDMessageReader msg = testType(inValue);
-		msg.getU8("block", "var", outValue);
-		ensure_equals("Ensure U8", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<6>()
-		// S16
-	{
-		S16 outValue, inValue = 90;
-		LLSDMessageReader msg = testType(inValue);
-		msg.getS16("block", "var", outValue);
-		ensure_equals("Ensure S16", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<7>()
-		// U16
-	{
-		U16 outValue, inValue = 3;
-		LLSDMessageReader msg = testType(inValue);
-		msg.getU16("block", "var", outValue);
-		ensure_equals("Ensure S16", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<8>()
-		// S32
-	{
-		S32 outValue, inValue = 44;
-		LLSDMessageReader msg = testType(inValue);
-		msg.getS32("block", "var", outValue);
-		ensure_equals("Ensure S32", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<9>()
-		// F32
-	{
-		F32 outValue, inValue = 121.44f;
-		LLSDMessageReader msg = testType(inValue);
-		msg.getF32("block", "var", outValue);
-		ensure_equals("Ensure F32", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<10>()
-		// U32
-	{
-		U32 outValue, inValue = 88;
-		LLSD sdValue = ll_sd_from_U32(inValue);
-		LLSDMessageReader msg = testType(sdValue);
-		msg.getU32("block", "var", outValue);
-		ensure_equals("Ensure U32", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<11>()
-		// U64
-	{
-		U64 outValue, inValue = 121;
-		LLSD sdValue = ll_sd_from_U64(inValue);
-		LLSDMessageReader msg = testType(sdValue);
-		msg.getU64("block", "var", outValue);
-		ensure_equals("Ensure U64", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<12>()
-		// F64
-	{
-		F64 outValue, inValue = 3232143.33;
-		LLSDMessageReader msg = testType(inValue);
-		msg.getF64("block", "var", outValue);
-		ensure_equals("Ensure F64", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<13>()
-		// String
-	{
-		 std::string outValue, inValue = "testing";
-		LLSDMessageReader msg = testType<std::string>(inValue.c_str());
-		
-		char buffer[MAX_STRING];
-		msg.getString("block", "var", MAX_STRING, buffer);
-		outValue = buffer;
-		ensure_equals("Ensure String", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<14>()
-		// Vector3
-	{
-		 LLVector3 outValue, inValue = LLVector3(1,2,3);
-		LLSD sdValue = ll_sd_from_vector3(inValue);
-		LLSDMessageReader msg = testType(sdValue);
-		msg.getVector3("block", "var", outValue);
-		ensure_equals("Ensure Vector3", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<15>()
-		// Vector4
-	{
-		LLVector4 outValue, inValue = LLVector4(1,2,3,4);
-		LLSD sdValue = ll_sd_from_vector4(inValue);
-		LLSDMessageReader msg = testType(sdValue);
-		msg.getVector4("block", "var", outValue);
-		ensure_equals("Ensure Vector4", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<16>()
-		// Vector3d
-	{
-		 LLVector3d outValue, inValue = LLVector3d(1,2,3);
-		 LLSD sdValue = ll_sd_from_vector3d(inValue);
-		LLSDMessageReader msg = testType(sdValue);
-		msg.getVector3d("block", "var", outValue);
-		ensure_equals("Ensure Vector3d", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<17>()
-		// Quaternion
-	{
-		LLQuaternion outValue, inValue = LLQuaternion(1,LLVector3(2,3,4));
-		LLSD sdValue = ll_sd_from_quaternion(inValue);
-		LLSDMessageReader msg = testType(sdValue);
-		msg.getQuat("block", "var", outValue);
-		ensure_equals("Ensure Quaternion", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<18>()
-		// UUID
-	{
-		LLUUID outValue, inValue;
-		inValue.generate();
-		LLSDMessageReader msg = testType(inValue);
-		msg.getUUID("block", "var", outValue);
-		ensure_equals("Ensure UUID", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<19>()
-		// IPAddr
-	{
-		U32 outValue, inValue = 12344556;
-		LLSD sdValue = ll_sd_from_ipaddr(inValue);
-		LLSDMessageReader msg = testType(sdValue);
-		msg.getIPAddr("block", "var", outValue);
-		ensure_equals("Ensure IPAddr", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<20>()
-		// IPPort
-	{
-		U16 outValue, inValue = 80;
-		LLSDMessageReader msg = testType(inValue);
-		msg.getIPPort("block", "var", outValue);
-		ensure_equals("Ensure IPPort", outValue, inValue);
-	}
-	template<> template<>
-	void LLSDMessageReaderTestObject::test<21>()
-		// Binary 
-	{
-		std::vector<U8> outValue(2), inValue(2);
-		inValue[0] = 0;
-		inValue[1] = 1;
-	  
-		LLSDMessageReader msg = testType(inValue);
-		msg.getBinaryData("block", "var", &(outValue[0]), inValue.size());
-		ensure_equals("Ensure Binary", outValue, inValue);
-	}
+        LLSDMessageReader msg = testType(inValue);
+        msg.getBinaryData("block", "var", &(outValue[0]), inValue.size());
+        ensure_equals("Ensure Binary", outValue, inValue);
+    }
 }
diff --git a/indra/test/llsdtraits.h b/indra/test/llsdtraits.h
index 07f6193ce2..c872f101d0 100644
--- a/indra/test/llsdtraits.h
+++ b/indra/test/llsdtraits.h
@@ -5,21 +5,21 @@
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -34,48 +34,48 @@ template<class T>
 class LLSDTraits
 {
  protected:
-	typedef T (LLSD::*Getter)() const;
-	
-	LLSD::Type type;
-	Getter getter;
-	
+    typedef T (LLSD::*Getter)() const;
+
+    LLSD::Type type;
+    Getter getter;
+
  public:
-	LLSDTraits();
-	
-	T get(const LLSD& actual)
-		{
-			return (actual.*getter)();
-		}
-	
-	bool checkType(const LLSD& actual)
-		{
-			return actual.type() == type;
-		}
+    LLSDTraits();
+
+    T get(const LLSD& actual)
+        {
+            return (actual.*getter)();
+        }
+
+    bool checkType(const LLSD& actual)
+        {
+            return actual.type() == type;
+        }
 };
 
 template<> inline
 LLSDTraits<LLSD::Boolean>::LLSDTraits()
-	: type(LLSD::TypeBoolean), getter(&LLSD::asBoolean)
+    : type(LLSD::TypeBoolean), getter(&LLSD::asBoolean)
 { }
 
 template<> inline
 LLSDTraits<LLSD::Integer>::LLSDTraits()
-	: type(LLSD::TypeInteger), getter(&LLSD::asInteger)
+    : type(LLSD::TypeInteger), getter(&LLSD::asInteger)
 { }
 
 template<> inline
 LLSDTraits<LLSD::Real>::LLSDTraits()
-	: type(LLSD::TypeReal), getter(&LLSD::asReal)
+    : type(LLSD::TypeReal), getter(&LLSD::asReal)
 { }
 
 template<> inline
 LLSDTraits<LLSD::UUID>::LLSDTraits()
-	: type(LLSD::TypeUUID), getter(&LLSD::asUUID)
+    : type(LLSD::TypeUUID), getter(&LLSD::asUUID)
 { }
 
 template<> inline
 LLSDTraits<LLSD::String>::LLSDTraits()
-	: type(LLSD::TypeString), getter(&LLSD::asString)
+    : type(LLSD::TypeString), getter(&LLSD::asString)
 { }
 
 template<>
@@ -84,17 +84,17 @@ class LLSDTraits<const char*> : public LLSDTraits<LLSD::String>
 
 template<> inline
 LLSDTraits<LLSD::Date>::LLSDTraits()
-	: type(LLSD::TypeDate), getter(&LLSD::asDate)
+    : type(LLSD::TypeDate), getter(&LLSD::asDate)
 { }
 
 template<> inline
 LLSDTraits<LLSD::URI>::LLSDTraits()
-	: type(LLSD::TypeURI), getter(&LLSD::asURI)
+    : type(LLSD::TypeURI), getter(&LLSD::asURI)
 { }
 
 template<> inline
 LLSDTraits<const LLSD::Binary&>::LLSDTraits()
-	: type(LLSD::TypeBinary), getter(&LLSD::asBinary)
+    : type(LLSD::TypeBinary), getter(&LLSD::asBinary)
 { }
 
 #endif // LLSDTRAITS_H
diff --git a/indra/test/llsdutil_tut.cpp b/indra/test/llsdutil_tut.cpp
index 22efd5439a..4b25a02f30 100644
--- a/indra/test/llsdutil_tut.cpp
+++ b/indra/test/llsdutil_tut.cpp
@@ -7,21 +7,21 @@
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -45,8 +45,8 @@
 
 namespace tut
 {
-	struct llsdutil_data
-	{
+    struct llsdutil_data
+    {
         void test_matches(const std::string& proto_key, const LLSD& possibles,
                           const char** begin, const char** end)
         {
@@ -74,115 +74,115 @@ namespace tut
                 }
             }
         }
-	};
-	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);
-	}
+    };
+    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);
+    }
 
     template<> template<>
     void llsdutil_object::test<9>()
@@ -387,7 +387,7 @@ namespace tut
         ensure("llsd_equals(superset left map)", ! llsd_equals(lmap, rmap));
     }
 
-    template<> template<> 
+    template<> template<>
     void llsdutil_object::test<10>()
     {
         set_test_name("llsd_hashing");
diff --git a/indra/test/llservicebuilder_tut.cpp b/indra/test/llservicebuilder_tut.cpp
index 8f5be3011c..0bc17865d6 100644
--- a/indra/test/llservicebuilder_tut.cpp
+++ b/indra/test/llservicebuilder_tut.cpp
@@ -6,21 +6,21 @@
 * $LicenseInfo:firstyear=2006&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
-* 
+*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
-* 
+*
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
-* 
+*
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-* 
+*
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */
@@ -35,139 +35,139 @@
 namespace tut
 {
 
-	struct ServiceBuilderTestData {
-		LLServiceBuilder mServiceBuilder;
-	};
-
-	typedef test_group<ServiceBuilderTestData>	ServiceBuilderTestGroup;
-	typedef ServiceBuilderTestGroup::object	ServiceBuilderTestObject;
-
-	ServiceBuilderTestGroup serviceBuilderTestGroup("ServiceBuilder");
-
-	template<> template<>
-	void ServiceBuilderTestObject::test<1>()
-	{
-		//Simple service build and reply with no mapping
-		LLSD test_block;
-		test_block["service-builder"] = "/agent/name";
-		mServiceBuilder.createServiceDefinition("ServiceBuilderTest", test_block["service-builder"]);
-		std::string test_url = mServiceBuilder.buildServiceURI("ServiceBuilderTest");
-		ensure_equals("Basic URL Creation", test_url , "/agent/name");
-	}	
-
-	template<> template<>
-	void ServiceBuilderTestObject::test<2>()
-	{
-		//Simple replace test
-		LLSD test_block;
-		test_block["service-builder"] = "/agent/{$agent-id}/name";
-		mServiceBuilder.createServiceDefinition("ServiceBuilderTest", test_block["service-builder"]);	
-		LLSD data_map;
-		data_map["agent-id"] = "257c631f-a0c5-4f29-8a9f-9031feaae6c6";
-		std::string test_url = mServiceBuilder.buildServiceURI("ServiceBuilderTest", data_map);
-		ensure_equals("Replacement URL Creation", test_url , "/agent/257c631f-a0c5-4f29-8a9f-9031feaae6c6/name");
-	}	
-
-	template<> template<>
-	void ServiceBuilderTestObject::test<3>()
-	{
-		//Incorrect service test
-		LLSD test_block;
-		test_block["service-builder"] = "/agent/{$agent-id}/name";
-		mServiceBuilder.createServiceDefinition("ServiceBuilderTest", test_block["service-builder"]);	
-		std::string test_url = mServiceBuilder.buildServiceURI("ServiceBuilder");
-		ensure_equals("Replacement URL Creation for Non-existant Service", test_url , "");
-	}
-
-	template<> template<>
-	void ServiceBuilderTestObject::test<4>()
-	{
-		//Incorrect service test
-		LLSD test_block;
-		test_block["service-builder"] = "/agent/{$agent-id}/name";
-		mServiceBuilder.createServiceDefinition("ServiceBuilderTest", test_block["service-builder"]);
-		LLSD data_map;
-		data_map["agent_id"] = "257c631f-a0c5-4f29-8a9f-9031feaae6c6";
-		std::string test_url = mServiceBuilder.buildServiceURI("ServiceBuilderTest", data_map);
-		ensure_equals("Replacement URL Creation for Non-existant Service", test_url , "/agent/{$agent-id}/name");
-	}
-
-	template<> template<>
-	void ServiceBuilderTestObject::test<5>()
-	{
-		LLSD test_block;
-		test_block["service-builder"] = "/proc/{$proc}{%params}";
-		mServiceBuilder.createServiceDefinition("ServiceBuilderTest", test_block["service-builder"]);	
-		LLSD data_map;
-		data_map["proc"] = "do/something/useful";
-		data_map["params"]["estate_id"] = 1;
-		data_map["params"]["query"] = "public";
-		std::string test_url = mServiceBuilder.buildServiceURI("ServiceBuilderTest", data_map);
-		ensure_equals(
-			"two part URL Creation",
-			test_url ,
-			"/proc/do/something/useful?estate_id=1&query=public");
-	}
-
-	template<> template<>
-	void ServiceBuilderTestObject::test<6>()
-	{
-		LLSD test_block;
-		test_block["service-builder"] = "Which way to the {${$baz}}?";
-		mServiceBuilder.createServiceDefinition(
-			"ServiceBuilderTest",
-			test_block["service-builder"]);	
-
-		LLSD data_map;
-		data_map["foo"] = "bar";
-		data_map["baz"] = "foo";
-		std::string test_url = mServiceBuilder.buildServiceURI(
-			"ServiceBuilderTest",
-			data_map);
-		ensure_equals(
-			"recursive url creation",
-			test_url ,
-			"Which way to the bar?");
-	}
-
-	template<> template<>
-	void ServiceBuilderTestObject::test<7>()
-	{
-		LLSD test_block;
-		test_block["service-builder"] = "Which way to the {$foo}?";
-		mServiceBuilder.createServiceDefinition(
-			"ServiceBuilderTest",
-			test_block["service-builder"]);	
-
-		LLSD data_map;
-		data_map["baz"] = "foo";
-		std::string test_url = mServiceBuilder.buildServiceURI(
-			"ServiceBuilderTest",
-			data_map);
-		ensure_equals(
-			"fails to do replacement",
-			test_url ,
-			"Which way to the {$foo}?");
-	}
-
-	template<> template<>
-	void ServiceBuilderTestObject::test<8>()
-	{
-		LLSD test_block;
-		test_block["service-builder"] = "/proc/{$proc}{%params}";
-		mServiceBuilder.createServiceDefinition(
-			"ServiceBuilderTest",
-			test_block["service-builder"]);	
-		LLSD data_map;
-		data_map["proc"] = "do/something/useful";
-		data_map["params"] = LLSD();
-		std::string test_url = mServiceBuilder.buildServiceURI(
-			"ServiceBuilderTest",
-			data_map);
-		ensure_equals(
-			"strip params",
-			test_url ,
-			"/proc/do/something/useful");
-	}
+    struct ServiceBuilderTestData {
+        LLServiceBuilder mServiceBuilder;
+    };
+
+    typedef test_group<ServiceBuilderTestData>  ServiceBuilderTestGroup;
+    typedef ServiceBuilderTestGroup::object ServiceBuilderTestObject;
+
+    ServiceBuilderTestGroup serviceBuilderTestGroup("ServiceBuilder");
+
+    template<> template<>
+    void ServiceBuilderTestObject::test<1>()
+    {
+        //Simple service build and reply with no mapping
+        LLSD test_block;
+        test_block["service-builder"] = "/agent/name";
+        mServiceBuilder.createServiceDefinition("ServiceBuilderTest", test_block["service-builder"]);
+        std::string test_url = mServiceBuilder.buildServiceURI("ServiceBuilderTest");
+        ensure_equals("Basic URL Creation", test_url , "/agent/name");
+    }
+
+    template<> template<>
+    void ServiceBuilderTestObject::test<2>()
+    {
+        //Simple replace test
+        LLSD test_block;
+        test_block["service-builder"] = "/agent/{$agent-id}/name";
+        mServiceBuilder.createServiceDefinition("ServiceBuilderTest", test_block["service-builder"]);
+        LLSD data_map;
+        data_map["agent-id"] = "257c631f-a0c5-4f29-8a9f-9031feaae6c6";
+        std::string test_url = mServiceBuilder.buildServiceURI("ServiceBuilderTest", data_map);
+        ensure_equals("Replacement URL Creation", test_url , "/agent/257c631f-a0c5-4f29-8a9f-9031feaae6c6/name");
+    }
+
+    template<> template<>
+    void ServiceBuilderTestObject::test<3>()
+    {
+        //Incorrect service test
+        LLSD test_block;
+        test_block["service-builder"] = "/agent/{$agent-id}/name";
+        mServiceBuilder.createServiceDefinition("ServiceBuilderTest", test_block["service-builder"]);
+        std::string test_url = mServiceBuilder.buildServiceURI("ServiceBuilder");
+        ensure_equals("Replacement URL Creation for Non-existant Service", test_url , "");
+    }
+
+    template<> template<>
+    void ServiceBuilderTestObject::test<4>()
+    {
+        //Incorrect service test
+        LLSD test_block;
+        test_block["service-builder"] = "/agent/{$agent-id}/name";
+        mServiceBuilder.createServiceDefinition("ServiceBuilderTest", test_block["service-builder"]);
+        LLSD data_map;
+        data_map["agent_id"] = "257c631f-a0c5-4f29-8a9f-9031feaae6c6";
+        std::string test_url = mServiceBuilder.buildServiceURI("ServiceBuilderTest", data_map);
+        ensure_equals("Replacement URL Creation for Non-existant Service", test_url , "/agent/{$agent-id}/name");
+    }
+
+    template<> template<>
+    void ServiceBuilderTestObject::test<5>()
+    {
+        LLSD test_block;
+        test_block["service-builder"] = "/proc/{$proc}{%params}";
+        mServiceBuilder.createServiceDefinition("ServiceBuilderTest", test_block["service-builder"]);
+        LLSD data_map;
+        data_map["proc"] = "do/something/useful";
+        data_map["params"]["estate_id"] = 1;
+        data_map["params"]["query"] = "public";
+        std::string test_url = mServiceBuilder.buildServiceURI("ServiceBuilderTest", data_map);
+        ensure_equals(
+            "two part URL Creation",
+            test_url ,
+            "/proc/do/something/useful?estate_id=1&query=public");
+    }
+
+    template<> template<>
+    void ServiceBuilderTestObject::test<6>()
+    {
+        LLSD test_block;
+        test_block["service-builder"] = "Which way to the {${$baz}}?";
+        mServiceBuilder.createServiceDefinition(
+            "ServiceBuilderTest",
+            test_block["service-builder"]);
+
+        LLSD data_map;
+        data_map["foo"] = "bar";
+        data_map["baz"] = "foo";
+        std::string test_url = mServiceBuilder.buildServiceURI(
+            "ServiceBuilderTest",
+            data_map);
+        ensure_equals(
+            "recursive url creation",
+            test_url ,
+            "Which way to the bar?");
+    }
+
+    template<> template<>
+    void ServiceBuilderTestObject::test<7>()
+    {
+        LLSD test_block;
+        test_block["service-builder"] = "Which way to the {$foo}?";
+        mServiceBuilder.createServiceDefinition(
+            "ServiceBuilderTest",
+            test_block["service-builder"]);
+
+        LLSD data_map;
+        data_map["baz"] = "foo";
+        std::string test_url = mServiceBuilder.buildServiceURI(
+            "ServiceBuilderTest",
+            data_map);
+        ensure_equals(
+            "fails to do replacement",
+            test_url ,
+            "Which way to the {$foo}?");
+    }
+
+    template<> template<>
+    void ServiceBuilderTestObject::test<8>()
+    {
+        LLSD test_block;
+        test_block["service-builder"] = "/proc/{$proc}{%params}";
+        mServiceBuilder.createServiceDefinition(
+            "ServiceBuilderTest",
+            test_block["service-builder"]);
+        LLSD data_map;
+        data_map["proc"] = "do/something/useful";
+        data_map["params"] = LLSD();
+        std::string test_url = mServiceBuilder.buildServiceURI(
+            "ServiceBuilderTest",
+            data_map);
+        ensure_equals(
+            "strip params",
+            test_url ,
+            "/proc/do/something/useful");
+    }
 }
 
diff --git a/indra/test/llstreamtools_tut.cpp b/indra/test/llstreamtools_tut.cpp
index 2f027b688f..68bd5e0ec9 100644
--- a/indra/test/llstreamtools_tut.cpp
+++ b/indra/test/llstreamtools_tut.cpp
@@ -7,25 +7,25 @@
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
- 
+
 #include <tut/tut.hpp>
 
 #include "linden_common.h"
@@ -35,849 +35,849 @@
 
 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. ##");
-		ensure("should not be good()", ! skip_comments_and_emptyspace(is));
-		ensure("should be at eof()", is.eof());
-		// don't get(): given bad state, we can't rely on results
-
-		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);
-		ensure("skip_comments_and_emptyspace: empty string", ! ret);
-
-		is.clear();
-		is.str(str = "  \r\n  \t # SecondLife is a 3D World");
-		ret = skip_comments_and_emptyspace(is);
-		ensure("skip_comments_and_emptyspace: space newline comment empty", ! ret);
-	}
-	
-	//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;
-
-		is.clear();
-		is.str(str = "  First Second \t \r  \n Third  Fourth-ShouldThisBePartOfFourth  Fifth\n");
-		actual_result = "";
-		get_word(actual_result, is); // First
-		actual_result = "";
-		get_word(actual_result, is); // Second
-		actual_result = "";
-		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 = "";
-		get_word(actual_result, is); // will copy Fourth-ShouldThisBePartOfFourth
-
-		actual_result = "";
-		get_word(actual_result, is); // will copy Fifth
-
-		is.clear();
-		is.str(str = "  First Second \t \r  \n Third  Fourth_ShouldThisBePartOfFourth Fifth\n");
-		skip_to_next_word(is);  // should now point to First
-		skip_to_next_word(is);  // should now point to Second
-		skip_to_next_word(is);  // should now point to Third
-		skip_to_next_word(is);  // should now point to Fourth
-		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"
-		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;
-
-		is.clear();
-		is.str(str = "First Second \t \r\n Third  Fourth-ShouldThisBePartOfFourth  IsThisFifth\n");
-		actual_result = "";
-		get_line(actual_result, is);
-		expected_result = "First Second \t \r\n";
-		ensure_equals("get_line: 1", actual_result, expected_result);
-
-		actual_result = "";
-		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 = "";
-		get_line(actual_result, is);
-		expected_result = "\n";
-		ensure_equals("get_line: First char as newline", actual_result, expected_result);
-
-		actual_result = "";
-		get_line(actual_result, is);
-		expected_result = "First Line.\n";
-		ensure_equals("get_line: 3", actual_result, expected_result);
-
-		actual_result = "";
-		get_line(actual_result, is);
-		expected_result = "\n";
-		ensure_equals("get_line: 4", actual_result, expected_result);
-
-		actual_result = "";
-		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>()
-	{
-		std::string str;
-		std::string expected_result;
-		std::string actual_result;
-		std::istringstream is;
-
-		// need to be check if this test case is wrong or the implementation is wrong.
-		is.clear();
-		is.str(str = "Should not skip lone \r.\r\n");
-		actual_result = "";
-		get_line(actual_result, is);
-		expected_result = "Should not skip lone \r.\r\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;
-
-		is.clear();
-		is.str(str = "\n");
-		actual_result = "";
-		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;
-
-		is.clear();
-		is.str(str = "First Line.\nSecond Line.\n");
-		actual_result = "";
-		get_line(actual_result, is, 255);
-		expected_result = "First Line.\n";
-		ensure_equals("get_line: Basic Operation", actual_result, expected_result);
-
-		actual_result = "";
-		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 = "";
-		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 = "";
-		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 = "";
-		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>()
-	{
-	}
-
-	//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>()
-	{
-		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>()
-	{
-		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);
-	}
+    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. ##");
+        ensure("should not be good()", ! skip_comments_and_emptyspace(is));
+        ensure("should be at eof()", is.eof());
+        // don't get(): given bad state, we can't rely on results
+
+        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);
+        ensure("skip_comments_and_emptyspace: empty string", ! ret);
+
+        is.clear();
+        is.str(str = "  \r\n  \t # SecondLife is a 3D World");
+        ret = skip_comments_and_emptyspace(is);
+        ensure("skip_comments_and_emptyspace: space newline comment empty", ! ret);
+    }
+
+    //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;
+
+        is.clear();
+        is.str(str = "  First Second \t \r  \n Third  Fourth-ShouldThisBePartOfFourth  Fifth\n");
+        actual_result = "";
+        get_word(actual_result, is); // First
+        actual_result = "";
+        get_word(actual_result, is); // Second
+        actual_result = "";
+        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 = "";
+        get_word(actual_result, is); // will copy Fourth-ShouldThisBePartOfFourth
+
+        actual_result = "";
+        get_word(actual_result, is); // will copy Fifth
+
+        is.clear();
+        is.str(str = "  First Second \t \r  \n Third  Fourth_ShouldThisBePartOfFourth Fifth\n");
+        skip_to_next_word(is);  // should now point to First
+        skip_to_next_word(is);  // should now point to Second
+        skip_to_next_word(is);  // should now point to Third
+        skip_to_next_word(is);  // should now point to Fourth
+        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"
+        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;
+
+        is.clear();
+        is.str(str = "First Second \t \r\n Third  Fourth-ShouldThisBePartOfFourth  IsThisFifth\n");
+        actual_result = "";
+        get_line(actual_result, is);
+        expected_result = "First Second \t \r\n";
+        ensure_equals("get_line: 1", actual_result, expected_result);
+
+        actual_result = "";
+        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 = "";
+        get_line(actual_result, is);
+        expected_result = "\n";
+        ensure_equals("get_line: First char as newline", actual_result, expected_result);
+
+        actual_result = "";
+        get_line(actual_result, is);
+        expected_result = "First Line.\n";
+        ensure_equals("get_line: 3", actual_result, expected_result);
+
+        actual_result = "";
+        get_line(actual_result, is);
+        expected_result = "\n";
+        ensure_equals("get_line: 4", actual_result, expected_result);
+
+        actual_result = "";
+        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>()
+    {
+        std::string str;
+        std::string expected_result;
+        std::string actual_result;
+        std::istringstream is;
+
+        // need to be check if this test case is wrong or the implementation is wrong.
+        is.clear();
+        is.str(str = "Should not skip lone \r.\r\n");
+        actual_result = "";
+        get_line(actual_result, is);
+        expected_result = "Should not skip lone \r.\r\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;
+
+        is.clear();
+        is.str(str = "\n");
+        actual_result = "";
+        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;
+
+        is.clear();
+        is.str(str = "First Line.\nSecond Line.\n");
+        actual_result = "";
+        get_line(actual_result, is, 255);
+        expected_result = "First Line.\n";
+        ensure_equals("get_line: Basic Operation", actual_result, expected_result);
+
+        actual_result = "";
+        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 = "";
+        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 = "";
+        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 = "";
+        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>()
+    {
+    }
+
+    //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>()
+    {
+        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>()
+    {
+        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);
-	}
+    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
index 10564ad7b3..67bdbb09b3 100644
--- a/indra/test/lltemplatemessagebuilder_tut.cpp
+++ b/indra/test/lltemplatemessagebuilder_tut.cpp
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -42,930 +42,930 @@
 #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();
-				const F32 circuit_heartbeat_interval=5;
-				const F32 circuit_timeout=100;
-
-				start_messaging_system("notafile", 13035,
-									   1,
-									   0,        
-									   0,        
-									   FALSE,        
-									   "notasharedsecret",
-									   NULL,
-									   false,
-									   circuit_heartbeat_interval,
-									   circuit_timeout);
-				//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(const_cast<char*>(_PREHASH_Test0), type, size, block);
-		}
-
-		static LLMessageBlock* createBlock(char* name, const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
-		{
-			LLMessageBlock* result = new LLMessageBlock(name, block);
-			if(type != MVT_NULL)
-			{
-				result->addVariable(const_cast<char*>(_PREHASH_Test0), type, size);
-			}
-			return result;
-		}
-
-		static LLTemplateMessageBuilder* defaultBuilder(LLMessageTemplate& messageTemplate, char* name = const_cast<char*>(_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));
+{
+    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();
+                const F32 circuit_heartbeat_interval=5;
+                const F32 circuit_timeout=100;
+
+                start_messaging_system("notafile", 13035,
+                                       1,
+                                       0,
+                                       0,
+                                       FALSE,
+                                       "notasharedsecret",
+                                       NULL,
+                                       false,
+                                       circuit_heartbeat_interval,
+                                       circuit_timeout);
+                //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(const_cast<char*>(_PREHASH_Test0), type, size, block);
+        }
+
+        static LLMessageBlock* createBlock(char* name, const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
+        {
+            LLMessageBlock* result = new LLMessageBlock(name, block);
+            if(type != MVT_NULL)
+            {
+                result->addVariable(const_cast<char*>(_PREHASH_Test0), type, size);
+            }
+            return result;
+        }
+
+        static LLTemplateMessageBuilder* defaultBuilder(LLMessageTemplate& messageTemplate, char* name = const_cast<char*>(_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(0.0f, LLVector3(0.3713907f, 0.5570861f, 0.7427813f));
 
-		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(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
-		messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4, MBT_SINGLE));
-
-		// build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
-		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, const_cast<char*>(_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(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4, MBT_SINGLE));
-		messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
-
-		// build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
-		builder = defaultBuilder(messageTemplate, const_cast<char*>(_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(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
-		messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4, MBT_SINGLE));
-
-		// build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
-		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, const_cast<char*>(_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, const_cast<char*>(_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(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
-
-		// Build message
-		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, const_cast<char*>(_PREHASH_Test0));
-		builder->addU32(_PREHASH_Test0, 0xaaaa);
-		bufferSize1 = builder->buildMessage(buffer1, MAX_BUFFER_SIZE, 0);
-		delete builder;
-
-		// Build template: Test0 before Test1
-		messageTemplate = defaultTemplate();
-		messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
-		messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4, MBT_SINGLE));
-
-		// Build message
-		builder = defaultBuilder(messageTemplate, const_cast<char*>(_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(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4));
-		messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4));
-		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
-		builder->addU32(_PREHASH_Test0, inTest00);
-		builder->nextBlock(_PREHASH_Test0);
-		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(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
-		messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4));
-
-		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
-		builder->addU32(_PREHASH_Test0, inTest);
-
-		LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
-		reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outTest);
-		S32 blockCount = reader->getNumberOfBlocks(const_cast<char*>(_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(const_cast<char*>(_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(0.0f, LLVector3(0.3713907f, 0.5570861f, 0.7427813f));
-		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(const_cast<char*>(_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(const_cast<char*>(_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, 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(const_cast<char*>(_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);
-		(void)outValue;
-		char outBuffer[bufferSize];
-		memset(buffer, 0xcc, bufferSize);
-		reader->getString(_PREHASH_Test1, _PREHASH_Test0, bufferSize, 
-						  outBuffer);
-		ensure_equals("Ensure present value ", outValue, inValue);
-		ensure_equals("Ensure unchanged buffer ", strlen(outBuffer), 0);
-		delete reader;
-	}
+        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(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
+        messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4, MBT_SINGLE));
+
+        // build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
+        LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, const_cast<char*>(_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(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4, MBT_SINGLE));
+        messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
+
+        // build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
+        builder = defaultBuilder(messageTemplate, const_cast<char*>(_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(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
+        messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4, MBT_SINGLE));
+
+        // build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
+        LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, const_cast<char*>(_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, const_cast<char*>(_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(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
+
+        // Build message
+        LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, const_cast<char*>(_PREHASH_Test0));
+        builder->addU32(_PREHASH_Test0, 0xaaaa);
+        bufferSize1 = builder->buildMessage(buffer1, MAX_BUFFER_SIZE, 0);
+        delete builder;
+
+        // Build template: Test0 before Test1
+        messageTemplate = defaultTemplate();
+        messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
+        messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4, MBT_SINGLE));
+
+        // Build message
+        builder = defaultBuilder(messageTemplate, const_cast<char*>(_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(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4));
+        messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4));
+        LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+        builder->addU32(_PREHASH_Test0, inTest00);
+        builder->nextBlock(_PREHASH_Test0);
+        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(const_cast<char*>(_PREHASH_Test0), MVT_U32, 4, MBT_SINGLE));
+        messageTemplate.addBlock(createBlock(const_cast<char*>(_PREHASH_Test1), MVT_U32, 4));
+
+        LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
+        builder->addU32(_PREHASH_Test0, inTest);
+
+        LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
+        reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outTest);
+        S32 blockCount = reader->getNumberOfBlocks(const_cast<char*>(_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(const_cast<char*>(_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(0.0f, LLVector3(0.3713907f, 0.5570861f, 0.7427813f));
+        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(const_cast<char*>(_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(const_cast<char*>(_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, 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(const_cast<char*>(_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);
+        (void)outValue;
+        char outBuffer[bufferSize];
+        memset(buffer, 0xcc, bufferSize);
+        reader->getString(_PREHASH_Test1, _PREHASH_Test0, bufferSize,
+                          outBuffer);
+        ensure_equals("Ensure present value ", outValue, inValue);
+        ensure_equals("Ensure unchanged buffer ", strlen(outBuffer), 0);
+        delete reader;
+    }
 }
 
diff --git a/indra/test/lltestapp.h b/indra/test/lltestapp.h
index 382516cd2b..466bc6fe16 100644
--- a/indra/test/lltestapp.h
+++ b/indra/test/lltestapp.h
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2019-10-21
  * @brief  LLApp subclass useful for testing.
- * 
+ *
  * $LicenseInfo:firstyear=2019&license=viewerlgpl$
  * Copyright (c) 2019, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/test/lltimestampcache_tut.cpp b/indra/test/lltimestampcache_tut.cpp
index 857a17a6d5..857dfe6e6e 100644
--- a/indra/test/lltimestampcache_tut.cpp
+++ b/indra/test/lltimestampcache_tut.cpp
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2008&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -34,91 +34,91 @@
 
 namespace tut
 {
-	struct LLTimestampCacheTestData
-	{
-	};
+    struct LLTimestampCacheTestData
+    {
+    };
 
-	typedef test_group<LLTimestampCacheTestData> LLTimestampCacheTestGroup;
-	typedef LLTimestampCacheTestGroup::object LLTimestampCacheTestObject;
+    typedef test_group<LLTimestampCacheTestData> LLTimestampCacheTestGroup;
+    typedef LLTimestampCacheTestGroup::object LLTimestampCacheTestObject;
 
-	LLTimestampCacheTestGroup timestampCacheTestGroup("LLTimestampCache");
+    LLTimestampCacheTestGroup timestampCacheTestGroup("LLTimestampCache");
 
-	// Most common usage
-	template<> template<>
-		void LLTimestampCacheTestObject::test<1>()
-		{
-			LLTimestampCache<std::string, std::string> cache;
-			// put in some data
-			cache.insert("key1", "val1", 1);
-			cache.insert("key2", "val2", 2);
-			cache.insert("key3", "val3", 3);
-			ensure_equals("size is 3", cache.size(), 3);
-			// check some items
-			ensure("has key1", cache.has("key1"));
-			ensure("no invalid key", !cache.has("invalid key"));
-			// get some items
-			ensure_equals("get key1", cache.get("key1", 4), "val1");
-			ensure_equals("get invalid key", 
-					cache.get("invalid key", 4), std::string() );
-			// timestamps
-			ensure_equals("key1 timestamp updated", cache.getTimestamp("key1"), 4);
-			ensure_equals("invalid key timestamp", 
-					cache.getTimestamp("invalid key"), 0);
-		}
+    // Most common usage
+    template<> template<>
+        void LLTimestampCacheTestObject::test<1>()
+        {
+            LLTimestampCache<std::string, std::string> cache;
+            // put in some data
+            cache.insert("key1", "val1", 1);
+            cache.insert("key2", "val2", 2);
+            cache.insert("key3", "val3", 3);
+            ensure_equals("size is 3", cache.size(), 3);
+            // check some items
+            ensure("has key1", cache.has("key1"));
+            ensure("no invalid key", !cache.has("invalid key"));
+            // get some items
+            ensure_equals("get key1", cache.get("key1", 4), "val1");
+            ensure_equals("get invalid key",
+                    cache.get("invalid key", 4), std::string() );
+            // timestamps
+            ensure_equals("key1 timestamp updated", cache.getTimestamp("key1"), 4);
+            ensure_equals("invalid key timestamp",
+                    cache.getTimestamp("invalid key"), 0);
+        }
 
-	// New empty cache shouldn't have any entries
-	template<> template<>
-		void LLTimestampCacheTestObject::test<2>()
-		{
-			LLTimestampCache<std::string, std::string> cache;
-			ensure_equals("starts empty",   cache.size(), 0);
-			ensure_equals("has nothing",    cache.has("foo"), false);
-			ensure_equals("gets nothing",   cache.get("foo", 0), std::string() );
-			U32 max_time = 0xFFFFFFFF;
-			ensure_equals("erases nothing", cache.eraseBefore(max_time), 0);
-		}
+    // New empty cache shouldn't have any entries
+    template<> template<>
+        void LLTimestampCacheTestObject::test<2>()
+        {
+            LLTimestampCache<std::string, std::string> cache;
+            ensure_equals("starts empty",   cache.size(), 0);
+            ensure_equals("has nothing",    cache.has("foo"), false);
+            ensure_equals("gets nothing",   cache.get("foo", 0), std::string() );
+            U32 max_time = 0xFFFFFFFF;
+            ensure_equals("erases nothing", cache.eraseBefore(max_time), 0);
+        }
 
-	// Non empty cache
-	template<> template<>
-		void LLTimestampCacheTestObject::test<3>()
-		{
-			LLTimestampCache<std::string, std::string> cache;
-			cache.insert("foo", "bar", 123);
-			ensure_equals("size one", cache.size(), 1);
-			ensure_equals("has it", cache.has("foo"), true);
-			ensure_equals("timestamp correct", cache.getTimestamp("foo"), 123);
-			std::string value = cache.get("foo", 456);
-			ensure_equals("get value", value, "bar");
-			ensure_equals("timestamp updated", cache.getTimestamp("foo"), 456);
-			ensure_equals("erase nothing", cache.eraseBefore(0), 0);
-			ensure_equals("erase one", cache.eraseBefore(789), 1);
-			ensure_equals("empty after erase", cache.size(), 0);
-		}
+    // Non empty cache
+    template<> template<>
+        void LLTimestampCacheTestObject::test<3>()
+        {
+            LLTimestampCache<std::string, std::string> cache;
+            cache.insert("foo", "bar", 123);
+            ensure_equals("size one", cache.size(), 1);
+            ensure_equals("has it", cache.has("foo"), true);
+            ensure_equals("timestamp correct", cache.getTimestamp("foo"), 123);
+            std::string value = cache.get("foo", 456);
+            ensure_equals("get value", value, "bar");
+            ensure_equals("timestamp updated", cache.getTimestamp("foo"), 456);
+            ensure_equals("erase nothing", cache.eraseBefore(0), 0);
+            ensure_equals("erase one", cache.eraseBefore(789), 1);
+            ensure_equals("empty after erase", cache.size(), 0);
+        }
 
-	// Recache of item should update timestamp
-	template<> template<>
-		void LLTimestampCacheTestObject::test<4>()
-		{
-			LLTimestampCache<std::string, std::string> cache;
-			cache.insert("foo", "bar", 123);
-			cache.insert("foo", "bar", 456);
-			ensure_equals("duplicate suppressed", cache.size(), 1);
-			ensure_equals("timestamp replaced", cache.getTimestamp("foo"), 456);
-		}
+    // Recache of item should update timestamp
+    template<> template<>
+        void LLTimestampCacheTestObject::test<4>()
+        {
+            LLTimestampCache<std::string, std::string> cache;
+            cache.insert("foo", "bar", 123);
+            cache.insert("foo", "bar", 456);
+            ensure_equals("duplicate suppressed", cache.size(), 1);
+            ensure_equals("timestamp replaced", cache.getTimestamp("foo"), 456);
+        }
 
-	// Erasing some items
-	template<> template<>
-		void LLTimestampCacheTestObject::test<5>()
-		{
-			LLTimestampCache<std::string, std::string> cache;
-			cache.insert("key1", "val1", 1);
-			cache.insert("key2", "val2", 2);
-			cache.insert("key3", "val3", 3);
-			cache.insert("key4", "val4", 4);
-			size_t erased = cache.eraseBefore(3);
-			ensure_equals("erase range", erased, 2);
-			ensure_equals("cache post erase", cache.size(), 2);
-			ensure_equals("has key3", cache.has("key3"), true);
-			ensure_equals("not has key2", cache.has("key2"), false);
-		}
+    // Erasing some items
+    template<> template<>
+        void LLTimestampCacheTestObject::test<5>()
+        {
+            LLTimestampCache<std::string, std::string> cache;
+            cache.insert("key1", "val1", 1);
+            cache.insert("key2", "val2", 2);
+            cache.insert("key3", "val3", 3);
+            cache.insert("key4", "val4", 4);
+            size_t erased = cache.eraseBefore(3);
+            ensure_equals("erase range", erased, 2);
+            ensure_equals("cache post erase", cache.size(), 2);
+            ensure_equals("has key3", cache.has("key3"), true);
+            ensure_equals("not has key2", cache.has("key2"), false);
+        }
 }
diff --git a/indra/test/lltranscode_tut.cpp b/indra/test/lltranscode_tut.cpp
index 3fce6e0e2b..23d554d46d 100644
--- a/indra/test/lltranscode_tut.cpp
+++ b/indra/test/lltranscode_tut.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llscriptresource_tut.cpp
  * @brief Test LLScriptResource
  *
  * $LicenseInfo:firstyear=2008&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -38,49 +38,49 @@ static const char test_latin2[] = "Edelwei\xdf";
 
 namespace tut
 {
-	class LLTranscodeTestData
-	{
-	};
-	
-	typedef test_group<LLTranscodeTestData> LLTranscodeTestGroup;
-	typedef LLTranscodeTestGroup::object LLTranscodeTestObject;
-	LLTranscodeTestGroup transcodeTestGroup("transcode");
+    class LLTranscodeTestData
+    {
+    };
+
+    typedef test_group<LLTranscodeTestData> LLTranscodeTestGroup;
+    typedef LLTranscodeTestGroup::object LLTranscodeTestObject;
+    LLTranscodeTestGroup transcodeTestGroup("transcode");
+
+    template<> template<>
+    void LLTranscodeTestObject::test<1>()
+    {
+        // Test utf8
+        std::stringstream input;
+        std::stringstream output;
+
+        input.str(test_utf7);
+        output.clear();
+        LLTranscode::transcode("charset=UTF-7", input, output);
+        ensure_equals("UTF-7 to UTF-8 transcoding", output.str(),
+                          std::string(test_utf8));
+
+        input.str(test_latin1);
+        output.clear();
+        LLTranscode::transcode("", input, output);
+        ensure_equals("Default (latin_1) to UTF8 transcoding", output.str(),
+            std::string(test_utf8));
 
-	template<> template<>
-	void LLTranscodeTestObject::test<1>()
-	{
-		// Test utf8
-		std::stringstream input;
-		std::stringstream output;
+        input.str(test_latin1);
+        output.clear();
+        LLTranscode::transcode("charset=iso-8859-1", input, output);
+        ensure_equals("latin_1 (ISO-8859-1) to UTF8 transcoding", output.str(),
+            std::string(test_utf8));
 
-		input.str(test_utf7);
-		output.clear();
-		LLTranscode::transcode("charset=UTF-7", input, output);
-		ensure_equals("UTF-7 to UTF-8 transcoding", output.str(),
-						  std::string(test_utf8));
+        input.str(test_latin2);
+        output.clear();
+        LLTranscode::transcode("charset=iso-8859-2", input, output);
+        ensure_equals("latin_2 (ISO-8859-2) to UTF8 transcoding", output.str(),
+            std::string(test_utf8));
 
-		input.str(test_latin1);
-		output.clear();
-		LLTranscode::transcode("", input, output);
-		ensure_equals("Default (latin_1) to UTF8 transcoding", output.str(),
-			std::string(test_utf8));
-		
-		input.str(test_latin1);
-		output.clear();
-		LLTranscode::transcode("charset=iso-8859-1", input, output);
-		ensure_equals("latin_1 (ISO-8859-1) to UTF8 transcoding", output.str(),
-			std::string(test_utf8));
-	
-		input.str(test_latin2);
-		output.clear();
-		LLTranscode::transcode("charset=iso-8859-2", input, output);
-		ensure_equals("latin_2 (ISO-8859-2) to UTF8 transcoding", output.str(),
-			std::string(test_utf8));
-		
-		input.str(test_utf8);
-		output.clear();
-		LLTranscode::transcode("charset=utf-8", input, output);
-		ensure_equals("UTF8 to UTF8 transcoding", output.str(),
-			std::string(test_utf8));
-	}
+        input.str(test_utf8);
+        output.clear();
+        LLTranscode::transcode("charset=utf-8", input, output);
+        ensure_equals("UTF8 to UTF8 transcoding", output.str(),
+            std::string(test_utf8));
+    }
 }
diff --git a/indra/test/lltut.cpp b/indra/test/lltut.cpp
index 5a8ee87afd..36c8fe4078 100644
--- a/indra/test/lltut.cpp
+++ b/indra/test/lltut.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file lltut.cpp
  * @author Mark Lentczner
  * @date 5/16/06
@@ -7,21 +7,21 @@
  * $LicenseInfo:firstyear=2006&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -38,169 +38,169 @@
 
 namespace tut
 {
-	void ensure_equals(const std::string& msg, const LLDate& actual,
-		const LLDate& expected)
-	{
-		ensure_equals(msg,
-			actual.secondsSinceEpoch(), expected.secondsSinceEpoch());
-	}
-
-	void ensure_equals(const std::string& msg, const LLURI& actual,
-		const LLURI& expected)
-	{
-		ensure_equals(msg,
-			actual.asString(), expected.asString());
-	}
-
-	// The lexical param types here intentionally diverge from the declaration
-	// in our header file. In lltut.h, LLSD is only a forward-declared type;
-	// we have no access to its LLSD::Binary nested type, and so must restate
-	// it explicitly to declare this overload. However, an overload that does
-	// NOT match LLSD::Binary does us no good whatsoever: it would never be
-	// engaged. Stating LLSD::Binary for this definition at least means that
-	// if the LLSD::Binary type ever diverges from what we expect in lltut.h,
-	// that divergence will produce an error: no definition will match that
-	// declaration.
-	void ensure_equals(const std::string& msg,
-		const LLSD::Binary& actual, const LLSD::Binary& expected)
-	{
-		ensure_equals(msg + " size", actual.size(), expected.size());
-		
-		LLSD::Binary::const_iterator i, j;
-		int k;
-		for (i = actual.begin(), j = expected.begin(), k = 0;
-			i != actual.end();
-			++i, ++j, ++k)
-		{
-			ensure_equals(msg + " field", *i, *j);
-		}
-	}
-
-	void ensure_equals(const std::string& msg, const LLSD& actual,
-		const LLSD& expected)
-	{
-		ensure_equals(msg + " type", actual.type(), expected.type());
-		switch (actual.type())
-		{
-			case LLSD::TypeUndefined:
-				return;
-			
-			case LLSD::TypeBoolean:
-				ensure_equals(msg + " boolean", actual.asBoolean(), expected.asBoolean());
-				return;
-			
-			case LLSD::TypeInteger:
-				ensure_equals(msg + " integer", actual.asInteger(), expected.asInteger());
-				return;
-			
-			case LLSD::TypeReal:
-				ensure_equals(msg + " real", actual.asReal(), expected.asReal());
-				return;
-			
-			case LLSD::TypeString:
-				ensure_equals(msg + " string", actual.asString(), expected.asString());
-				return;
-			
-			case LLSD::TypeUUID:
-				ensure_equals(msg + " uuid", actual.asUUID(), expected.asUUID());
-				return;
-			
-			case LLSD::TypeDate:
-				ensure_equals(msg + " date", actual.asDate(), expected.asDate());
-				return;
-				
-			case LLSD::TypeURI:
-				ensure_equals(msg + " uri", actual.asURI(), expected.asURI());
-				return;
-		
-			case LLSD::TypeBinary:
-				ensure_equals(msg + " binary", actual.asBinary(), expected.asBinary());
-				return;
-		
-			case LLSD::TypeMap:
-			{
-				ensure_equals(msg + " map size", actual.size(), expected.size());
-				
-				LLSD::map_const_iterator actual_iter = actual.beginMap();
-				LLSD::map_const_iterator expected_iter = expected.beginMap();
-				
-				while(actual_iter != actual.endMap())
-				{
-					ensure_equals(msg + " map keys", 
-						actual_iter->first, expected_iter->first);
-					ensure_equals(msg + "[" + actual_iter->first + "]",
-						actual_iter->second, expected_iter->second);
-					++actual_iter;
-					++expected_iter;
-				}
-				return;
-			}
-			case LLSD::TypeArray:
-			{
-				ensure_equals(msg + " array size", actual.size(), expected.size());
-				
-				for(int i = 0; i < actual.size(); ++i)
-				{
-					ensure_equals(msg + llformat("[%d]", i),
-						actual[i], expected[i]);
-				}
-				return;
-			}
-			default:
-				// should never get here, but compiler produces warning if we
-				// don't cover this case, and at Linden warnings are fatal.
-				throw failure(STRINGIZE("invalid type field " << actual.type()));
-		}
-	}
-
-	void ensure_starts_with(const std::string& msg,
-		const std::string& actual, const std::string& expectedStart)
-	{
-		if( actual.find(expectedStart, 0) != 0 )
-		{
-			std::stringstream ss;
-			ss << msg << ": " << "expected to find '" << expectedStart
-			   << "' at start of actual '" << actual << "'";
-			throw failure(ss.str().c_str());
-		}
-	}
-
-	void ensure_ends_with(const std::string& msg,
-		const std::string& actual, const std::string& expectedEnd)
-	{
-		if( actual.size() < expectedEnd.size()
-			|| actual.rfind(expectedEnd)
-				!= (actual.size() - expectedEnd.size()) )
-		{
-			std::stringstream ss;
-			ss << msg << ": " << "expected to find '" << expectedEnd
-			   << "' at end of actual '" << actual << "'";
-			throw failure(ss.str().c_str());
-		}
-	}
-
-	void ensure_contains(const std::string& msg,
-		const std::string& actual, const std::string& expectedSubString)
-	{
-		if( actual.find(expectedSubString, 0) == std::string::npos )
-		{
-			std::stringstream ss;
-			ss << msg << ": " << "expected to find '" << expectedSubString
-			   << "' in actual '" << actual << "'";
-			throw failure(ss.str().c_str());
-		}
-	}
-
-	void ensure_does_not_contain(const std::string& msg,
-		const std::string& actual, const std::string& expectedSubString)
-	{
-		if( actual.find(expectedSubString, 0) != std::string::npos )
-		{
-			std::stringstream ss;
-			ss << msg << ": " << "expected not to find " << expectedSubString
-				<< " in actual " << actual;
-			throw failure(ss.str().c_str());
-		}
-	}
+    void ensure_equals(const std::string& msg, const LLDate& actual,
+        const LLDate& expected)
+    {
+        ensure_equals(msg,
+            actual.secondsSinceEpoch(), expected.secondsSinceEpoch());
+    }
+
+    void ensure_equals(const std::string& msg, const LLURI& actual,
+        const LLURI& expected)
+    {
+        ensure_equals(msg,
+            actual.asString(), expected.asString());
+    }
+
+    // The lexical param types here intentionally diverge from the declaration
+    // in our header file. In lltut.h, LLSD is only a forward-declared type;
+    // we have no access to its LLSD::Binary nested type, and so must restate
+    // it explicitly to declare this overload. However, an overload that does
+    // NOT match LLSD::Binary does us no good whatsoever: it would never be
+    // engaged. Stating LLSD::Binary for this definition at least means that
+    // if the LLSD::Binary type ever diverges from what we expect in lltut.h,
+    // that divergence will produce an error: no definition will match that
+    // declaration.
+    void ensure_equals(const std::string& msg,
+        const LLSD::Binary& actual, const LLSD::Binary& expected)
+    {
+        ensure_equals(msg + " size", actual.size(), expected.size());
+
+        LLSD::Binary::const_iterator i, j;
+        int k;
+        for (i = actual.begin(), j = expected.begin(), k = 0;
+            i != actual.end();
+            ++i, ++j, ++k)
+        {
+            ensure_equals(msg + " field", *i, *j);
+        }
+    }
+
+    void ensure_equals(const std::string& msg, const LLSD& actual,
+        const LLSD& expected)
+    {
+        ensure_equals(msg + " type", actual.type(), expected.type());
+        switch (actual.type())
+        {
+            case LLSD::TypeUndefined:
+                return;
+
+            case LLSD::TypeBoolean:
+                ensure_equals(msg + " boolean", actual.asBoolean(), expected.asBoolean());
+                return;
+
+            case LLSD::TypeInteger:
+                ensure_equals(msg + " integer", actual.asInteger(), expected.asInteger());
+                return;
+
+            case LLSD::TypeReal:
+                ensure_equals(msg + " real", actual.asReal(), expected.asReal());
+                return;
+
+            case LLSD::TypeString:
+                ensure_equals(msg + " string", actual.asString(), expected.asString());
+                return;
+
+            case LLSD::TypeUUID:
+                ensure_equals(msg + " uuid", actual.asUUID(), expected.asUUID());
+                return;
+
+            case LLSD::TypeDate:
+                ensure_equals(msg + " date", actual.asDate(), expected.asDate());
+                return;
+
+            case LLSD::TypeURI:
+                ensure_equals(msg + " uri", actual.asURI(), expected.asURI());
+                return;
+
+            case LLSD::TypeBinary:
+                ensure_equals(msg + " binary", actual.asBinary(), expected.asBinary());
+                return;
+
+            case LLSD::TypeMap:
+            {
+                ensure_equals(msg + " map size", actual.size(), expected.size());
+
+                LLSD::map_const_iterator actual_iter = actual.beginMap();
+                LLSD::map_const_iterator expected_iter = expected.beginMap();
+
+                while(actual_iter != actual.endMap())
+                {
+                    ensure_equals(msg + " map keys",
+                        actual_iter->first, expected_iter->first);
+                    ensure_equals(msg + "[" + actual_iter->first + "]",
+                        actual_iter->second, expected_iter->second);
+                    ++actual_iter;
+                    ++expected_iter;
+                }
+                return;
+            }
+            case LLSD::TypeArray:
+            {
+                ensure_equals(msg + " array size", actual.size(), expected.size());
+
+                for(int i = 0; i < actual.size(); ++i)
+                {
+                    ensure_equals(msg + llformat("[%d]", i),
+                        actual[i], expected[i]);
+                }
+                return;
+            }
+            default:
+                // should never get here, but compiler produces warning if we
+                // don't cover this case, and at Linden warnings are fatal.
+                throw failure(STRINGIZE("invalid type field " << actual.type()));
+        }
+    }
+
+    void ensure_starts_with(const std::string& msg,
+        const std::string& actual, const std::string& expectedStart)
+    {
+        if( actual.find(expectedStart, 0) != 0 )
+        {
+            std::stringstream ss;
+            ss << msg << ": " << "expected to find '" << expectedStart
+               << "' at start of actual '" << actual << "'";
+            throw failure(ss.str().c_str());
+        }
+    }
+
+    void ensure_ends_with(const std::string& msg,
+        const std::string& actual, const std::string& expectedEnd)
+    {
+        if( actual.size() < expectedEnd.size()
+            || actual.rfind(expectedEnd)
+                != (actual.size() - expectedEnd.size()) )
+        {
+            std::stringstream ss;
+            ss << msg << ": " << "expected to find '" << expectedEnd
+               << "' at end of actual '" << actual << "'";
+            throw failure(ss.str().c_str());
+        }
+    }
+
+    void ensure_contains(const std::string& msg,
+        const std::string& actual, const std::string& expectedSubString)
+    {
+        if( actual.find(expectedSubString, 0) == std::string::npos )
+        {
+            std::stringstream ss;
+            ss << msg << ": " << "expected to find '" << expectedSubString
+               << "' in actual '" << actual << "'";
+            throw failure(ss.str().c_str());
+        }
+    }
+
+    void ensure_does_not_contain(const std::string& msg,
+        const std::string& actual, const std::string& expectedSubString)
+    {
+        if( actual.find(expectedSubString, 0) != std::string::npos )
+        {
+            std::stringstream ss;
+            ss << msg << ": " << "expected not to find " << expectedSubString
+                << " in actual " << actual;
+            throw failure(ss.str().c_str());
+        }
+    }
 }
 
diff --git a/indra/test/lltut.h b/indra/test/lltut.h
index 9835565bb6..e56b4e8d1c 100644
--- a/indra/test/lltut.h
+++ b/indra/test/lltut.h
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file lltut.h
  * @author Phoenix
  * @date 2005-09-26
@@ -7,21 +7,21 @@
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -38,35 +38,35 @@ class LLURI;
 
 namespace tut
 {
-	void ensure_equals(const std::string& msg,
-		const LLDate& actual, const LLDate& expected);
+    void ensure_equals(const std::string& msg,
+        const LLDate& actual, const LLDate& expected);
 
-	void ensure_equals(const std::string& msg,
-		const LLURI& actual, const LLURI& expected);
+    void ensure_equals(const std::string& msg,
+        const LLURI& actual, const LLURI& expected);
 
-	// std::vector<U8> is the current definition of LLSD::Binary. Because
-	// we're only forward-declaring LLSD in this header file, we can't
-	// directly reference that nested type. If the build complains that
-	// there's no definition for this declaration, it could be that
-	// LLSD::Binary has changed, and that this declaration must be adjusted to
-	// match.
-	void ensure_equals(const std::string& msg,
-		const std::vector<U8>& actual, const std::vector<U8>& expected);
+    // std::vector<U8> is the current definition of LLSD::Binary. Because
+    // we're only forward-declaring LLSD in this header file, we can't
+    // directly reference that nested type. If the build complains that
+    // there's no definition for this declaration, it could be that
+    // LLSD::Binary has changed, and that this declaration must be adjusted to
+    // match.
+    void ensure_equals(const std::string& msg,
+        const std::vector<U8>& actual, const std::vector<U8>& expected);
 
-	void ensure_equals(const std::string& msg,
-		const LLSD& actual, const LLSD& expected);
+    void ensure_equals(const std::string& msg,
+        const LLSD& actual, const LLSD& expected);
 
-	void ensure_starts_with(const std::string& msg,
-		const std::string& actual, const std::string& expectedStart);
+    void ensure_starts_with(const std::string& msg,
+        const std::string& actual, const std::string& expectedStart);
 
-	void ensure_ends_with(const std::string& msg,
-		const std::string& actual, const std::string& expectedEnd);
+    void ensure_ends_with(const std::string& msg,
+        const std::string& actual, const std::string& expectedEnd);
 
-	void ensure_contains(const std::string& msg,
-		const std::string& actual, const std::string& expectedSubString);
+    void ensure_contains(const std::string& msg,
+        const std::string& actual, const std::string& expectedSubString);
 
-	void ensure_does_not_contain(const std::string& msg,
-		const std::string& actual, const std::string& expectedSubString);
+    void ensure_does_not_contain(const std::string& msg,
+        const std::string& actual, const std::string& expectedSubString);
 }
 
 // This is an odd place to #include an important contributor -- but the usual
@@ -87,73 +87,73 @@ namespace tut
 // The functions BELOW this point actually consume tut.hpp functionality.
 namespace tut
 {
-	inline void ensure_approximately_equals(const char* msg, F64 actual, F64 expected, U32 frac_bits)
-	{
-		if(!is_approx_equal_fraction(actual, expected, frac_bits))
-		{
-			std::stringstream ss;
-			ss << (msg?msg:"") << (msg?": ":"") << "not equal actual: " << actual << " expected: " << expected;
-			throw tut::failure(ss.str().c_str());
-		}
-	}
-
-	inline void ensure_approximately_equals(const char* msg, F32 actual, F32 expected, U32 frac_bits)
-	{
-		if(!is_approx_equal_fraction(actual, expected, frac_bits))
-		{
-			std::stringstream ss;
-			ss << (msg?msg:"") << (msg?": ":"") << "not equal actual: " << actual << " expected: " << expected;
-			throw tut::failure(ss.str().c_str());
-		}
-	}
-
-	inline void ensure_approximately_equals(F32 actual, F32 expected, U32 frac_bits)
-	{
-		ensure_approximately_equals(NULL, actual, expected, frac_bits);
-	}
-
-	inline void ensure_approximately_equals_range(const char *msg, F32 actual, F32 expected, F32 delta)
-	{
-		if (fabs(actual-expected)>delta)
-		{
-			std::stringstream ss;
-			ss << (msg?msg:"") << (msg?": ":"") << "not equal actual: " << actual << " expected: " << expected << " tolerance: " << delta;
-			throw tut::failure(ss.str().c_str());
-		}
-	}
-
-	inline void ensure_memory_matches(const char* msg,const void* actual, U32 actual_len, const void* expected,U32 expected_len)
-	{
-		if((expected_len != actual_len) || 
-			(std::memcmp(actual, expected, actual_len) != 0))
-		{
-			std::stringstream ss;
-			ss << (msg?msg:"") << (msg?": ":"") << "not equal";
-			throw tut::failure(ss.str().c_str());
-		}
-	}
-
-	inline void ensure_memory_matches(const void* actual, U32 actual_len, const void* expected,U32 expected_len)
-	{
-		ensure_memory_matches(NULL, actual, actual_len, expected, expected_len);
-	}
-
-	template <class T,class Q>
-	void ensure_not_equals(const char* msg,const Q& actual,const T& expected)
-	{
-		if( expected == actual )
-		{
-			std::stringstream ss;
-			ss << (msg?msg:"") << (msg?": ":"") << "both equal " << expected;
-			throw tut::failure(ss.str().c_str());
-		}
-	}
-
-	template <class T,class Q>
-	void ensure_not_equals(const Q& actual,const T& expected)
-	{
-		ensure_not_equals(NULL, actual, expected);
-	}
+    inline void ensure_approximately_equals(const char* msg, F64 actual, F64 expected, U32 frac_bits)
+    {
+        if(!is_approx_equal_fraction(actual, expected, frac_bits))
+        {
+            std::stringstream ss;
+            ss << (msg?msg:"") << (msg?": ":"") << "not equal actual: " << actual << " expected: " << expected;
+            throw tut::failure(ss.str().c_str());
+        }
+    }
+
+    inline void ensure_approximately_equals(const char* msg, F32 actual, F32 expected, U32 frac_bits)
+    {
+        if(!is_approx_equal_fraction(actual, expected, frac_bits))
+        {
+            std::stringstream ss;
+            ss << (msg?msg:"") << (msg?": ":"") << "not equal actual: " << actual << " expected: " << expected;
+            throw tut::failure(ss.str().c_str());
+        }
+    }
+
+    inline void ensure_approximately_equals(F32 actual, F32 expected, U32 frac_bits)
+    {
+        ensure_approximately_equals(NULL, actual, expected, frac_bits);
+    }
+
+    inline void ensure_approximately_equals_range(const char *msg, F32 actual, F32 expected, F32 delta)
+    {
+        if (fabs(actual-expected)>delta)
+        {
+            std::stringstream ss;
+            ss << (msg?msg:"") << (msg?": ":"") << "not equal actual: " << actual << " expected: " << expected << " tolerance: " << delta;
+            throw tut::failure(ss.str().c_str());
+        }
+    }
+
+    inline void ensure_memory_matches(const char* msg,const void* actual, U32 actual_len, const void* expected,U32 expected_len)
+    {
+        if((expected_len != actual_len) ||
+            (std::memcmp(actual, expected, actual_len) != 0))
+        {
+            std::stringstream ss;
+            ss << (msg?msg:"") << (msg?": ":"") << "not equal";
+            throw tut::failure(ss.str().c_str());
+        }
+    }
+
+    inline void ensure_memory_matches(const void* actual, U32 actual_len, const void* expected,U32 expected_len)
+    {
+        ensure_memory_matches(NULL, actual, actual_len, expected, expected_len);
+    }
+
+    template <class T,class Q>
+    void ensure_not_equals(const char* msg,const Q& actual,const T& expected)
+    {
+        if( expected == actual )
+        {
+            std::stringstream ss;
+            ss << (msg?msg:"") << (msg?": ":"") << "both equal " << expected;
+            throw tut::failure(ss.str().c_str());
+        }
+    }
+
+    template <class T,class Q>
+    void ensure_not_equals(const Q& actual,const T& expected)
+    {
+        ensure_not_equals(NULL, actual, expected);
+    }
 }
 
 #endif // LL_LLTUT_H
diff --git a/indra/test/lluserrelations_tut.cpp b/indra/test/lluserrelations_tut.cpp
index afbcf6e5a8..80a659da65 100644
--- a/indra/test/lluserrelations_tut.cpp
+++ b/indra/test/lluserrelations_tut.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file lluserrelations_tut.cpp
  * @author Phoenix
  * @date 2006-10-12
@@ -7,21 +7,21 @@
  * $LicenseInfo:firstyear=2006&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -33,124 +33,124 @@
 
 namespace tut
 {
-	struct user_relationship
-	{
-		LLRelationship mRelationship;
-	};
-	typedef test_group<user_relationship> user_relationship_t;
-	typedef user_relationship_t::object user_relationship_object_t;
-	tut::user_relationship_t tut_user_relationship("relationships");
+    struct user_relationship
+    {
+        LLRelationship mRelationship;
+    };
+    typedef test_group<user_relationship> user_relationship_t;
+    typedef user_relationship_t::object user_relationship_object_t;
+    tut::user_relationship_t tut_user_relationship("relationships");
 
-	template<> template<>
-	void user_relationship_object_t::test<1>()
-	{
-		// Test the default construction
-		ensure(
-			"No granted rights to",
-			!mRelationship.isRightGrantedTo(
-				LLRelationship::GRANT_ONLINE_STATUS));
-		ensure(
-			"No granted rights from",
-			!mRelationship.isRightGrantedFrom(
-				LLRelationship::GRANT_ONLINE_STATUS));
-		ensure("No online status",!mRelationship.isOnline());
-	}
+    template<> template<>
+    void user_relationship_object_t::test<1>()
+    {
+        // Test the default construction
+        ensure(
+            "No granted rights to",
+            !mRelationship.isRightGrantedTo(
+                LLRelationship::GRANT_ONLINE_STATUS));
+        ensure(
+            "No granted rights from",
+            !mRelationship.isRightGrantedFrom(
+                LLRelationship::GRANT_ONLINE_STATUS));
+        ensure("No online status",!mRelationship.isOnline());
+    }
 
-	template<> template<>
-	void user_relationship_object_t::test<2>()
-	{
-		// Test some granting
-		mRelationship.grantRights(
-			LLRelationship::GRANT_ONLINE_STATUS,
-			LLRelationship::GRANT_MODIFY_OBJECTS);
-		ensure(
-			"Granted rights to has online",
-			mRelationship.isRightGrantedTo(
-				LLRelationship::GRANT_ONLINE_STATUS));
-		ensure(
-			"Granted rights from does not have online",
-			!mRelationship.isRightGrantedFrom(
-				LLRelationship::GRANT_ONLINE_STATUS));
-		ensure(
-			"Granted rights to does not have modify",
-			!mRelationship.isRightGrantedTo(
-				LLRelationship::GRANT_MODIFY_OBJECTS));
-		ensure(
-			"Granted rights from has modify",
-			mRelationship.isRightGrantedFrom(
-				LLRelationship::GRANT_MODIFY_OBJECTS));
-	}
+    template<> template<>
+    void user_relationship_object_t::test<2>()
+    {
+        // Test some granting
+        mRelationship.grantRights(
+            LLRelationship::GRANT_ONLINE_STATUS,
+            LLRelationship::GRANT_MODIFY_OBJECTS);
+        ensure(
+            "Granted rights to has online",
+            mRelationship.isRightGrantedTo(
+                LLRelationship::GRANT_ONLINE_STATUS));
+        ensure(
+            "Granted rights from does not have online",
+            !mRelationship.isRightGrantedFrom(
+                LLRelationship::GRANT_ONLINE_STATUS));
+        ensure(
+            "Granted rights to does not have modify",
+            !mRelationship.isRightGrantedTo(
+                LLRelationship::GRANT_MODIFY_OBJECTS));
+        ensure(
+            "Granted rights from has modify",
+            mRelationship.isRightGrantedFrom(
+                LLRelationship::GRANT_MODIFY_OBJECTS));
+    }
 
-	template<> template<>
-	void user_relationship_object_t::test<3>()
-	{
-		// Test revoking
-		mRelationship.grantRights(
-			LLRelationship::GRANT_ONLINE_STATUS
-			| LLRelationship::GRANT_MAP_LOCATION,
-			LLRelationship::GRANT_ONLINE_STATUS);
-		ensure(
-			"Granted rights to has online and map",
-			mRelationship.isRightGrantedTo(
-				LLRelationship::GRANT_ONLINE_STATUS
-				| LLRelationship::GRANT_MAP_LOCATION));
-		ensure(
-			"Granted rights from has online",
-			mRelationship.isRightGrantedFrom(
-				LLRelationship::GRANT_ONLINE_STATUS));
+    template<> template<>
+    void user_relationship_object_t::test<3>()
+    {
+        // Test revoking
+        mRelationship.grantRights(
+            LLRelationship::GRANT_ONLINE_STATUS
+            | LLRelationship::GRANT_MAP_LOCATION,
+            LLRelationship::GRANT_ONLINE_STATUS);
+        ensure(
+            "Granted rights to has online and map",
+            mRelationship.isRightGrantedTo(
+                LLRelationship::GRANT_ONLINE_STATUS
+                | LLRelationship::GRANT_MAP_LOCATION));
+        ensure(
+            "Granted rights from has online",
+            mRelationship.isRightGrantedFrom(
+                LLRelationship::GRANT_ONLINE_STATUS));
 
-		mRelationship.revokeRights(
-			LLRelationship::GRANT_MAP_LOCATION,
-			LLRelationship::GRANT_NONE);
-		ensure(
-			"Granted rights revoked map",
-			!mRelationship.isRightGrantedTo(
-				LLRelationship::GRANT_ONLINE_STATUS
-				| LLRelationship::GRANT_MAP_LOCATION));
-		ensure(
-			"Granted rights revoked still has online",
-			mRelationship.isRightGrantedTo(
-				LLRelationship::GRANT_ONLINE_STATUS));
+        mRelationship.revokeRights(
+            LLRelationship::GRANT_MAP_LOCATION,
+            LLRelationship::GRANT_NONE);
+        ensure(
+            "Granted rights revoked map",
+            !mRelationship.isRightGrantedTo(
+                LLRelationship::GRANT_ONLINE_STATUS
+                | LLRelationship::GRANT_MAP_LOCATION));
+        ensure(
+            "Granted rights revoked still has online",
+            mRelationship.isRightGrantedTo(
+                LLRelationship::GRANT_ONLINE_STATUS));
 
-		mRelationship.grantRights(
-			LLRelationship::GRANT_NONE,
-			LLRelationship::GRANT_MODIFY_OBJECTS);
-		ensure(
-			"Granted rights from still has online",
-			mRelationship.isRightGrantedFrom(
-				LLRelationship::GRANT_ONLINE_STATUS));
-		ensure(
-			"Granted rights from has full grant",
-			mRelationship.isRightGrantedFrom(
-				LLRelationship::GRANT_ONLINE_STATUS
-				| LLRelationship::GRANT_MODIFY_OBJECTS));
-		mRelationship.revokeRights(
-			LLRelationship::GRANT_NONE,
-			LLRelationship::GRANT_MODIFY_OBJECTS);
-		ensure(
-			"Granted rights from still has online",
-			mRelationship.isRightGrantedFrom(
-				LLRelationship::GRANT_ONLINE_STATUS));
-		ensure(
-			"Granted rights from no longer modify",
-			!mRelationship.isRightGrantedFrom(
-				LLRelationship::GRANT_MODIFY_OBJECTS));	
-	}
+        mRelationship.grantRights(
+            LLRelationship::GRANT_NONE,
+            LLRelationship::GRANT_MODIFY_OBJECTS);
+        ensure(
+            "Granted rights from still has online",
+            mRelationship.isRightGrantedFrom(
+                LLRelationship::GRANT_ONLINE_STATUS));
+        ensure(
+            "Granted rights from has full grant",
+            mRelationship.isRightGrantedFrom(
+                LLRelationship::GRANT_ONLINE_STATUS
+                | LLRelationship::GRANT_MODIFY_OBJECTS));
+        mRelationship.revokeRights(
+            LLRelationship::GRANT_NONE,
+            LLRelationship::GRANT_MODIFY_OBJECTS);
+        ensure(
+            "Granted rights from still has online",
+            mRelationship.isRightGrantedFrom(
+                LLRelationship::GRANT_ONLINE_STATUS));
+        ensure(
+            "Granted rights from no longer modify",
+            !mRelationship.isRightGrantedFrom(
+                LLRelationship::GRANT_MODIFY_OBJECTS));
+    }
 
-	template<> template<>
-	void user_relationship_object_t::test<4>()
-	{
-		ensure("No online status", !mRelationship.isOnline());
-		mRelationship.online(true);
-		ensure("Online status", mRelationship.isOnline());
-		mRelationship.online(false);
-		ensure("No online status", !mRelationship.isOnline());
-	}
+    template<> template<>
+    void user_relationship_object_t::test<4>()
+    {
+        ensure("No online status", !mRelationship.isOnline());
+        mRelationship.online(true);
+        ensure("Online status", mRelationship.isOnline());
+        mRelationship.online(false);
+        ensure("No online status", !mRelationship.isOnline());
+    }
 
 /*
-	template<> template<>
-	void user_relationship_object_t::test<>()
-	{
-	}
+    template<> template<>
+    void user_relationship_object_t::test<>()
+    {
+    }
 */
 }
diff --git a/indra/test/llxorcipher_tut.cpp b/indra/test/llxorcipher_tut.cpp
index 55b3faaa61..9acac53604 100644
--- a/indra/test/llxorcipher_tut.cpp
+++ b/indra/test/llxorcipher_tut.cpp
@@ -7,25 +7,25 @@
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
- 
+
 #include "linden_common.h"
 #include "lltut.h"
 #include "llxorcipher.h"
@@ -33,99 +33,99 @@
 
 namespace tut
 {
-	struct cipher
-	{
-	};
-	typedef test_group<cipher> cipher_t;
-	typedef cipher_t::object cipher_object_t;
-	tut::cipher_t tut_cipher("cipher");
+    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));
 
-	//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 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);
+    }
 
-		U32 length = xorCipher.requiredEncryptionSpace(50);
-		ensure("requiredEncryptionSpace() function failed", (length == 50));
+    // 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];
 
-		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);	
-	}
+        LLXORCipher xorCipher(pad, pad_len);
+        LLXORCipher xorCipher1(pad1, pad_len1);
 
-	// 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];
+        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);
+    }
 
-		LLXORCipher xorCipher(pad, pad_len);
-		LLXORCipher xorCipher1(pad1, pad_len1);
+    //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);
 
-		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);
+    }
 
-		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;
 
-	//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 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 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);
-	}
+        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
index 76063e6db1..96308b54af 100644
--- a/indra/test/message_tut.cpp
+++ b/indra/test/message_tut.cpp
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -37,111 +37,111 @@
 
 namespace
 {
-	struct Response : public LLHTTPNode::Response
-	{
-		virtual void result(const LLSD&) {}
-		virtual void status(S32 code, const std::string& message) 
-		{
-			mStatus = code;
-		}
-		virtual void extendedResult(S32 code, const std::string& message, const LLSD& headers) { }
-		virtual void extendedResult(S32 code, const LLSD& result, const LLSD& headers) { }
-		S32 mStatus;
-	};
+    struct Response : public LLHTTPNode::Response
+    {
+        virtual void result(const LLSD&) {}
+        virtual void status(S32 code, const std::string& message)
+        {
+            mStatus = code;
+        }
+        virtual void extendedResult(S32 code, const std::string& message, const LLSD& headers) { }
+        virtual void extendedResult(S32 code, const LLSD& result, const LLSD& headers) { }
+        S32 mStatus;
+    };
 }
 
 namespace tut
-{	
-	struct LLMessageSystemTestData 
-	{
-		std::string mTestConfigDir;
-		std::string mSep;
+{
+    struct LLMessageSystemTestData
+    {
+        std::string mTestConfigDir;
+        std::string mSep;
 
-		LLMessageSystemTestData()
-		{
-			static bool init = false;
-			if(!init)
-			{
-				ll_init_apr();
-				//init_prehash_data();
-				init = true;
-			}
-			const F32 circuit_heartbeat_interval=5;
-			const F32 circuit_timeout=100;
+        LLMessageSystemTestData()
+        {
+            static bool init = false;
+            if(!init)
+            {
+                ll_init_apr();
+                //init_prehash_data();
+                init = true;
+            }
+            const F32 circuit_heartbeat_interval=5;
+            const F32 circuit_timeout=100;
 
 
-			// currently test disconnected message system
-			start_messaging_system("notafile", 13035,
-								   1,
-								   0,        
-								   0,        
-								   FALSE,        
-								   "notasharedsecret",
-								   NULL,
-								   false,
-								   circuit_heartbeat_interval,
-								   circuit_timeout
-								   );
-			// generate temp dir
-			std::ostringstream ostr;
+            // currently test disconnected message system
+            start_messaging_system("notafile", 13035,
+                                   1,
+                                   0,
+                                   0,
+                                   FALSE,
+                                   "notasharedsecret",
+                                   NULL,
+                                   false,
+                                   circuit_heartbeat_interval,
+                                   circuit_timeout
+                                   );
+            // generate temp dir
+            std::ostringstream ostr;
 #if LL_WINDOWS
-			mSep = "\\";
-			ostr << "C:" << mSep;
+            mSep = "\\";
+            ostr << "C:" << mSep;
 #else
-			mSep = "/";
-			ostr << mSep << "tmp" << mSep;
+            mSep = "/";
+            ostr << mSep << "tmp" << mSep;
 #endif
-			LLUUID random;
-			random.generate();
-			ostr << "message-test-" << random;
-			mTestConfigDir = ostr.str();
-			LLFile::mkdir(mTestConfigDir);
-			writeConfigFile(LLSD());
-			LLMessageConfig::initClass("simulator", ostr.str());
-		}
+            LLUUID random;
+            random.generate();
+            ostr << "message-test-" << random;
+            mTestConfigDir = ostr.str();
+            LLFile::mkdir(mTestConfigDir);
+            writeConfigFile(LLSD());
+            LLMessageConfig::initClass("simulator", ostr.str());
+        }
+
+        ~LLMessageSystemTestData()
+        {
+            // not end_messaging_system()
+            delete static_cast<LLMessageSystem*>(gMessageSystem);
+            gMessageSystem = NULL;
+
+            // rm contents of temp dir
+            std::ostringstream ostr;
+            ostr << mTestConfigDir << mSep << "message.xml";
+            int rmfile = LLFile::remove(ostr.str());
+            ensure_equals("rmfile value", rmfile, 0);
 
-		~LLMessageSystemTestData()
-		{
-			// not end_messaging_system()
-			delete static_cast<LLMessageSystem*>(gMessageSystem);
-			gMessageSystem = NULL;
+            // rm temp dir
+            int rmdir = LLFile::rmdir(mTestConfigDir);
+            ensure_equals("rmdir value", rmdir, 0);
+        }
 
-			// rm contents of temp dir
-			std::ostringstream ostr;
-			ostr << mTestConfigDir << mSep << "message.xml";
-			int rmfile = LLFile::remove(ostr.str());
-			ensure_equals("rmfile value", rmfile, 0);
+        void writeConfigFile(const LLSD& config)
+        {
+            std::string ostr(mTestConfigDir + mSep + "message.xml");
+            llofstream file(ostr.c_str());
+            if (file.is_open())
+            {
+                LLSDSerialize::toPrettyXML(config, file);
+            }
+            file.close();
+        }
+    };
 
-			// rm temp dir
-			int rmdir = LLFile::rmdir(mTestConfigDir);
-			ensure_equals("rmdir value", rmdir, 0);
-		}
+    typedef test_group<LLMessageSystemTestData> LLMessageSystemTestGroup;
+    typedef LLMessageSystemTestGroup::object        LLMessageSystemTestObject;
+    LLMessageSystemTestGroup messageTestGroup("LLMessageSystem");
 
-		void writeConfigFile(const LLSD& config)
-		{
-			std::string ostr(mTestConfigDir + mSep + "message.xml");
-			llofstream file(ostr.c_str());
-			if (file.is_open())
-			{
-				LLSDSerialize::toPrettyXML(config, file);
-			}
-			file.close();
-		}
-	};
-	
-	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, HTTP_NOT_FOUND);
-	}
+    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, HTTP_NOT_FOUND);
+    }
 }
 
diff --git a/indra/test/mock_http_client.cpp b/indra/test/mock_http_client.cpp
index e72902bfc2..a97d31c7f4 100644
--- a/indra/test/mock_http_client.cpp
+++ b/indra/test/mock_http_client.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file mock_http_client.cpp
  * @brief Framework for testing HTTP requests
  *
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -29,54 +29,54 @@
 
 namespace tut
 {
-	class SuccessNode : public LLHTTPNode
-	{
-	public:
-		void get(ResponsePtr r, const LLSD& context) const
-	   	{ 
-	   		LLSD result;
-			result["state"] = "complete";
-	   		result["test"] = "test";
-	   		r->result(result);
-	   	}
-		void post(ResponsePtr r, const LLSD& context, const LLSD& input) const
-		{
-			LLSD result;
-			result["state"] = "complete";
-			result["test"] = "test";
-			r->result(result);
-		}
-	};
+    class SuccessNode : public LLHTTPNode
+    {
+    public:
+        void get(ResponsePtr r, const LLSD& context) const
+        {
+            LLSD result;
+            result["state"] = "complete";
+            result["test"] = "test";
+            r->result(result);
+        }
+        void post(ResponsePtr r, const LLSD& context, const LLSD& input) const
+        {
+            LLSD result;
+            result["state"] = "complete";
+            result["test"] = "test";
+            r->result(result);
+        }
+    };
+
+    class ErrorNode : public LLHTTPNode
+    {
+    public:
+        void get(ResponsePtr r, const LLSD& context) const
+            { r->status(599, "Intentional error"); }
+        void post(ResponsePtr r, const LLSD& context, const LLSD& input) const
+            { r->status(input["status"], input["reason"]); }
+    };
 
-	class ErrorNode : public LLHTTPNode
-	{
-	public:
-		void get(ResponsePtr r, const LLSD& context) const
-			{ r->status(599, "Intentional error"); }
-		void post(ResponsePtr r, const LLSD& context, const LLSD& input) const
-			{ r->status(input["status"], input["reason"]); }
-	};
+    class TimeOutNode : public LLHTTPNode
+    {
+    public:
+        void get(ResponsePtr r, const LLSD& context) const
+        {
+            /* do nothing, the request will eventually time out */
+        }
+    };
 
-	class TimeOutNode : public LLHTTPNode
-	{
-	public:
-		void get(ResponsePtr r, const LLSD& context) const
-		{
-            /* do nothing, the request will eventually time out */ 
-		}
-	};
+    LLSD storage;
 
-	LLSD storage;
-	
-	class LLSDStorageNode : public LLHTTPNode
-	{
-	public:
-		LLSD get() const{ return storage; }
-		LLSD put(const LLSD& value) const{ storage = value; return LLSD(); }
-	};
+    class LLSDStorageNode : public LLHTTPNode
+    {
+    public:
+        LLSD get() const{ return storage; }
+        LLSD put(const LLSD& value) const{ storage = value; return LLSD(); }
+    };
 
-	LLHTTPRegistration<LLSDStorageNode> gStorageNode("/test/storage");
-	LLHTTPRegistration<SuccessNode>		gSuccessNode("/test/success");
-	LLHTTPRegistration<ErrorNode>		gErrorNode("/test/error");
-	LLHTTPRegistration<TimeOutNode>		gTimeOutNode("/test/timeout");
+    LLHTTPRegistration<LLSDStorageNode> gStorageNode("/test/storage");
+    LLHTTPRegistration<SuccessNode>     gSuccessNode("/test/success");
+    LLHTTPRegistration<ErrorNode>       gErrorNode("/test/error");
+    LLHTTPRegistration<TimeOutNode>     gTimeOutNode("/test/timeout");
 }
diff --git a/indra/test/mock_http_client.h b/indra/test/mock_http_client.h
index a2b9b435fb..ef268abc6e 100644
--- a/indra/test/mock_http_client.h
+++ b/indra/test/mock_http_client.h
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file mock_http_client.cpp
  * @brief Framework for testing HTTP requests
  *
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -33,158 +33,158 @@
 
 namespace tut
 {
-	struct MockHttpClient
-	{
-	public:
-		MockHttpClient()
-		{
-			apr_pool_create(&mPool, NULL);
-			mServerPump = new LLPumpIO(mPool);
-			mClientPump = new LLPumpIO(mPool);
-			
-			LLHTTPClient::setPump(*mClientPump);
-		}
-		
-		~MockHttpClient()
-		{
-			delete mServerPump;
-			delete mClientPump;
-			apr_pool_destroy(mPool);
-		}
-
-		void setupTheServer()
-		{
-			LLHTTPNode& root = LLIOHTTPServer::create(mPool, *mServerPump, 8888);
-
-			LLHTTPStandardServices::useServices();
-			LLHTTPRegistrar::buildAllServices(root);
-		}
-		
-		void runThePump(float timeout = 100.0f)
-		{
-			LLTimer timer;
-			timer.setTimerExpirySec(timeout);
-
-			while(!mSawCompleted && !timer.hasExpired())
-			{
-				if (mServerPump)
-				{
-					mServerPump->pump();
-					mServerPump->callback();
-				}
-				if (mClientPump)
-				{
-					mClientPump->pump();
-					mClientPump->callback();
-				}
-			}
-		}
-
-		void killServer()
-		{
-			delete mServerPump;
-			mServerPump = NULL;
-		}
-	
-	private:
-		apr_pool_t* mPool;
-		LLPumpIO* mServerPump;
-		LLPumpIO* mClientPump;
-
-		
-	protected:
-		void ensureStatusOK()
-		{
-			if (mSawError)
-			{
-				std::string msg =
-					llformat("httpFailure() called when not expected, status %d",
-						mStatus); 
-				fail(msg);
-			}
-		}
-	
-		void ensureStatusError()
-		{
-			if (!mSawError)
-			{
-				fail("httpFailure() wasn't called");
-			}
-		}
-		
-		LLSD getResult()
-		{
-			return mResult;
-		}
-	
-	protected:
-		bool mSawError;
-		S32 mStatus;
-		std::string mReason;
-		bool mSawCompleted;
-		LLSD mResult;
-		bool mResultDeleted;
-
-		class Result : public LLHTTPClient::Responder
-		{
-		protected:
-			Result(MockHttpClient& client)
-				: mClient(client)
-			{
-			}
-		
-		public:
-			static boost::intrusive_ptr<Result> build(MockHttpClient& client)
-			{
-				return boost::intrusive_ptr<Result>(new Result(client));
-			}
-			
-			~Result()
-			{
-				mClient.mResultDeleted = true;
-			}
-			
-		protected:
-			virtual void httpFailure()
-			{
-				mClient.mSawError = true;
-				mClient.mStatus = getStatus();
-				mClient.mReason = getReason();
-			}
-
-			virtual void httpSuccess()
-			{
-				mClient.mResult = getContent();
-			}
-
-			virtual void httpCompleted()
-			{
-				LLHTTPClient::Responder::httpCompleted();
-				
-				mClient.mSawCompleted = true;
-			}
-
-		private:
-			MockHttpClient& mClient;
-		};
-
-		friend class Result;
-
-	protected:
-
-		void reset()
-		{
-			mSawError = false;
-			mStatus = 0;
-			mSawCompleted = false;
-			mResult.clear();
-			mResultDeleted = false;
-		}
-
-		LLHTTPClient::ResponderPtr newResult()
-		{
-			reset();
-			return Result::build(*this);
-		}
-	};
+    struct MockHttpClient
+    {
+    public:
+        MockHttpClient()
+        {
+            apr_pool_create(&mPool, NULL);
+            mServerPump = new LLPumpIO(mPool);
+            mClientPump = new LLPumpIO(mPool);
+
+            LLHTTPClient::setPump(*mClientPump);
+        }
+
+        ~MockHttpClient()
+        {
+            delete mServerPump;
+            delete mClientPump;
+            apr_pool_destroy(mPool);
+        }
+
+        void setupTheServer()
+        {
+            LLHTTPNode& root = LLIOHTTPServer::create(mPool, *mServerPump, 8888);
+
+            LLHTTPStandardServices::useServices();
+            LLHTTPRegistrar::buildAllServices(root);
+        }
+
+        void runThePump(float timeout = 100.0f)
+        {
+            LLTimer timer;
+            timer.setTimerExpirySec(timeout);
+
+            while(!mSawCompleted && !timer.hasExpired())
+            {
+                if (mServerPump)
+                {
+                    mServerPump->pump();
+                    mServerPump->callback();
+                }
+                if (mClientPump)
+                {
+                    mClientPump->pump();
+                    mClientPump->callback();
+                }
+            }
+        }
+
+        void killServer()
+        {
+            delete mServerPump;
+            mServerPump = NULL;
+        }
+
+    private:
+        apr_pool_t* mPool;
+        LLPumpIO* mServerPump;
+        LLPumpIO* mClientPump;
+
+
+    protected:
+        void ensureStatusOK()
+        {
+            if (mSawError)
+            {
+                std::string msg =
+                    llformat("httpFailure() called when not expected, status %d",
+                        mStatus);
+                fail(msg);
+            }
+        }
+
+        void ensureStatusError()
+        {
+            if (!mSawError)
+            {
+                fail("httpFailure() wasn't called");
+            }
+        }
+
+        LLSD getResult()
+        {
+            return mResult;
+        }
+
+    protected:
+        bool mSawError;
+        S32 mStatus;
+        std::string mReason;
+        bool mSawCompleted;
+        LLSD mResult;
+        bool mResultDeleted;
+
+        class Result : public LLHTTPClient::Responder
+        {
+        protected:
+            Result(MockHttpClient& client)
+                : mClient(client)
+            {
+            }
+
+        public:
+            static boost::intrusive_ptr<Result> build(MockHttpClient& client)
+            {
+                return boost::intrusive_ptr<Result>(new Result(client));
+            }
+
+            ~Result()
+            {
+                mClient.mResultDeleted = true;
+            }
+
+        protected:
+            virtual void httpFailure()
+            {
+                mClient.mSawError = true;
+                mClient.mStatus = getStatus();
+                mClient.mReason = getReason();
+            }
+
+            virtual void httpSuccess()
+            {
+                mClient.mResult = getContent();
+            }
+
+            virtual void httpCompleted()
+            {
+                LLHTTPClient::Responder::httpCompleted();
+
+                mClient.mSawCompleted = true;
+            }
+
+        private:
+            MockHttpClient& mClient;
+        };
+
+        friend class Result;
+
+    protected:
+
+        void reset()
+        {
+            mSawError = false;
+            mStatus = 0;
+            mSawCompleted = false;
+            mResult.clear();
+            mResultDeleted = false;
+        }
+
+        LLHTTPClient::ResponderPtr newResult()
+        {
+            reset();
+            return Result::build(*this);
+        }
+    };
 }
diff --git a/indra/test/namedtempfile.h b/indra/test/namedtempfile.h
index ad14cebbd1..8027f95728 100644
--- a/indra/test/namedtempfile.h
+++ b/indra/test/namedtempfile.h
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2012-01-13
  * @brief  NamedTempFile class for tests that need disk files as fixtures.
- * 
+ *
  * $LicenseInfo:firstyear=2012&license=viewerlgpl$
  * Copyright (c) 2012, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/test/prim_linkability_tut.cpp b/indra/test/prim_linkability_tut.cpp
index a70912e535..3603b25f18 100644
--- a/indra/test/prim_linkability_tut.cpp
+++ b/indra/test/prim_linkability_tut.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file linkability.cpp
  * @author andrew@lindenlab.com
  * @date 2007-04-23
@@ -7,21 +7,21 @@
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -35,461 +35,461 @@
 // helper function
 void randomize_sphere(LLSphere& sphere, F32 center_range, F32 radius_range)
 {
-	F32 radius = ll_frand(2.f * radius_range) - radius_range;
-	LLVector3 center;
-	for (S32 i=0; i<3; ++i)
-	{
-		center.mV[i] = ll_frand(2.f * center_range) - center_range;
-	}
-	sphere.setRadius(radius);
-	sphere.setCenter(center);
+    F32 radius = ll_frand(2.f * radius_range) - radius_range;
+    LLVector3 center;
+    for (S32 i=0; i<3; ++i)
+    {
+        center.mV[i] = ll_frand(2.f * center_range) - center_range;
+    }
+    sphere.setRadius(radius);
+    sphere.setCenter(center);
 }
 
 // helper function.  Same as above with a min and max radius.
 void randomize_sphere(LLSphere& sphere, F32 center_range, F32 minimum_radius, F32 maximum_radius)
 {
-	F32 radius = ll_frand(maximum_radius - minimum_radius) + minimum_radius; 
-	LLVector3 center;
-	for (S32 i=0; i<3; ++i)
-	{
-		center.mV[i] = ll_frand(2.f * center_range) - center_range;
-	}
-	sphere.setRadius(radius);
-	sphere.setCenter(center);
+    F32 radius = ll_frand(maximum_radius - minimum_radius) + minimum_radius;
+    LLVector3 center;
+    for (S32 i=0; i<3; ++i)
+    {
+        center.mV[i] = ll_frand(2.f * center_range) - center_range;
+    }
+    sphere.setRadius(radius);
+    sphere.setCenter(center);
 }
 
 // helper function
 bool random_sort( const LLPrimLinkInfo< S32 >&, const LLPrimLinkInfo< S32 >& b)
 {
-	return (ll_rand(64) < 32);
+    return (ll_rand(64) < 32);
 }
 
 namespace tut
 {
-	struct linkable_data
-	{
-		LLPrimLinkInfo<S32> info;
-	};
-
-	typedef test_group<linkable_data> linkable_test;
-	typedef linkable_test::object linkable_object;
-	tut::linkable_test wtf("prim linkability");
-
-	template<> template<>
-	void linkable_object::test<1>()
-	{
-		// Here we test the boundary of the LLPrimLinkInfo::canLink() method 
-		// between semi-random middle-sized objects.
-
-		S32 number_of_tests = 100;
-		for (S32 test = 0; test < number_of_tests; ++test)
-		{
-			// compute the radii that would provide the above max link distance
-			F32 first_radius = 0.f;
-			F32 second_radius = 0.f;
-			
-			// compute a random center for the first sphere
-			// compute some random max link distance
-			F32 max_link_span = ll_frand(MAX_OBJECT_SPAN);
-			if (max_link_span < OBJECT_SPAN_BONUS)
-			{
-				max_link_span += OBJECT_SPAN_BONUS;
-			}
-			LLVector3 first_center(
-					ll_frand(2.f * max_link_span) - max_link_span, 
-					ll_frand(2.f * max_link_span) - max_link_span, 
-					ll_frand(2.f * max_link_span) - max_link_span);
-
-			// put the second sphere at the right distance from the origin
-			// such that it is within the max_link_distance of the first
-			LLVector3 direction(ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f);
-			direction.normalize();
-			F32 half_milimeter = 0.0005f;
-			LLVector3 second_center;
-
-			// max_span = 3 * (first_radius + second_radius) + OBJECT_SPAN_BONUS
-			// make sure they link at short distances
-			{
-				second_center = first_center + (OBJECT_SPAN_BONUS - half_milimeter) * direction;
-				LLPrimLinkInfo<S32> first_info(0, LLSphere(first_center, first_radius) );
-				LLPrimLinkInfo<S32> second_info(1, LLSphere(second_center, second_radius) );
-				ensure("these nearby objects should link", first_info.canLink(second_info) );
-			}
-
-			// make sure they fail to link if we move them apart just a little bit
-			{
-				second_center = first_center + (OBJECT_SPAN_BONUS + half_milimeter) * direction;
-				LLPrimLinkInfo<S32> first_info(0, LLSphere(first_center, first_radius) );
-				LLPrimLinkInfo<S32> second_info(1, LLSphere(second_center, second_radius) );
-				ensure("these nearby objects should NOT link", !first_info.canLink(second_info) );
-			}
-
-			// make sure the objects link or not at medium distances
-			{
-				first_radius = 0.3f * ll_frand(max_link_span - OBJECT_SPAN_BONUS);
-
-				// This is the exact second radius that will link at exactly our random max_link_distance
-				second_radius = ((max_link_span - OBJECT_SPAN_BONUS) / 3.f) - first_radius;
-				second_center = first_center + (max_link_span - first_radius - second_radius - half_milimeter) * direction;
-
-				LLPrimLinkInfo<S32> first_info(0, LLSphere(first_center, first_radius) );
-				LLPrimLinkInfo<S32> second_info(1, LLSphere(second_center, second_radius) );
-
-				ensure("these objects should link", first_info.canLink(second_info) );
-			}
-
-			// make sure they fail to link if we move them apart just a little bit
-			{
-				// move the second sphere such that it is a little too far from the first
-				second_center += (2.f * half_milimeter) * direction;
-				LLPrimLinkInfo<S32> first_info(0, LLSphere(first_center, first_radius) );
-				LLPrimLinkInfo<S32> second_info(1, LLSphere(second_center, second_radius) );
-				
-				ensure("these objects should NOT link", !first_info.canLink(second_info) );
-			}
-
-			// make sure things don't link at far distances
-			{
-				second_center = first_center + (MAX_OBJECT_SPAN + 2.f * half_milimeter) * direction;
-				second_radius = 0.3f * MAX_OBJECT_SPAN;
-				LLPrimLinkInfo<S32> first_info(0, LLSphere(first_center, first_radius) );
-				LLPrimLinkInfo<S32> second_info(1, LLSphere(second_center, second_radius) );
-				ensure("these objects should NOT link", !first_info.canLink(second_info) );
-			}
-			
-		}
-	}
-
-	template<> template<>
-	void linkable_object::test<2>()
-	{
-
-		// Consider a row of eight spheres in a row, each 10m in diameter and centered
-		// at 10m intervals:  01234567.
-
-		F32 radius = 5.f;
-		F32 spacing = 10.f;
-
-		LLVector3 line_direction(ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f);
-		line_direction.normalize();
-
-		LLVector3 first_center(ll_frand(2.f * spacing) -spacing, ll_frand(2.f * spacing) - spacing, ll_frand(2.f * spacing) - spacing);
-
-		LLPrimLinkInfo<S32> infos[8];
-
-		for (S32 index = 0; index < 8; ++index)
-		{
-			LLVector3 center = first_center + ((F32)(index) * spacing) * line_direction;
-			infos[index].set(index, LLSphere(center, radius));
-		}
-
-		// Max span for 2 spheres of 5m radius is 3 * (5 + 5) + 1 = 31m
-		// spheres 0&2 have a 30m span (from outside edge to outside edge) and should link
-		{
-			LLPrimLinkInfo<S32> root_info = infos[0];
-			std::list< LLPrimLinkInfo<S32> > info_list;
-			info_list.push_back(infos[2]);
-			root_info.mergeLinkableSet(info_list);
-			S32 prim_count = root_info.getPrimCount();
-			ensure_equals("0&2 prim count should be 2", prim_count, 2);
-			ensure_equals("0&2 unlinkable list should have length 0", (S32) info_list.size(), 0);
-		}
-
-		
-		// spheres 0&3 have a 40 meter span and should NOT link outright
-		{
-			LLPrimLinkInfo<S32> root_info = infos[0];
-			std::list< LLPrimLinkInfo<S32> > info_list;
-			info_list.push_back(infos[3]);
-			root_info.mergeLinkableSet(info_list);
-			S32 prim_count = root_info.getPrimCount();
-			ensure_equals("0&4 prim count should be 1", prim_count, 1);
-			ensure_equals("0&4 unlinkable list should have length 1", (S32) info_list.size(), 1);
-		}
-
-		
-		// spheres 0-4 should link no matter what order : 01234
-		// Total span = 50m, 012 link with a r=15.5 giving max span of 3 * (15.5 + 5) + 1 = 62.5, but the cap is 54m
-		{
-			LLPrimLinkInfo<S32> root_info = infos[0];
-			std::list< LLPrimLinkInfo<S32> > info_list;
-			for (S32 index = 1; index < 5; ++index)
-			{
-				info_list.push_back(infos[index]);
-			}
-			root_info.mergeLinkableSet(info_list);
-			S32 prim_count = root_info.getPrimCount();
-			ensure_equals("01234 prim count should be 5", prim_count, 5);
-			ensure_equals("01234 unlinkable list should have length 0", (S32) info_list.size(), 0);
-		}
-
-		
-		// spheres 0-5 should link no matter what order : 04321
-		{
-			LLPrimLinkInfo<S32> root_info = infos[0];
-			std::list< LLPrimLinkInfo<S32> > info_list;
-			for (S32 index = 4; index > 0; --index)
-			{
-				info_list.push_back(infos[index]);
-			}
-			root_info.mergeLinkableSet(info_list);
-			S32 prim_count = root_info.getPrimCount();
-			ensure_equals("04321 prim count should be 5", prim_count, 5);
-			ensure_equals("04321 unlinkable list should have length 0", (S32) info_list.size(), 0);
-		}
-
-		// spheres 0-4 should link no matter what order : 01423
-		{
-			LLPrimLinkInfo<S32> root_info = infos[0];
-			std::list< LLPrimLinkInfo<S32> > info_list;
-			info_list.push_back(infos[1]);
-			info_list.push_back(infos[4]);
-			info_list.push_back(infos[2]);
-			info_list.push_back(infos[3]);
-			root_info.mergeLinkableSet(info_list);
-			S32 prim_count = root_info.getPrimCount();
-			ensure_equals("01423 prim count should be 5", prim_count, 5);
-			ensure_equals("01423 unlinkable list should have length 0", (S32) info_list.size(), 0);
-		}
-
-		// spheres 0-5 should NOT fully link, only 0-4 
-		{
-			LLPrimLinkInfo<S32> root_info = infos[0];
-			std::list< LLPrimLinkInfo<S32> > info_list;
-			for (S32 index = 1; index < 6; ++index)
-			{
-				info_list.push_back(infos[index]);
-			}
-			root_info.mergeLinkableSet(info_list);
-			S32 prim_count = root_info.getPrimCount();
-			ensure_equals("012345 prim count should be 5", prim_count, 5);
-			ensure_equals("012345 unlinkable list should have length 1", (S32) info_list.size(), 1);
-			std::list< LLPrimLinkInfo<S32> >::iterator info_itr = info_list.begin();
-			if (info_itr != info_list.end())
-			{
-				// examine the contents of the unlinked info
-				std::list<S32> unlinked_indecies;
-				info_itr->getData(unlinked_indecies);
-				// make sure there is only one index in the unlinked_info
-				ensure_equals("012345 unlinkable index count should be 1", (S32) unlinked_indecies.size(), 1);
-				// make sure its value is 6
-				std::list<S32>::iterator unlinked_index_itr = unlinked_indecies.begin();
-				S32 unlinkable_index = *unlinked_index_itr;
-				ensure_equals("012345 unlinkable index should be 5", (S32) unlinkable_index, 5);
-			}
-		}
-		
-		// spheres 0-7 should NOT fully link, only 0-5 
-		{
-			LLPrimLinkInfo<S32> root_info = infos[0];
-			std::list< LLPrimLinkInfo<S32> > info_list;
-			for (S32 index = 1; index < 8; ++index)
-			{
-				info_list.push_back(infos[index]);
-			}
-			root_info.mergeLinkableSet(info_list);
-			S32 prim_count = root_info.getPrimCount();
-			ensure_equals("01234567 prim count should be 5", prim_count, 5);
-			// Should be 1 linkinfo on unlinkable that has 2 prims
-			ensure_equals("01234567 unlinkable list should have length 1", (S32) info_list.size(), 1);
-			std::list< LLPrimLinkInfo<S32> >::iterator info_itr = info_list.begin();
-			if (info_itr != info_list.end())
-			{
-				// make sure there is only one index in the unlinked_info
-				std::list<S32> unlinked_indecies;
-				info_itr->getData(unlinked_indecies);
-				ensure_equals("0123456 unlinkable index count should be 3", (S32) unlinked_indecies.size(), 3);
-
-				// make sure its values are 6 and 7
-				std::list<S32>::iterator unlinked_index_itr = unlinked_indecies.begin();
-				S32 unlinkable_index = *unlinked_index_itr;
-				ensure_equals("0123456 first unlinkable index should be 5", (S32) unlinkable_index, 5);
-				++unlinked_index_itr;
-				unlinkable_index = *unlinked_index_itr;
-				ensure_equals("0123456 second unlinkable index should be 6", (S32) unlinkable_index, 6);
-				++unlinked_index_itr;
-				unlinkable_index = *unlinked_index_itr;
-				ensure_equals("0123456 third unlinkable index should be 7", (S32) unlinkable_index, 7);
-
-			}
-		}
-	}
-
-	template<> template<>
-	void linkable_object::test<3>()
-	{
-		// Here we test the link results between an LLPrimLinkInfo and a set of
-		// randomized LLPrimLinkInfos where the expected results are known.
-		S32 number_of_tests = 5;
-		for (S32 test = 0; test < number_of_tests; ++test)
-		{
-			// the radii are known
-			F32 first_radius = 1.f;
-			F32 second_radius = 2.f;
-			F32 third_radius = 3.f;
-
-			// compute the distances
-			F32 half_milimeter = 0.0005f;
-			F32 max_first_second_span = 3.f * (first_radius + second_radius) + OBJECT_SPAN_BONUS;
-			F32 linkable_distance = max_first_second_span - first_radius - second_radius - half_milimeter;
-
-			F32 max_full_span = 3.f * (0.5f * max_first_second_span + third_radius) + OBJECT_SPAN_BONUS;
-			F32 unlinkable_distance = max_full_span - 0.5f * linkable_distance - third_radius + half_milimeter;
-
-			// compute some random directions
-			LLVector3 first_direction(ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f);
-			first_direction.normalize();
-			LLVector3 second_direction(ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f);
-			second_direction.normalize();
-			LLVector3 third_direction(ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f);
-			third_direction.normalize();
-	
-			// compute the centers
-			LLVector3 first_center = ll_frand(10.f) * first_direction;
-			LLVector3 second_center = first_center + ll_frand(linkable_distance) * second_direction;
-			LLVector3 first_join_center = 0.5f * (first_center + second_center);
-			LLVector3 third_center = first_join_center + unlinkable_distance * third_direction;
-
-			// make sure the second info links and the third does not
-			{
-				// initialize the infos
-				S32 index = 0;
-				LLPrimLinkInfo<S32> first_info(index++, LLSphere(first_center, first_radius));
-				LLPrimLinkInfo<S32> second_info(index++, LLSphere(second_center, second_radius));
-				LLPrimLinkInfo<S32> third_info(index++, LLSphere(third_center, third_radius));
-	
-				// put the second and third infos in a list
-				std::list< LLPrimLinkInfo<S32> > info_list;
-				info_list.push_back(second_info);
-				info_list.push_back(third_info); 
-	
-				// merge the list with the first_info
-				first_info.mergeLinkableSet(info_list);
-				S32 prim_count = first_info.getPrimCount();
-
-				ensure_equals("prim count should be 2", prim_count, 2);
-				ensure_equals("unlinkable list should have length 1", (S32) info_list.size(), 1);
-			}
-
-			// reverse the order and make sure we get the same results
-			{
-				// initialize the infos
-				S32 index = 0;
-				LLPrimLinkInfo<S32> first_info(index++, LLSphere(first_center, first_radius));
-				LLPrimLinkInfo<S32> second_info(index++, LLSphere(second_center, second_radius));
-				LLPrimLinkInfo<S32> third_info(index++, LLSphere(third_center, third_radius));
-	
-				// build the list in the reverse order
-				std::list< LLPrimLinkInfo<S32> > info_list;
-				info_list.push_back(third_info); 
-				info_list.push_back(second_info);
-	
-				// merge the list with the first_info
-				first_info.mergeLinkableSet(info_list);
-				S32 prim_count = first_info.getPrimCount();
-
-				ensure_equals("prim count should be 2", prim_count, 2);
-				ensure_equals("unlinkable list should have length 1", (S32) info_list.size(), 1);
-			}
-		}
-	}
-
-	template<> template<>
-	void linkable_object::test<4>()
-	{
-		// Here we test whether linkability is invarient under permutations
-		// of link order.  To do this we generate a bunch of random spheres
-		// and then try to link them in different ways.
-		//
-		// NOTE: the linkability will only be invarient if there is only one
-		// linkable solution.  Multiple solutions will exist if the set of 
-		// candidates are larger than the maximum linkable distance, or more 
-		// numerous than a single linked object can contain.  This is easily 
-		// understood by considering a very large set of link candidates, 
-		// and first linking preferentially to the left until linking fails, 
-		// then doing the same to the right -- the final solutions will differ.
-		// Hence for this test we must generate candidate sets that lie within 
-		// the linkability envelope of a single object.
-		//
-		// NOTE: a random set of objects will tend to either be totally linkable
-		// or totally not.  That is, the random orientations that 
-
-		F32 root_center_range = 0.f;
-		F32 min_prim_radius = 0.1f;
-		F32 max_prim_radius = 2.f;
-		
-		// Linkability is min(MAX_OBJECT_SPAN,3 *( R1 + R2 ) + BONUS)
-		// 3 * (min_prim_radius + min_prim_radius) + OBJECT_SPAN_BONUS = 6 * min_prim_radius + OBJECT_SPAN_BONUS;
-		// Use .45 instead of .5 to gaurantee objects are within the minimum span.
-		F32 child_center_range = 0.45f * ( (6*min_prim_radius) + OBJECT_SPAN_BONUS );
-
-		S32 number_of_tests = 100;
-		S32 number_of_spheres = 10;
-		S32 number_of_scrambles = 10;
-		S32 number_of_random_bubble_sorts = 10;
-
-		for (S32 test = 0; test < number_of_tests; ++test)
-		{
-			LLSphere sphere;
-			S32 sphere_index = 0;
-
-			// build the root piece
-			randomize_sphere(sphere, root_center_range, min_prim_radius, max_prim_radius);
-			info.set( sphere_index++, sphere );
-
-			// build the unlinked pieces
-			std::list< LLPrimLinkInfo<S32> > info_list;
-			for (; sphere_index < number_of_spheres; ++sphere_index)
-			{
-				randomize_sphere(sphere, child_center_range, min_prim_radius, max_prim_radius);
-				LLPrimLinkInfo<S32> child_info( sphere_index, sphere );
-				info_list.push_back(child_info);
-			}
-
-			// declare the variables used to store the results
-			std::list<S32> first_linked_list;
-
-			{
-				// the link attempt will modify our original info's, so we
-				// have to make copies of the originals for testing
-				LLPrimLinkInfo<S32> test_info( 0, LLSphere(info.getCenter(), 0.5f * info.getDiameter()) );
-				std::list< LLPrimLinkInfo<S32> > test_list;
-				test_list.assign(info_list.begin(), info_list.end());
-
-				// try to link
-				test_info.mergeLinkableSet(test_list);
-	
-				ensure("All prims should link, but did not.",test_list.empty());
-
-				// store the results 
-				test_info.getData(first_linked_list);
-				first_linked_list.sort();
-			}
-
-			// try to link the spheres in various random orders
-			for (S32 scramble = 0; scramble < number_of_scrambles; ++scramble)
-			{
-				LLPrimLinkInfo<S32> test_info(0, LLSphere(info.getCenter(), 0.5f * info.getDiameter()) );
-
-				// scramble the order of the info_list
-				std::list< LLPrimLinkInfo<S32> > test_list;
-				test_list.assign(info_list.begin(), info_list.end());
-				for (S32 i = 0; i < number_of_random_bubble_sorts; i++)
-				{
-					test_list.sort(random_sort);
-				}
-
-				// try to link
-				test_info.mergeLinkableSet(test_list);
-	
-				// get the results 
-				std::list<S32> linked_list;
-				test_info.getData(linked_list);
-				linked_list.sort();
-
-				ensure_equals("linked set size should be order independent",linked_list.size(),first_linked_list.size());
-			}
-		}
-	}
+    struct linkable_data
+    {
+        LLPrimLinkInfo<S32> info;
+    };
+
+    typedef test_group<linkable_data> linkable_test;
+    typedef linkable_test::object linkable_object;
+    tut::linkable_test wtf("prim linkability");
+
+    template<> template<>
+    void linkable_object::test<1>()
+    {
+        // Here we test the boundary of the LLPrimLinkInfo::canLink() method
+        // between semi-random middle-sized objects.
+
+        S32 number_of_tests = 100;
+        for (S32 test = 0; test < number_of_tests; ++test)
+        {
+            // compute the radii that would provide the above max link distance
+            F32 first_radius = 0.f;
+            F32 second_radius = 0.f;
+
+            // compute a random center for the first sphere
+            // compute some random max link distance
+            F32 max_link_span = ll_frand(MAX_OBJECT_SPAN);
+            if (max_link_span < OBJECT_SPAN_BONUS)
+            {
+                max_link_span += OBJECT_SPAN_BONUS;
+            }
+            LLVector3 first_center(
+                    ll_frand(2.f * max_link_span) - max_link_span,
+                    ll_frand(2.f * max_link_span) - max_link_span,
+                    ll_frand(2.f * max_link_span) - max_link_span);
+
+            // put the second sphere at the right distance from the origin
+            // such that it is within the max_link_distance of the first
+            LLVector3 direction(ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f);
+            direction.normalize();
+            F32 half_milimeter = 0.0005f;
+            LLVector3 second_center;
+
+            // max_span = 3 * (first_radius + second_radius) + OBJECT_SPAN_BONUS
+            // make sure they link at short distances
+            {
+                second_center = first_center + (OBJECT_SPAN_BONUS - half_milimeter) * direction;
+                LLPrimLinkInfo<S32> first_info(0, LLSphere(first_center, first_radius) );
+                LLPrimLinkInfo<S32> second_info(1, LLSphere(second_center, second_radius) );
+                ensure("these nearby objects should link", first_info.canLink(second_info) );
+            }
+
+            // make sure they fail to link if we move them apart just a little bit
+            {
+                second_center = first_center + (OBJECT_SPAN_BONUS + half_milimeter) * direction;
+                LLPrimLinkInfo<S32> first_info(0, LLSphere(first_center, first_radius) );
+                LLPrimLinkInfo<S32> second_info(1, LLSphere(second_center, second_radius) );
+                ensure("these nearby objects should NOT link", !first_info.canLink(second_info) );
+            }
+
+            // make sure the objects link or not at medium distances
+            {
+                first_radius = 0.3f * ll_frand(max_link_span - OBJECT_SPAN_BONUS);
+
+                // This is the exact second radius that will link at exactly our random max_link_distance
+                second_radius = ((max_link_span - OBJECT_SPAN_BONUS) / 3.f) - first_radius;
+                second_center = first_center + (max_link_span - first_radius - second_radius - half_milimeter) * direction;
+
+                LLPrimLinkInfo<S32> first_info(0, LLSphere(first_center, first_radius) );
+                LLPrimLinkInfo<S32> second_info(1, LLSphere(second_center, second_radius) );
+
+                ensure("these objects should link", first_info.canLink(second_info) );
+            }
+
+            // make sure they fail to link if we move them apart just a little bit
+            {
+                // move the second sphere such that it is a little too far from the first
+                second_center += (2.f * half_milimeter) * direction;
+                LLPrimLinkInfo<S32> first_info(0, LLSphere(first_center, first_radius) );
+                LLPrimLinkInfo<S32> second_info(1, LLSphere(second_center, second_radius) );
+
+                ensure("these objects should NOT link", !first_info.canLink(second_info) );
+            }
+
+            // make sure things don't link at far distances
+            {
+                second_center = first_center + (MAX_OBJECT_SPAN + 2.f * half_milimeter) * direction;
+                second_radius = 0.3f * MAX_OBJECT_SPAN;
+                LLPrimLinkInfo<S32> first_info(0, LLSphere(first_center, first_radius) );
+                LLPrimLinkInfo<S32> second_info(1, LLSphere(second_center, second_radius) );
+                ensure("these objects should NOT link", !first_info.canLink(second_info) );
+            }
+
+        }
+    }
+
+    template<> template<>
+    void linkable_object::test<2>()
+    {
+
+        // Consider a row of eight spheres in a row, each 10m in diameter and centered
+        // at 10m intervals:  01234567.
+
+        F32 radius = 5.f;
+        F32 spacing = 10.f;
+
+        LLVector3 line_direction(ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f);
+        line_direction.normalize();
+
+        LLVector3 first_center(ll_frand(2.f * spacing) -spacing, ll_frand(2.f * spacing) - spacing, ll_frand(2.f * spacing) - spacing);
+
+        LLPrimLinkInfo<S32> infos[8];
+
+        for (S32 index = 0; index < 8; ++index)
+        {
+            LLVector3 center = first_center + ((F32)(index) * spacing) * line_direction;
+            infos[index].set(index, LLSphere(center, radius));
+        }
+
+        // Max span for 2 spheres of 5m radius is 3 * (5 + 5) + 1 = 31m
+        // spheres 0&2 have a 30m span (from outside edge to outside edge) and should link
+        {
+            LLPrimLinkInfo<S32> root_info = infos[0];
+            std::list< LLPrimLinkInfo<S32> > info_list;
+            info_list.push_back(infos[2]);
+            root_info.mergeLinkableSet(info_list);
+            S32 prim_count = root_info.getPrimCount();
+            ensure_equals("0&2 prim count should be 2", prim_count, 2);
+            ensure_equals("0&2 unlinkable list should have length 0", (S32) info_list.size(), 0);
+        }
+
+
+        // spheres 0&3 have a 40 meter span and should NOT link outright
+        {
+            LLPrimLinkInfo<S32> root_info = infos[0];
+            std::list< LLPrimLinkInfo<S32> > info_list;
+            info_list.push_back(infos[3]);
+            root_info.mergeLinkableSet(info_list);
+            S32 prim_count = root_info.getPrimCount();
+            ensure_equals("0&4 prim count should be 1", prim_count, 1);
+            ensure_equals("0&4 unlinkable list should have length 1", (S32) info_list.size(), 1);
+        }
+
+
+        // spheres 0-4 should link no matter what order : 01234
+        // Total span = 50m, 012 link with a r=15.5 giving max span of 3 * (15.5 + 5) + 1 = 62.5, but the cap is 54m
+        {
+            LLPrimLinkInfo<S32> root_info = infos[0];
+            std::list< LLPrimLinkInfo<S32> > info_list;
+            for (S32 index = 1; index < 5; ++index)
+            {
+                info_list.push_back(infos[index]);
+            }
+            root_info.mergeLinkableSet(info_list);
+            S32 prim_count = root_info.getPrimCount();
+            ensure_equals("01234 prim count should be 5", prim_count, 5);
+            ensure_equals("01234 unlinkable list should have length 0", (S32) info_list.size(), 0);
+        }
+
+
+        // spheres 0-5 should link no matter what order : 04321
+        {
+            LLPrimLinkInfo<S32> root_info = infos[0];
+            std::list< LLPrimLinkInfo<S32> > info_list;
+            for (S32 index = 4; index > 0; --index)
+            {
+                info_list.push_back(infos[index]);
+            }
+            root_info.mergeLinkableSet(info_list);
+            S32 prim_count = root_info.getPrimCount();
+            ensure_equals("04321 prim count should be 5", prim_count, 5);
+            ensure_equals("04321 unlinkable list should have length 0", (S32) info_list.size(), 0);
+        }
+
+        // spheres 0-4 should link no matter what order : 01423
+        {
+            LLPrimLinkInfo<S32> root_info = infos[0];
+            std::list< LLPrimLinkInfo<S32> > info_list;
+            info_list.push_back(infos[1]);
+            info_list.push_back(infos[4]);
+            info_list.push_back(infos[2]);
+            info_list.push_back(infos[3]);
+            root_info.mergeLinkableSet(info_list);
+            S32 prim_count = root_info.getPrimCount();
+            ensure_equals("01423 prim count should be 5", prim_count, 5);
+            ensure_equals("01423 unlinkable list should have length 0", (S32) info_list.size(), 0);
+        }
+
+        // spheres 0-5 should NOT fully link, only 0-4
+        {
+            LLPrimLinkInfo<S32> root_info = infos[0];
+            std::list< LLPrimLinkInfo<S32> > info_list;
+            for (S32 index = 1; index < 6; ++index)
+            {
+                info_list.push_back(infos[index]);
+            }
+            root_info.mergeLinkableSet(info_list);
+            S32 prim_count = root_info.getPrimCount();
+            ensure_equals("012345 prim count should be 5", prim_count, 5);
+            ensure_equals("012345 unlinkable list should have length 1", (S32) info_list.size(), 1);
+            std::list< LLPrimLinkInfo<S32> >::iterator info_itr = info_list.begin();
+            if (info_itr != info_list.end())
+            {
+                // examine the contents of the unlinked info
+                std::list<S32> unlinked_indecies;
+                info_itr->getData(unlinked_indecies);
+                // make sure there is only one index in the unlinked_info
+                ensure_equals("012345 unlinkable index count should be 1", (S32) unlinked_indecies.size(), 1);
+                // make sure its value is 6
+                std::list<S32>::iterator unlinked_index_itr = unlinked_indecies.begin();
+                S32 unlinkable_index = *unlinked_index_itr;
+                ensure_equals("012345 unlinkable index should be 5", (S32) unlinkable_index, 5);
+            }
+        }
+
+        // spheres 0-7 should NOT fully link, only 0-5
+        {
+            LLPrimLinkInfo<S32> root_info = infos[0];
+            std::list< LLPrimLinkInfo<S32> > info_list;
+            for (S32 index = 1; index < 8; ++index)
+            {
+                info_list.push_back(infos[index]);
+            }
+            root_info.mergeLinkableSet(info_list);
+            S32 prim_count = root_info.getPrimCount();
+            ensure_equals("01234567 prim count should be 5", prim_count, 5);
+            // Should be 1 linkinfo on unlinkable that has 2 prims
+            ensure_equals("01234567 unlinkable list should have length 1", (S32) info_list.size(), 1);
+            std::list< LLPrimLinkInfo<S32> >::iterator info_itr = info_list.begin();
+            if (info_itr != info_list.end())
+            {
+                // make sure there is only one index in the unlinked_info
+                std::list<S32> unlinked_indecies;
+                info_itr->getData(unlinked_indecies);
+                ensure_equals("0123456 unlinkable index count should be 3", (S32) unlinked_indecies.size(), 3);
+
+                // make sure its values are 6 and 7
+                std::list<S32>::iterator unlinked_index_itr = unlinked_indecies.begin();
+                S32 unlinkable_index = *unlinked_index_itr;
+                ensure_equals("0123456 first unlinkable index should be 5", (S32) unlinkable_index, 5);
+                ++unlinked_index_itr;
+                unlinkable_index = *unlinked_index_itr;
+                ensure_equals("0123456 second unlinkable index should be 6", (S32) unlinkable_index, 6);
+                ++unlinked_index_itr;
+                unlinkable_index = *unlinked_index_itr;
+                ensure_equals("0123456 third unlinkable index should be 7", (S32) unlinkable_index, 7);
+
+            }
+        }
+    }
+
+    template<> template<>
+    void linkable_object::test<3>()
+    {
+        // Here we test the link results between an LLPrimLinkInfo and a set of
+        // randomized LLPrimLinkInfos where the expected results are known.
+        S32 number_of_tests = 5;
+        for (S32 test = 0; test < number_of_tests; ++test)
+        {
+            // the radii are known
+            F32 first_radius = 1.f;
+            F32 second_radius = 2.f;
+            F32 third_radius = 3.f;
+
+            // compute the distances
+            F32 half_milimeter = 0.0005f;
+            F32 max_first_second_span = 3.f * (first_radius + second_radius) + OBJECT_SPAN_BONUS;
+            F32 linkable_distance = max_first_second_span - first_radius - second_radius - half_milimeter;
+
+            F32 max_full_span = 3.f * (0.5f * max_first_second_span + third_radius) + OBJECT_SPAN_BONUS;
+            F32 unlinkable_distance = max_full_span - 0.5f * linkable_distance - third_radius + half_milimeter;
+
+            // compute some random directions
+            LLVector3 first_direction(ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f);
+            first_direction.normalize();
+            LLVector3 second_direction(ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f);
+            second_direction.normalize();
+            LLVector3 third_direction(ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f);
+            third_direction.normalize();
+
+            // compute the centers
+            LLVector3 first_center = ll_frand(10.f) * first_direction;
+            LLVector3 second_center = first_center + ll_frand(linkable_distance) * second_direction;
+            LLVector3 first_join_center = 0.5f * (first_center + second_center);
+            LLVector3 third_center = first_join_center + unlinkable_distance * third_direction;
+
+            // make sure the second info links and the third does not
+            {
+                // initialize the infos
+                S32 index = 0;
+                LLPrimLinkInfo<S32> first_info(index++, LLSphere(first_center, first_radius));
+                LLPrimLinkInfo<S32> second_info(index++, LLSphere(second_center, second_radius));
+                LLPrimLinkInfo<S32> third_info(index++, LLSphere(third_center, third_radius));
+
+                // put the second and third infos in a list
+                std::list< LLPrimLinkInfo<S32> > info_list;
+                info_list.push_back(second_info);
+                info_list.push_back(third_info);
+
+                // merge the list with the first_info
+                first_info.mergeLinkableSet(info_list);
+                S32 prim_count = first_info.getPrimCount();
+
+                ensure_equals("prim count should be 2", prim_count, 2);
+                ensure_equals("unlinkable list should have length 1", (S32) info_list.size(), 1);
+            }
+
+            // reverse the order and make sure we get the same results
+            {
+                // initialize the infos
+                S32 index = 0;
+                LLPrimLinkInfo<S32> first_info(index++, LLSphere(first_center, first_radius));
+                LLPrimLinkInfo<S32> second_info(index++, LLSphere(second_center, second_radius));
+                LLPrimLinkInfo<S32> third_info(index++, LLSphere(third_center, third_radius));
+
+                // build the list in the reverse order
+                std::list< LLPrimLinkInfo<S32> > info_list;
+                info_list.push_back(third_info);
+                info_list.push_back(second_info);
+
+                // merge the list with the first_info
+                first_info.mergeLinkableSet(info_list);
+                S32 prim_count = first_info.getPrimCount();
+
+                ensure_equals("prim count should be 2", prim_count, 2);
+                ensure_equals("unlinkable list should have length 1", (S32) info_list.size(), 1);
+            }
+        }
+    }
+
+    template<> template<>
+    void linkable_object::test<4>()
+    {
+        // Here we test whether linkability is invarient under permutations
+        // of link order.  To do this we generate a bunch of random spheres
+        // and then try to link them in different ways.
+        //
+        // NOTE: the linkability will only be invarient if there is only one
+        // linkable solution.  Multiple solutions will exist if the set of
+        // candidates are larger than the maximum linkable distance, or more
+        // numerous than a single linked object can contain.  This is easily
+        // understood by considering a very large set of link candidates,
+        // and first linking preferentially to the left until linking fails,
+        // then doing the same to the right -- the final solutions will differ.
+        // Hence for this test we must generate candidate sets that lie within
+        // the linkability envelope of a single object.
+        //
+        // NOTE: a random set of objects will tend to either be totally linkable
+        // or totally not.  That is, the random orientations that
+
+        F32 root_center_range = 0.f;
+        F32 min_prim_radius = 0.1f;
+        F32 max_prim_radius = 2.f;
+
+        // Linkability is min(MAX_OBJECT_SPAN,3 *( R1 + R2 ) + BONUS)
+        // 3 * (min_prim_radius + min_prim_radius) + OBJECT_SPAN_BONUS = 6 * min_prim_radius + OBJECT_SPAN_BONUS;
+        // Use .45 instead of .5 to gaurantee objects are within the minimum span.
+        F32 child_center_range = 0.45f * ( (6*min_prim_radius) + OBJECT_SPAN_BONUS );
+
+        S32 number_of_tests = 100;
+        S32 number_of_spheres = 10;
+        S32 number_of_scrambles = 10;
+        S32 number_of_random_bubble_sorts = 10;
+
+        for (S32 test = 0; test < number_of_tests; ++test)
+        {
+            LLSphere sphere;
+            S32 sphere_index = 0;
+
+            // build the root piece
+            randomize_sphere(sphere, root_center_range, min_prim_radius, max_prim_radius);
+            info.set( sphere_index++, sphere );
+
+            // build the unlinked pieces
+            std::list< LLPrimLinkInfo<S32> > info_list;
+            for (; sphere_index < number_of_spheres; ++sphere_index)
+            {
+                randomize_sphere(sphere, child_center_range, min_prim_radius, max_prim_radius);
+                LLPrimLinkInfo<S32> child_info( sphere_index, sphere );
+                info_list.push_back(child_info);
+            }
+
+            // declare the variables used to store the results
+            std::list<S32> first_linked_list;
+
+            {
+                // the link attempt will modify our original info's, so we
+                // have to make copies of the originals for testing
+                LLPrimLinkInfo<S32> test_info( 0, LLSphere(info.getCenter(), 0.5f * info.getDiameter()) );
+                std::list< LLPrimLinkInfo<S32> > test_list;
+                test_list.assign(info_list.begin(), info_list.end());
+
+                // try to link
+                test_info.mergeLinkableSet(test_list);
+
+                ensure("All prims should link, but did not.",test_list.empty());
+
+                // store the results
+                test_info.getData(first_linked_list);
+                first_linked_list.sort();
+            }
+
+            // try to link the spheres in various random orders
+            for (S32 scramble = 0; scramble < number_of_scrambles; ++scramble)
+            {
+                LLPrimLinkInfo<S32> test_info(0, LLSphere(info.getCenter(), 0.5f * info.getDiameter()) );
+
+                // scramble the order of the info_list
+                std::list< LLPrimLinkInfo<S32> > test_list;
+                test_list.assign(info_list.begin(), info_list.end());
+                for (S32 i = 0; i < number_of_random_bubble_sorts; i++)
+                {
+                    test_list.sort(random_sort);
+                }
+
+                // try to link
+                test_info.mergeLinkableSet(test_list);
+
+                // get the results
+                std::list<S32> linked_list;
+                test_info.getData(linked_list);
+                linked_list.sort();
+
+                ensure_equals("linked set size should be order independent",linked_list.size(),first_linked_list.size());
+            }
+        }
+    }
 }
 
diff --git a/indra/test/print.h b/indra/test/print.h
index 08e36caddf..7577698cc8 100644
--- a/indra/test/print.h
+++ b/indra/test/print.h
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2020-01-02
  * @brief  print() function for debugging
- * 
+ *
  * $LicenseInfo:firstyear=2020&license=viewerlgpl$
  * Copyright (c) 2020, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/test/setenv.h b/indra/test/setenv.h
index ed2de9ccca..a691697adb 100644
--- a/indra/test/setenv.h
+++ b/indra/test/setenv.h
@@ -4,7 +4,7 @@
  * @date   2020-04-01
  * @brief  Provide a way for a particular test program to alter the
  *         environment before entry to main().
- * 
+ *
  * $LicenseInfo:firstyear=2020&license=viewerlgpl$
  * Copyright (c) 2020, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/test/sync.h b/indra/test/sync.h
index bd837cb730..82eef1e5f5 100644
--- a/indra/test/sync.h
+++ b/indra/test/sync.h
@@ -7,7 +7,7 @@
  *         mechanisms. Such tests usually want to interleave coroutine
  *         executions in strictly stepwise fashion. This class supports that
  *         paradigm.
- * 
+ *
  * $LicenseInfo:firstyear=2019&license=viewerlgpl$
  * Copyright (c) 2019, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/test/test.cpp b/indra/test/test.cpp
index f1c5991330..21232e88f5 100644
--- a/indra/test/test.cpp
+++ b/indra/test/test.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file test.cpp
  * @author Phoenix
  * @date 2005-09-26
@@ -7,26 +7,26 @@
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
 
-/** 
+/**
  *
  * You can add tests by creating a new cpp file in this directory, and
  * rebuilding. There are at most 50 tests per testgroup without a
@@ -47,10 +47,10 @@
 #include "apr_getopt.h"
 
 // the CTYPE_WORKAROUND is needed for linux dev stations that don't
-// have the broken libc6 packages needed by our out-of-date static 
+// have the broken libc6 packages needed by our out-of-date static
 // libs (such as libcrypto and libcurl). -- Leviathan 20060113
 #ifdef CTYPE_WORKAROUND
-#	include "ctype_workaround.h"
+#   include "ctype_workaround.h"
 #endif
 
 #ifndef LL_WINDOWS
@@ -85,254 +85,254 @@ void wouldHaveCrashed(const std::string& message);
 
 namespace tut
 {
-	std::string sSourceDir;
+    std::string sSourceDir;
 
-	test_runner_singleton runner;
+    test_runner_singleton runner;
 }
 
 class LLReplayLog
 {
 public:
-	LLReplayLog() {}
-	virtual ~LLReplayLog() {}
+    LLReplayLog() {}
+    virtual ~LLReplayLog() {}
 
-	virtual void reset() {}
-	virtual void replay(std::ostream&) {}
+    virtual void reset() {}
+    virtual void replay(std::ostream&) {}
 };
 
 class RecordToTempFile : public LLError::Recorder, public boost::noncopyable
 {
 public:
-	RecordToTempFile()
-		: LLError::Recorder(),
-		boost::noncopyable(),
-		mTempFile("log", ""),
-		mFile(mTempFile.getName().c_str())
-	{
-	}
-
-	virtual ~RecordToTempFile()
-	{
-		mFile.close();
-	}
-
-	virtual void recordMessage(LLError::ELevel level, const std::string& message)
-	{
+    RecordToTempFile()
+        : LLError::Recorder(),
+        boost::noncopyable(),
+        mTempFile("log", ""),
+        mFile(mTempFile.getName().c_str())
+    {
+    }
+
+    virtual ~RecordToTempFile()
+    {
+        mFile.close();
+    }
+
+    virtual void recordMessage(LLError::ELevel level, const std::string& message)
+    {
         LL_PROFILE_ZONE_SCOPED
-		mFile << message << std::endl;
-	}
-
-	void reset()
-	{
-		mFile.close();
-		mFile.open(mTempFile.getName().c_str());
-	}
-
-	void replay(std::ostream& out)
-	{
-		mFile.close();
-		std::ifstream inf(mTempFile.getName().c_str());
-		std::string line;
-		while (std::getline(inf, line))
-		{
-			out << line << std::endl;
-		}
-	}
+        mFile << message << std::endl;
+    }
+
+    void reset()
+    {
+        mFile.close();
+        mFile.open(mTempFile.getName().c_str());
+    }
+
+    void replay(std::ostream& out)
+    {
+        mFile.close();
+        std::ifstream inf(mTempFile.getName().c_str());
+        std::string line;
+        while (std::getline(inf, line))
+        {
+            out << line << std::endl;
+        }
+    }
 
 private:
-	NamedTempFile mTempFile;
-	llofstream mFile;
+    NamedTempFile mTempFile;
+    llofstream mFile;
 };
 
 class LLReplayLogReal: public LLReplayLog, public boost::noncopyable
 {
 public:
-	LLReplayLogReal(LLError::ELevel level)
-		: LLReplayLog(),
-		boost::noncopyable(),
-		mOldSettings(LLError::saveAndResetSettings()),
-		mRecorder(new RecordToTempFile())
-	{
-		LLError::setFatalFunction(wouldHaveCrashed);
-		LLError::setDefaultLevel(level);
-		LLError::addRecorder(mRecorder);
-	}
-
-	virtual ~LLReplayLogReal()
-	{
-		LLError::removeRecorder(mRecorder);
-		LLError::restoreSettings(mOldSettings);
-	}
-
-	virtual void reset()
-	{
-		std::dynamic_pointer_cast<RecordToTempFile>(mRecorder)->reset();
-	}
-
-	virtual void replay(std::ostream& out)
-	{
-		std::dynamic_pointer_cast<RecordToTempFile>(mRecorder)->replay(out);
-	}
+    LLReplayLogReal(LLError::ELevel level)
+        : LLReplayLog(),
+        boost::noncopyable(),
+        mOldSettings(LLError::saveAndResetSettings()),
+        mRecorder(new RecordToTempFile())
+    {
+        LLError::setFatalFunction(wouldHaveCrashed);
+        LLError::setDefaultLevel(level);
+        LLError::addRecorder(mRecorder);
+    }
+
+    virtual ~LLReplayLogReal()
+    {
+        LLError::removeRecorder(mRecorder);
+        LLError::restoreSettings(mOldSettings);
+    }
+
+    virtual void reset()
+    {
+        std::dynamic_pointer_cast<RecordToTempFile>(mRecorder)->reset();
+    }
+
+    virtual void replay(std::ostream& out)
+    {
+        std::dynamic_pointer_cast<RecordToTempFile>(mRecorder)->replay(out);
+    }
 
 private:
-	LLError::SettingsStoragePtr mOldSettings;
-	LLError::RecorderPtr mRecorder;
+    LLError::SettingsStoragePtr mOldSettings;
+    LLError::RecorderPtr mRecorder;
 };
 
 class LLTestCallback : public chained_callback
 {
-	typedef chained_callback super;
+    typedef chained_callback super;
 
 public:
-	LLTestCallback(bool verbose_mode, std::ostream *stream,
-				   std::shared_ptr<LLReplayLog> replayer) :
-		mVerboseMode(verbose_mode),
-		mTotalTests(0),
-		mPassedTests(0),
-		mFailedTests(0),
-		mSkippedTests(0),
-		// By default, capture a shared_ptr to std::cout, with a no-op "deleter"
-		// so that destroying the shared_ptr makes no attempt to delete std::cout.
-		mStream(std::shared_ptr<std::ostream>(&std::cout, [](std::ostream*){})),
-		mReplayer(replayer)
-	{
-		if (stream)
-		{
-			// We want a boost::iostreams::tee_device that will stream to two
-			// std::ostreams.
-			typedef boost::iostreams::tee_device<std::ostream, std::ostream> TeeDevice;
-			// More than that, though, we want an actual stream using that
-			// device.
-			typedef boost::iostreams::stream<TeeDevice> TeeStream;
-			// Allocate and assign in two separate steps, per Herb Sutter.
-			// (Until we turn on C++11 support, have to wrap *stream with
-			// boost::ref() due to lack of perfect forwarding.)
-			std::shared_ptr<std::ostream> pstream(new TeeStream(std::cout, boost::ref(*stream)));
-			mStream = pstream;
-		}
-	}
-
-	~LLTestCallback()
-	{
-	}
-
-	virtual void run_started()
-	{
-		//std::cout << "run_started" << std::endl;
-		LL_INFOS("TestRunner")<<"Test Started"<< LL_ENDL;
-		super::run_started();
-	}
-
-	virtual void group_started(const std::string& name) {
-		LL_INFOS("TestRunner")<<"Unit test group_started name=" << name << LL_ENDL;
-		*mStream << "Unit test group_started name=" << name << std::endl;
-		super::group_started(name);
-	}
-
-	virtual void group_completed(const std::string& name) {
-		LL_INFOS("TestRunner")<<"Unit test group_completed name=" << name << LL_ENDL;
-		*mStream << "Unit test group_completed name=" << name << std::endl;
-		super::group_completed(name);
-	}
-
-	virtual void test_completed(const tut::test_result& tr)
-	{
-		++mTotalTests;
-
-		// If this test failed, dump requested log messages BEFORE stating the
-		// test result.
-		if (tr.result != tut::test_result::ok && tr.result != tut::test_result::skip)
-		{
-			mReplayer->replay(*mStream);
-		}
-		// Either way, clear stored messages in preparation for next test.
-		mReplayer->reset();
-
-		std::ostringstream out;
-		out << "[" << tr.group << ", " << tr.test;
-		if (! tr.name.empty())
-			out << ": " << tr.name;
-		out << "] ";
-		switch(tr.result)
-		{
-			case tut::test_result::ok:
-				++mPassedTests;
-				out << "ok";
-				break;
-			case tut::test_result::fail:
-				++mFailedTests;
-				out << "fail";
-				break;
-			case tut::test_result::ex:
-				++mFailedTests;
-				out << "exception: " << LLError::Log::demangle(tr.exception_typeid.c_str());
-				break;
-			case tut::test_result::warn:
-				++mFailedTests;
-				out << "test destructor throw";
-				break;
-			case tut::test_result::term:
-				++mFailedTests;
-				out << "abnormal termination";
-				break;
-			case tut::test_result::skip:
-				++mSkippedTests;
-				out << "skipped known failure";
-				break;
-			default:
-				++mFailedTests;
-				out << "unknown (tr.result == " << tr.result << ")";
-		}
-		if(mVerboseMode || (tr.result != tut::test_result::ok))
-		{
-			*mStream << out.str();
-			if(!tr.message.empty())
-			{
-				*mStream << ": '" << tr.message << "'";
-				LL_WARNS("TestRunner") << "not ok : "<<tr.message << LL_ENDL;
-			}
-			*mStream << std::endl;
-		}
-		LL_INFOS("TestRunner")<<out.str()<<LL_ENDL;
-		super::test_completed(tr);
-	}
-
-	virtual int getFailedTests() const { return mFailedTests; }
-
-	virtual void run_completed()
-	{
-		*mStream << "\tTotal Tests:\t" << mTotalTests << std::endl;
-		*mStream << "\tPassed Tests:\t" << mPassedTests;
-		if (mPassedTests == mTotalTests)
-		{
-			*mStream << "\tYAY!! \\o/";
-		}
-		*mStream << std::endl;
-
-		if (mSkippedTests > 0)
-		{
-			*mStream << "\tSkipped known failures:\t" << mSkippedTests
-			<< std::endl;
-		}
-
-		if(mFailedTests > 0)
-		{
-			*mStream << "*********************************" << std::endl;
-			*mStream << "Failed Tests:\t" << mFailedTests << std::endl;
-			*mStream << "Please report or fix the problem." << std::endl;
-			*mStream << "*********************************" << std::endl;
-		}
-		super::run_completed();
-	}
+    LLTestCallback(bool verbose_mode, std::ostream *stream,
+                   std::shared_ptr<LLReplayLog> replayer) :
+        mVerboseMode(verbose_mode),
+        mTotalTests(0),
+        mPassedTests(0),
+        mFailedTests(0),
+        mSkippedTests(0),
+        // By default, capture a shared_ptr to std::cout, with a no-op "deleter"
+        // so that destroying the shared_ptr makes no attempt to delete std::cout.
+        mStream(std::shared_ptr<std::ostream>(&std::cout, [](std::ostream*){})),
+        mReplayer(replayer)
+    {
+        if (stream)
+        {
+            // We want a boost::iostreams::tee_device that will stream to two
+            // std::ostreams.
+            typedef boost::iostreams::tee_device<std::ostream, std::ostream> TeeDevice;
+            // More than that, though, we want an actual stream using that
+            // device.
+            typedef boost::iostreams::stream<TeeDevice> TeeStream;
+            // Allocate and assign in two separate steps, per Herb Sutter.
+            // (Until we turn on C++11 support, have to wrap *stream with
+            // boost::ref() due to lack of perfect forwarding.)
+            std::shared_ptr<std::ostream> pstream(new TeeStream(std::cout, boost::ref(*stream)));
+            mStream = pstream;
+        }
+    }
+
+    ~LLTestCallback()
+    {
+    }
+
+    virtual void run_started()
+    {
+        //std::cout << "run_started" << std::endl;
+        LL_INFOS("TestRunner")<<"Test Started"<< LL_ENDL;
+        super::run_started();
+    }
+
+    virtual void group_started(const std::string& name) {
+        LL_INFOS("TestRunner")<<"Unit test group_started name=" << name << LL_ENDL;
+        *mStream << "Unit test group_started name=" << name << std::endl;
+        super::group_started(name);
+    }
+
+    virtual void group_completed(const std::string& name) {
+        LL_INFOS("TestRunner")<<"Unit test group_completed name=" << name << LL_ENDL;
+        *mStream << "Unit test group_completed name=" << name << std::endl;
+        super::group_completed(name);
+    }
+
+    virtual void test_completed(const tut::test_result& tr)
+    {
+        ++mTotalTests;
+
+        // If this test failed, dump requested log messages BEFORE stating the
+        // test result.
+        if (tr.result != tut::test_result::ok && tr.result != tut::test_result::skip)
+        {
+            mReplayer->replay(*mStream);
+        }
+        // Either way, clear stored messages in preparation for next test.
+        mReplayer->reset();
+
+        std::ostringstream out;
+        out << "[" << tr.group << ", " << tr.test;
+        if (! tr.name.empty())
+            out << ": " << tr.name;
+        out << "] ";
+        switch(tr.result)
+        {
+            case tut::test_result::ok:
+                ++mPassedTests;
+                out << "ok";
+                break;
+            case tut::test_result::fail:
+                ++mFailedTests;
+                out << "fail";
+                break;
+            case tut::test_result::ex:
+                ++mFailedTests;
+                out << "exception: " << LLError::Log::demangle(tr.exception_typeid.c_str());
+                break;
+            case tut::test_result::warn:
+                ++mFailedTests;
+                out << "test destructor throw";
+                break;
+            case tut::test_result::term:
+                ++mFailedTests;
+                out << "abnormal termination";
+                break;
+            case tut::test_result::skip:
+                ++mSkippedTests;
+                out << "skipped known failure";
+                break;
+            default:
+                ++mFailedTests;
+                out << "unknown (tr.result == " << tr.result << ")";
+        }
+        if(mVerboseMode || (tr.result != tut::test_result::ok))
+        {
+            *mStream << out.str();
+            if(!tr.message.empty())
+            {
+                *mStream << ": '" << tr.message << "'";
+                LL_WARNS("TestRunner") << "not ok : "<<tr.message << LL_ENDL;
+            }
+            *mStream << std::endl;
+        }
+        LL_INFOS("TestRunner")<<out.str()<<LL_ENDL;
+        super::test_completed(tr);
+    }
+
+    virtual int getFailedTests() const { return mFailedTests; }
+
+    virtual void run_completed()
+    {
+        *mStream << "\tTotal Tests:\t" << mTotalTests << std::endl;
+        *mStream << "\tPassed Tests:\t" << mPassedTests;
+        if (mPassedTests == mTotalTests)
+        {
+            *mStream << "\tYAY!! \\o/";
+        }
+        *mStream << std::endl;
+
+        if (mSkippedTests > 0)
+        {
+            *mStream << "\tSkipped known failures:\t" << mSkippedTests
+            << std::endl;
+        }
+
+        if(mFailedTests > 0)
+        {
+            *mStream << "*********************************" << std::endl;
+            *mStream << "Failed Tests:\t" << mFailedTests << std::endl;
+            *mStream << "Please report or fix the problem." << std::endl;
+            *mStream << "*********************************" << std::endl;
+        }
+        super::run_completed();
+    }
 
 protected:
-	bool mVerboseMode;
-	int mTotalTests;
-	int mPassedTests;
-	int mFailedTests;
-	int mSkippedTests;
-	std::shared_ptr<std::ostream> mStream;
-	std::shared_ptr<LLReplayLog> mReplayer;
+    bool mVerboseMode;
+    int mTotalTests;
+    int mPassedTests;
+    int mFailedTests;
+    int mSkippedTests;
+    std::shared_ptr<std::ostream> mStream;
+    std::shared_ptr<LLReplayLog> mReplayer;
 };
 
 // TeamCity specific class which emits service messages
@@ -341,358 +341,358 @@ protected:
 class LLTCTestCallback : public LLTestCallback
 {
 public:
-	LLTCTestCallback(bool verbose_mode, std::ostream *stream,
-					 std::shared_ptr<LLReplayLog> replayer) :
-		LLTestCallback(verbose_mode, stream, replayer)
-	{
-	}
-
-	~LLTCTestCallback()
-	{
-	}
-
-	virtual void group_started(const std::string& name) {
-		LLTestCallback::group_started(name);
-		std::cout << "\n##teamcity[testSuiteStarted name='" << escape(name) << "']" << std::endl;
-	}
-
-	virtual void group_completed(const std::string& name) {
-		LLTestCallback::group_completed(name);
-		std::cout << "##teamcity[testSuiteFinished name='" << escape(name) << "']" << std::endl;
-	}
-
-	virtual void test_completed(const tut::test_result& tr)
-	{
-		std::string testname(STRINGIZE(tr.group << "." << tr.test));
-		if (! tr.name.empty())
-		{
-			testname.append(":");
-			testname.append(tr.name);
-		}
-		testname = escape(testname);
-
-		// Sadly, tut::callback doesn't give us control at test start; have to
-		// backfill start message into TC output.
-		std::cout << "##teamcity[testStarted name='" << testname << "']" << std::endl;
-
-		// now forward call to base class so any output produced there is in
-		// the right TC context
-		LLTestCallback::test_completed(tr);
-
-		switch(tr.result)
-		{
-			case tut::test_result::ok:
-				break;
-
-			case tut::test_result::fail:
-			case tut::test_result::ex:
-			case tut::test_result::warn:
-			case tut::test_result::term:
-				std::cout << "##teamcity[testFailed name='" << testname
-						  << "' message='" << escape(tr.message) << "']" << std::endl;
-				break;
-
-			case tut::test_result::skip:
-				std::cout << "##teamcity[testIgnored name='" << testname << "']" << std::endl;
-				break;
-
-			default:
-				break;
-		}
-
-		std::cout << "##teamcity[testFinished name='" << testname << "']" << std::endl;
-	}
-
-	static std::string escape(const std::string& str)
-	{
-		// Per http://confluence.jetbrains.net/display/TCD65/Build+Script+Interaction+with+TeamCity#BuildScriptInteractionwithTeamCity-ServiceMessages
-		std::string result;
-		for (char c : str)
-		{
-			switch (c)
-			{
-			case '\'':
-				result.append("|'");
-				break;
-			case '\n':
-				result.append("|n");
-				break;
-			case '\r':
-				result.append("|r");
-				break;
+    LLTCTestCallback(bool verbose_mode, std::ostream *stream,
+                     std::shared_ptr<LLReplayLog> replayer) :
+        LLTestCallback(verbose_mode, stream, replayer)
+    {
+    }
+
+    ~LLTCTestCallback()
+    {
+    }
+
+    virtual void group_started(const std::string& name) {
+        LLTestCallback::group_started(name);
+        std::cout << "\n##teamcity[testSuiteStarted name='" << escape(name) << "']" << std::endl;
+    }
+
+    virtual void group_completed(const std::string& name) {
+        LLTestCallback::group_completed(name);
+        std::cout << "##teamcity[testSuiteFinished name='" << escape(name) << "']" << std::endl;
+    }
+
+    virtual void test_completed(const tut::test_result& tr)
+    {
+        std::string testname(STRINGIZE(tr.group << "." << tr.test));
+        if (! tr.name.empty())
+        {
+            testname.append(":");
+            testname.append(tr.name);
+        }
+        testname = escape(testname);
+
+        // Sadly, tut::callback doesn't give us control at test start; have to
+        // backfill start message into TC output.
+        std::cout << "##teamcity[testStarted name='" << testname << "']" << std::endl;
+
+        // now forward call to base class so any output produced there is in
+        // the right TC context
+        LLTestCallback::test_completed(tr);
+
+        switch(tr.result)
+        {
+            case tut::test_result::ok:
+                break;
+
+            case tut::test_result::fail:
+            case tut::test_result::ex:
+            case tut::test_result::warn:
+            case tut::test_result::term:
+                std::cout << "##teamcity[testFailed name='" << testname
+                          << "' message='" << escape(tr.message) << "']" << std::endl;
+                break;
+
+            case tut::test_result::skip:
+                std::cout << "##teamcity[testIgnored name='" << testname << "']" << std::endl;
+                break;
+
+            default:
+                break;
+        }
+
+        std::cout << "##teamcity[testFinished name='" << testname << "']" << std::endl;
+    }
+
+    static std::string escape(const std::string& str)
+    {
+        // Per http://confluence.jetbrains.net/display/TCD65/Build+Script+Interaction+with+TeamCity#BuildScriptInteractionwithTeamCity-ServiceMessages
+        std::string result;
+        for (char c : str)
+        {
+            switch (c)
+            {
+            case '\'':
+                result.append("|'");
+                break;
+            case '\n':
+                result.append("|n");
+                break;
+            case '\r':
+                result.append("|r");
+                break;
 /*==========================================================================*|
-			// These are not possible 'char' values from a std::string.
-			case '\u0085':			// next line
-				result.append("|x");
-				break;
-			case '\u2028':			// line separator
-				result.append("|l");
-				break;
-			case '\u2029':			// paragraph separator
-				result.append("|p");
-				break;
+            // These are not possible 'char' values from a std::string.
+            case '\u0085':          // next line
+                result.append("|x");
+                break;
+            case '\u2028':          // line separator
+                result.append("|l");
+                break;
+            case '\u2029':          // paragraph separator
+                result.append("|p");
+                break;
 |*==========================================================================*/
-			case '|':
-				result.append("||");
-				break;
-			case '[':
-				result.append("|[");
-				break;
-			case ']':
-				result.append("|]");
-				break;
-			default:
-				result.push_back(c);
-				break;
-			}
-		}
-		return result;
-	}
+            case '|':
+                result.append("||");
+                break;
+            case '[':
+                result.append("|[");
+                break;
+            case ']':
+                result.append("|]");
+                break;
+            default:
+                result.push_back(c);
+                break;
+            }
+        }
+        return result;
+    }
 };
 
 
 static const apr_getopt_option_t TEST_CL_OPTIONS[] =
 {
-	{"help", 'h', 0, "Print the help message."},
-	{"list", 'l', 0, "List available test groups."},
-	{"verbose", 'v', 0, "Verbose output."},
-	{"group", 'g', 1, "Run test group specified by option argument."},
-	{"output", 'o', 1, "Write output to the named file."},
-	{"sourcedir", 's', 1, "Project source file directory from CMake."},
-	{"touch", 't', 1, "Touch the given file if all tests succeed"},
-	{"wait", 'w', 0, "Wait for input before exit."},
-	{"debug", 'd', 0, "Emit full debug logs."},
-	{"suitename", 'x', 1, "Run tests using this suitename"},
-	{0, 0, 0, 0}
+    {"help", 'h', 0, "Print the help message."},
+    {"list", 'l', 0, "List available test groups."},
+    {"verbose", 'v', 0, "Verbose output."},
+    {"group", 'g', 1, "Run test group specified by option argument."},
+    {"output", 'o', 1, "Write output to the named file."},
+    {"sourcedir", 's', 1, "Project source file directory from CMake."},
+    {"touch", 't', 1, "Touch the given file if all tests succeed"},
+    {"wait", 'w', 0, "Wait for input before exit."},
+    {"debug", 'd', 0, "Emit full debug logs."},
+    {"suitename", 'x', 1, "Run tests using this suitename"},
+    {0, 0, 0, 0}
 };
 
 void stream_usage(std::ostream& s, const char* app)
 {
-	s << "Usage: " << app << " [OPTIONS]" << std::endl
-	<< std::endl;
-
-	s << "This application runs the unit tests." << std::endl << std::endl;
-
-	s << "Options: " << std::endl;
-	const apr_getopt_option_t* option = &TEST_CL_OPTIONS[0];
-	while(option->name)
-	{
-		s << "  ";
-		s << "  -" << (char)option->optch << ", --" << option->name
-		<< std::endl;
-		s << "\t" << option->description << std::endl << std::endl;
-		++option;
-	}
-
-	s << app << " is also sensitive to environment variables:\n"
-	  << "LOGTEST=level : for all tests, emit log messages at level 'level'\n"
-	  << "LOGFAIL=level : only for failed tests, emit log messages at level 'level'\n"
-	  << "where 'level' is one of ALL, DEBUG, INFO, WARN, ERROR, NONE.\n"
-	  << "--debug is like LOGTEST=DEBUG, but --debug overrides LOGTEST,\n"
-	  << "while LOGTEST overrides LOGFAIL.\n\n";
-
-	s << "Examples:" << std::endl;
-	s << "  " << app << " --verbose" << std::endl;
-	s << "\tRun all the tests and report all results." << std::endl;
-	s << "  " << app << " --list" << std::endl;
-	s << "\tList all available test groups." << std::endl;
-	s << "  " << app << " --group=uuid" << std::endl;
-	s << "\tRun the test group 'uuid'." << std::endl;
-
-	s << "\n\n"
-	  << "In any event, logs are recorded in the build directory by appending\n"
-	  << "the suffix '.log' to the full path name of this application.\n"
-	  << "If no level is specified as described above, these log files are at\n"
-	  << "DEBUG level.\n"
-		;
+    s << "Usage: " << app << " [OPTIONS]" << std::endl
+    << std::endl;
+
+    s << "This application runs the unit tests." << std::endl << std::endl;
+
+    s << "Options: " << std::endl;
+    const apr_getopt_option_t* option = &TEST_CL_OPTIONS[0];
+    while(option->name)
+    {
+        s << "  ";
+        s << "  -" << (char)option->optch << ", --" << option->name
+        << std::endl;
+        s << "\t" << option->description << std::endl << std::endl;
+        ++option;
+    }
+
+    s << app << " is also sensitive to environment variables:\n"
+      << "LOGTEST=level : for all tests, emit log messages at level 'level'\n"
+      << "LOGFAIL=level : only for failed tests, emit log messages at level 'level'\n"
+      << "where 'level' is one of ALL, DEBUG, INFO, WARN, ERROR, NONE.\n"
+      << "--debug is like LOGTEST=DEBUG, but --debug overrides LOGTEST,\n"
+      << "while LOGTEST overrides LOGFAIL.\n\n";
+
+    s << "Examples:" << std::endl;
+    s << "  " << app << " --verbose" << std::endl;
+    s << "\tRun all the tests and report all results." << std::endl;
+    s << "  " << app << " --list" << std::endl;
+    s << "\tList all available test groups." << std::endl;
+    s << "  " << app << " --group=uuid" << std::endl;
+    s << "\tRun the test group 'uuid'." << std::endl;
+
+    s << "\n\n"
+      << "In any event, logs are recorded in the build directory by appending\n"
+      << "the suffix '.log' to the full path name of this application.\n"
+      << "If no level is specified as described above, these log files are at\n"
+      << "DEBUG level.\n"
+        ;
 }
 
 void stream_groups(std::ostream& s, const char* app)
 {
-	s << "Registered test groups:" << std::endl;
-	tut::groupnames gl = tut::runner.get().list_groups();
-	tut::groupnames::const_iterator it = gl.begin();
-	tut::groupnames::const_iterator end = gl.end();
-	for(; it != end; ++it)
-	{
-		s << "  " << *(it) << std::endl;
-	}
+    s << "Registered test groups:" << std::endl;
+    tut::groupnames gl = tut::runner.get().list_groups();
+    tut::groupnames::const_iterator it = gl.begin();
+    tut::groupnames::const_iterator end = gl.end();
+    for(; it != end; ++it)
+    {
+        s << "  " << *(it) << std::endl;
+    }
 }
 
 void wouldHaveCrashed(const std::string& message)
 {
-	tut::fail("llerrs message: " + message);
+    tut::fail("llerrs message: " + message);
 }
 
 static LLTrace::ThreadRecorder* sMasterThreadRecorder = NULL;
 
 int main(int argc, char **argv)
 {
-	// The following line must be executed to initialize Google Mock
-	// (and Google Test) before running the tests.
+    // The following line must be executed to initialize Google Mock
+    // (and Google Test) before running the tests.
 #ifndef LL_WINDOWS
-	::testing::InitGoogleMock(&argc, argv);
+    ::testing::InitGoogleMock(&argc, argv);
 #endif
 
-	ll_init_apr();
-	apr_getopt_t* os = NULL;
-	if(APR_SUCCESS != apr_getopt_init(&os, gAPRPoolp, argc, argv))
-	{
-		std::cerr << "apr_getopt_init() failed" << std::endl;
-		return 1;
-	}
-
-	// values used for controlling application
-	bool verbose_mode = false;
-	bool wait_at_exit = false;
-	std::string test_group;
-	std::string suite_name;
-
-	// LOGTEST overrides default, but can be overridden by --debug.
-	const char* LOGTEST = getenv("LOGTEST");
-
-	// values used for options parsing
-	apr_status_t apr_err;
-	const char* opt_arg = NULL;
-	int opt_id = 0;
-	std::unique_ptr<llofstream> output;
-	const char *touch = NULL;
-
-	while(true)
-	{
-		apr_err = apr_getopt_long(os, TEST_CL_OPTIONS, &opt_id, &opt_arg);
-		if(APR_STATUS_IS_EOF(apr_err)) break;
-		if(apr_err)
-		{
-			char buf[255];		/* Flawfinder: ignore */
-			std::cerr << "Error parsing options: "
-			<< apr_strerror(apr_err, buf, 255) << std::endl;
-			return 1;
-		}
-		switch (opt_id)
-		{
-			case 'g':
-				test_group.assign(opt_arg);
-				break;
-			case 'h':
-				stream_usage(std::cout, argv[0]);
-				return 0;
-				break;
-			case 'l':
-				stream_groups(std::cout, argv[0]);
-				return 0;
-			case 'v':
-				verbose_mode = true;
-				break;
-			case 'o':
-				output.reset(new llofstream);
-				output->open(opt_arg);
-				break;
-			case 's':	// --sourcedir
-				tut::sSourceDir = opt_arg;
-				// For convenience, so you can use tut::sSourceDir + "myfile"
-				tut::sSourceDir += '/';
-				break;
-			case 't':
-				touch = opt_arg;
-				break;
-			case 'w':
-				wait_at_exit = true;
-				break;
-			case 'd':
-				LOGTEST = "DEBUG";
-				break;
-			case 'x':
-				suite_name.assign(opt_arg);
-				break;
-			default:
-				stream_usage(std::cerr, argv[0]);
-				return 1;
-				break;
-		}
-	}
-
-	// set up logging
-	const char* LOGFAIL = getenv("LOGFAIL");
-	std::shared_ptr<LLReplayLog> replayer{std::make_shared<LLReplayLog>()};
-
-	// Testing environment variables for both 'set' and 'not empty' allows a
-	// user to suppress a pre-existing environment variable by forcing empty.
-	if (LOGTEST && *LOGTEST)
-	{
-		LLError::initForApplication(".", ".", true /* log to stderr */);
-		LLError::setDefaultLevel(LLError::decodeLevel(LOGTEST));
-	}
-	else
-	{
-		LLError::initForApplication(".", ".", false /* do not log to stderr */);
-		LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
-		if (LOGFAIL && *LOGFAIL)
-		{
-			LLError::ELevel level = LLError::decodeLevel(LOGFAIL);
-			replayer.reset(new LLReplayLogReal(level));
-		}
-	}
-	LLError::setFatalFunction(wouldHaveCrashed);
-	std::string test_app_name(argv[0]);
-	std::string test_log = test_app_name + ".log";
-	LLFile::remove(test_log);
-	LLError::logToFile(test_log);
+    ll_init_apr();
+    apr_getopt_t* os = NULL;
+    if(APR_SUCCESS != apr_getopt_init(&os, gAPRPoolp, argc, argv))
+    {
+        std::cerr << "apr_getopt_init() failed" << std::endl;
+        return 1;
+    }
+
+    // values used for controlling application
+    bool verbose_mode = false;
+    bool wait_at_exit = false;
+    std::string test_group;
+    std::string suite_name;
+
+    // LOGTEST overrides default, but can be overridden by --debug.
+    const char* LOGTEST = getenv("LOGTEST");
+
+    // values used for options parsing
+    apr_status_t apr_err;
+    const char* opt_arg = NULL;
+    int opt_id = 0;
+    std::unique_ptr<llofstream> output;
+    const char *touch = NULL;
+
+    while(true)
+    {
+        apr_err = apr_getopt_long(os, TEST_CL_OPTIONS, &opt_id, &opt_arg);
+        if(APR_STATUS_IS_EOF(apr_err)) break;
+        if(apr_err)
+        {
+            char buf[255];      /* Flawfinder: ignore */
+            std::cerr << "Error parsing options: "
+            << apr_strerror(apr_err, buf, 255) << std::endl;
+            return 1;
+        }
+        switch (opt_id)
+        {
+            case 'g':
+                test_group.assign(opt_arg);
+                break;
+            case 'h':
+                stream_usage(std::cout, argv[0]);
+                return 0;
+                break;
+            case 'l':
+                stream_groups(std::cout, argv[0]);
+                return 0;
+            case 'v':
+                verbose_mode = true;
+                break;
+            case 'o':
+                output.reset(new llofstream);
+                output->open(opt_arg);
+                break;
+            case 's':   // --sourcedir
+                tut::sSourceDir = opt_arg;
+                // For convenience, so you can use tut::sSourceDir + "myfile"
+                tut::sSourceDir += '/';
+                break;
+            case 't':
+                touch = opt_arg;
+                break;
+            case 'w':
+                wait_at_exit = true;
+                break;
+            case 'd':
+                LOGTEST = "DEBUG";
+                break;
+            case 'x':
+                suite_name.assign(opt_arg);
+                break;
+            default:
+                stream_usage(std::cerr, argv[0]);
+                return 1;
+                break;
+        }
+    }
+
+    // set up logging
+    const char* LOGFAIL = getenv("LOGFAIL");
+    std::shared_ptr<LLReplayLog> replayer{std::make_shared<LLReplayLog>()};
+
+    // Testing environment variables for both 'set' and 'not empty' allows a
+    // user to suppress a pre-existing environment variable by forcing empty.
+    if (LOGTEST && *LOGTEST)
+    {
+        LLError::initForApplication(".", ".", true /* log to stderr */);
+        LLError::setDefaultLevel(LLError::decodeLevel(LOGTEST));
+    }
+    else
+    {
+        LLError::initForApplication(".", ".", false /* do not log to stderr */);
+        LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
+        if (LOGFAIL && *LOGFAIL)
+        {
+            LLError::ELevel level = LLError::decodeLevel(LOGFAIL);
+            replayer.reset(new LLReplayLogReal(level));
+        }
+    }
+    LLError::setFatalFunction(wouldHaveCrashed);
+    std::string test_app_name(argv[0]);
+    std::string test_log = test_app_name + ".log";
+    LLFile::remove(test_log);
+    LLError::logToFile(test_log);
 
 #ifdef CTYPE_WORKAROUND
-	ctype_workaround();
+    ctype_workaround();
 #endif
 
-	if (!sMasterThreadRecorder)
-	{
-		sMasterThreadRecorder = new LLTrace::ThreadRecorder();
-		LLTrace::set_master_thread_recorder(sMasterThreadRecorder);
-	}
-
-	// run the tests
-
-	LLTestCallback* mycallback;
-	if (getenv("TEAMCITY_PROJECT_NAME"))
-	{
-		mycallback = new LLTCTestCallback(verbose_mode, output.get(), replayer);
-	}
-	else
-	{
-		mycallback = new LLTestCallback(verbose_mode, output.get(), replayer);
-	}
-
-	// a chained_callback subclass must be linked with previous
-	mycallback->link();
-
-	if(test_group.empty())
-	{
-		tut::runner.get().run_tests();
-	}
-	else
-	{
-		tut::runner.get().run_tests(test_group);
-	}
-
-	bool success = (mycallback->getFailedTests() == 0);
-
-	if (wait_at_exit)
-	{
-		std::cerr << "Press return to exit..." << std::endl;
-		std::cin.get();
-	}
-
-	if (touch && success)
-	{
-		llofstream s;
-		s.open(touch);
-		s << "ok" << std::endl;
-		s.close();
-	}
-
-	ll_cleanup_apr();
-
-	int retval = (success ? 0 : 1);
-	return retval;
-
-	//delete mycallback;
+    if (!sMasterThreadRecorder)
+    {
+        sMasterThreadRecorder = new LLTrace::ThreadRecorder();
+        LLTrace::set_master_thread_recorder(sMasterThreadRecorder);
+    }
+
+    // run the tests
+
+    LLTestCallback* mycallback;
+    if (getenv("TEAMCITY_PROJECT_NAME"))
+    {
+        mycallback = new LLTCTestCallback(verbose_mode, output.get(), replayer);
+    }
+    else
+    {
+        mycallback = new LLTestCallback(verbose_mode, output.get(), replayer);
+    }
+
+    // a chained_callback subclass must be linked with previous
+    mycallback->link();
+
+    if(test_group.empty())
+    {
+        tut::runner.get().run_tests();
+    }
+    else
+    {
+        tut::runner.get().run_tests(test_group);
+    }
+
+    bool success = (mycallback->getFailedTests() == 0);
+
+    if (wait_at_exit)
+    {
+        std::cerr << "Press return to exit..." << std::endl;
+        std::cin.get();
+    }
+
+    if (touch && success)
+    {
+        llofstream s;
+        s.open(touch);
+        s << "ok" << std::endl;
+        s.close();
+    }
+
+    ll_cleanup_apr();
+
+    int retval = (success ? 0 : 1);
+    return retval;
+
+    //delete mycallback;
 }
diff --git a/indra/test/test.h b/indra/test/test.h
index 40c94283ec..3db33e85f7 100644
--- a/indra/test/test.h
+++ b/indra/test/test.h
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file test.h
  * @author James
  * @date 2009-01-12
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2009&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -31,14 +31,14 @@
 
 namespace tut
 {
-	// Source code directory from CMake, used for loading test data and
-	// configuration.  For example:
-	//
-	// loadMyConfig( sSourceDir + "config.dat" );
-	//
-	// Use sparingly, as hitting the file system slows down test execution
-	// and hence every compile. JC
-	extern std::string sSourceDir;
+    // Source code directory from CMake, used for loading test data and
+    // configuration.  For example:
+    //
+    // loadMyConfig( sSourceDir + "config.dat" );
+    //
+    // Use sparingly, as hitting the file system slows down test execution
+    // and hence every compile. JC
+    extern std::string sSourceDir;
 }
 
 #endif