Merge branch 'release/maint-b' into pipewire-linux-volume-catcher

43 files changed, 5455 insertions, 5460 deletions

diff --git a/indra/llcommon/tests/StringVec.h b/indra/llcommon/tests/StringVec.h
index a380b00a05..4311cba992 100644
--- a/indra/llcommon/tests/StringVec.h
+++ b/indra/llcommon/tests/StringVec.h
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2012-02-24
  * @brief  Extend TUT ensure_equals() to handle std::vector<std::string>
- * 
+ *
  * $LicenseInfo:firstyear=2012&license=viewerlgpl$
  * Copyright (c) 2012, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/llcommon/tests/apply_test.cpp b/indra/llcommon/tests/apply_test.cpp
index 56b497e0c8..6d213c2db9 100644
--- a/indra/llcommon/tests/apply_test.cpp
+++ b/indra/llcommon/tests/apply_test.cpp
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2022-12-19
  * @brief  Test for apply.
- * 
+ *
  * $LicenseInfo:firstyear=2022&license=viewerlgpl$
  * Copyright (c) 2022, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/llcommon/tests/bitpack_test.cpp b/indra/llcommon/tests/bitpack_test.cpp
index 9bfd567068..2810f926af 100644
--- a/indra/llcommon/tests/bitpack_test.cpp
+++ b/indra/llcommon/tests/bitpack_test.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 "../llbitpack.h"
@@ -35,84 +35,84 @@
 
 namespace tut
 {
-	struct bit_pack
-	{
-	};
-	typedef test_group<bit_pack> bit_pack_t;
-	typedef bit_pack_t::object bit_pack_object_t;
-	tut::bit_pack_t tut_bit_pack("LLBitPack");
-
-	// pack -> unpack
-	template<> template<>
-	void bit_pack_object_t::test<1>()
-	{
-		U8 packbuffer[255];
-		U8 unpackbuffer[255];
-		int pack_bufsize = 0;
-		int unpack_bufsize = 0;
-
-		LLBitPack bitpack(packbuffer, 255);
-
-		char str[] = "SecondLife is a 3D virtual world";
-		int len = sizeof(str);
-		pack_bufsize = bitpack.bitPack((U8*) str, len*8);
-		pack_bufsize = bitpack.flushBitPack();
-
-		LLBitPack bitunpack(packbuffer, pack_bufsize*8);
-		unpack_bufsize = bitunpack.bitUnpack(unpackbuffer, len*8);
-		ensure("bitPack: unpack size should be same as string size prior to pack", len == unpack_bufsize);
-		ensure_memory_matches("str->bitPack->bitUnpack should be equal to string", str, len, unpackbuffer, unpack_bufsize); 
-	}
-
-	// pack large, unpack in individual bytes
-	template<> template<>
-	void bit_pack_object_t::test<2>()
-	{
-		U8 packbuffer[255];
-		U8 unpackbuffer[255];
-		int pack_bufsize = 0;
-
-		LLBitPack bitpack(packbuffer, 255);
-
-		char str[] = "SecondLife";
-		int len = sizeof(str);
-		pack_bufsize = bitpack.bitPack((U8*) str, len*8);
-		pack_bufsize = bitpack.flushBitPack();
-
-		LLBitPack bitunpack(packbuffer, pack_bufsize*8);
-		bitunpack.bitUnpack(&unpackbuffer[0], 8);
-		ensure("bitPack: individual unpack: 0", unpackbuffer[0] == (U8) str[0]);
-		bitunpack.bitUnpack(&unpackbuffer[0], 8);
-		ensure("bitPack: individual unpack: 1", unpackbuffer[0] == (U8) str[1]);
-		bitunpack.bitUnpack(&unpackbuffer[0], 8);
-		ensure("bitPack: individual unpack: 2", unpackbuffer[0] == (U8) str[2]);
-		bitunpack.bitUnpack(&unpackbuffer[0], 8);
-		ensure("bitPack: individual unpack: 3", unpackbuffer[0] == (U8) str[3]);
-		bitunpack.bitUnpack(&unpackbuffer[0], 8);
-		ensure("bitPack: individual unpack: 4", unpackbuffer[0] == (U8) str[4]);
-		bitunpack.bitUnpack(&unpackbuffer[0], 8);
-		ensure("bitPack: individual unpack: 5", unpackbuffer[0] == (U8) str[5]);
-		bitunpack.bitUnpack(unpackbuffer, 8*4); // Life
-		ensure_memory_matches("bitPack: 4 bytes unpack:", unpackbuffer, 4, str+6, 4);
-	}
-
-	// U32 packing
-	template<> template<>
-	void bit_pack_object_t::test<3>()
-	{
-		U8 packbuffer[255];
-		int pack_bufsize = 0;
-
-		LLBitPack bitpack(packbuffer, 255);
-		U32 num = 0x41fab67a;
-		pack_bufsize = bitpack.bitPack((U8*)&num, 8*sizeof(U32));
-		pack_bufsize = bitpack.flushBitPack();
-
-		LLBitPack bitunpack(packbuffer, pack_bufsize*8);
-		U32 res = 0;
-		// since packing and unpacking is done on same machine in the unit test run, 
-		// endianness should not matter
-		bitunpack.bitUnpack((U8*) &res, sizeof(res)*8);
-		ensure("U32->bitPack->bitUnpack->U32 should be equal", num == res); 
-	}
+    struct bit_pack
+    {
+    };
+    typedef test_group<bit_pack> bit_pack_t;
+    typedef bit_pack_t::object bit_pack_object_t;
+    tut::bit_pack_t tut_bit_pack("LLBitPack");
+
+    // pack -> unpack
+    template<> template<>
+    void bit_pack_object_t::test<1>()
+    {
+        U8 packbuffer[255];
+        U8 unpackbuffer[255];
+        int pack_bufsize = 0;
+        int unpack_bufsize = 0;
+
+        LLBitPack bitpack(packbuffer, 255);
+
+        char str[] = "SecondLife is a 3D virtual world";
+        int len = sizeof(str);
+        pack_bufsize = bitpack.bitPack((U8*) str, len*8);
+        pack_bufsize = bitpack.flushBitPack();
+
+        LLBitPack bitunpack(packbuffer, pack_bufsize*8);
+        unpack_bufsize = bitunpack.bitUnpack(unpackbuffer, len*8);
+        ensure("bitPack: unpack size should be same as string size prior to pack", len == unpack_bufsize);
+        ensure_memory_matches("str->bitPack->bitUnpack should be equal to string", str, len, unpackbuffer, unpack_bufsize);
+    }
+
+    // pack large, unpack in individual bytes
+    template<> template<>
+    void bit_pack_object_t::test<2>()
+    {
+        U8 packbuffer[255];
+        U8 unpackbuffer[255];
+        int pack_bufsize = 0;
+
+        LLBitPack bitpack(packbuffer, 255);
+
+        char str[] = "SecondLife";
+        int len = sizeof(str);
+        pack_bufsize = bitpack.bitPack((U8*) str, len*8);
+        pack_bufsize = bitpack.flushBitPack();
+
+        LLBitPack bitunpack(packbuffer, pack_bufsize*8);
+        bitunpack.bitUnpack(&unpackbuffer[0], 8);
+        ensure("bitPack: individual unpack: 0", unpackbuffer[0] == (U8) str[0]);
+        bitunpack.bitUnpack(&unpackbuffer[0], 8);
+        ensure("bitPack: individual unpack: 1", unpackbuffer[0] == (U8) str[1]);
+        bitunpack.bitUnpack(&unpackbuffer[0], 8);
+        ensure("bitPack: individual unpack: 2", unpackbuffer[0] == (U8) str[2]);
+        bitunpack.bitUnpack(&unpackbuffer[0], 8);
+        ensure("bitPack: individual unpack: 3", unpackbuffer[0] == (U8) str[3]);
+        bitunpack.bitUnpack(&unpackbuffer[0], 8);
+        ensure("bitPack: individual unpack: 4", unpackbuffer[0] == (U8) str[4]);
+        bitunpack.bitUnpack(&unpackbuffer[0], 8);
+        ensure("bitPack: individual unpack: 5", unpackbuffer[0] == (U8) str[5]);
+        bitunpack.bitUnpack(unpackbuffer, 8*4); // Life
+        ensure_memory_matches("bitPack: 4 bytes unpack:", unpackbuffer, 4, str+6, 4);
+    }
+
+    // U32 packing
+    template<> template<>
+    void bit_pack_object_t::test<3>()
+    {
+        U8 packbuffer[255];
+        int pack_bufsize = 0;
+
+        LLBitPack bitpack(packbuffer, 255);
+        U32 num = 0x41fab67a;
+        pack_bufsize = bitpack.bitPack((U8*)&num, 8*sizeof(U32));
+        pack_bufsize = bitpack.flushBitPack();
+
+        LLBitPack bitunpack(packbuffer, pack_bufsize*8);
+        U32 res = 0;
+        // since packing and unpacking is done on same machine in the unit test run,
+        // endianness should not matter
+        bitunpack.bitUnpack((U8*) &res, sizeof(res)*8);
+        ensure("U32->bitPack->bitUnpack->U32 should be equal", num == res);
+    }
 }
diff --git a/indra/llcommon/tests/classic_callback_test.cpp b/indra/llcommon/tests/classic_callback_test.cpp
index c060775c24..fe79179ce6 100644
--- a/indra/llcommon/tests/classic_callback_test.cpp
+++ b/indra/llcommon/tests/classic_callback_test.cpp
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2021-09-22
  * @brief  Test ClassicCallback and HeapClassicCallback.
- * 
+ *
  * $LicenseInfo:firstyear=2021&license=viewerlgpl$
  * Copyright (c) 2021, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/llcommon/tests/commonmisc_test.cpp b/indra/llcommon/tests/commonmisc_test.cpp
index 4b3e07fa75..3deb864c0c 100644
--- a/indra/llcommon/tests/commonmisc_test.cpp
+++ b/indra/llcommon/tests/commonmisc_test.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file common.cpp
  * @author Phoenix
  * @date 2005-10-12
@@ -7,27 +7,27 @@
  * $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$
  */
 
-/** 
- * 
+/**
+ *
  * THOROUGH_DESCRIPTION of common.cpp
  *
  */
@@ -54,388 +54,388 @@
 
 namespace tut
 {
-	struct sd_data
-	{
-	};
-	typedef test_group<sd_data> sd_test;
-	typedef sd_test::object sd_object;
-	tut::sd_test sd("LLSD");
-
-	template<> template<>
-	void sd_object::test<1>()
-	{
-		std::ostringstream resp;
-		resp << "{'connect':true,  'position':[r128,r128,r128], 'look_at':[r0,r1,r0], 'agent_access':'M', 'region_x':i8192, 'region_y':i8192}";
-		std::string str = resp.str();
-		LLMemoryStream mstr((U8*)str.c_str(), str.size());
-		LLSD response;
-		S32 count = LLSDSerialize::fromNotation(response, mstr, str.size());
-		ensure("stream parsed", response.isDefined());
-		ensure_equals("stream parse count", count, 13);
-		ensure_equals("sd type", response.type(), LLSD::TypeMap);
-		ensure_equals("map element count", response.size(), 6);
-		ensure_equals("value connect", response["connect"].asBoolean(), true);
-		ensure_equals("value region_x", response["region_x"].asInteger(),8192);
-		ensure_equals("value region_y", response["region_y"].asInteger(),8192);
-	}
-
-	template<> template<>
-	void sd_object::test<2>()
-	{
-		const std::string decoded("random");
-		//const std::string encoded("cmFuZG9t\n");
-		const std::string streamed("b(6)\"random\"");
-		typedef std::vector<U8> buf_t;
-		buf_t buf;
-		std::copy(
-			decoded.begin(),
-			decoded.end(),
-			std::back_insert_iterator<buf_t>(buf));
-		LLSD sd;
-		sd = buf;
-		std::stringstream str;
-		S32 count = LLSDSerialize::toNotation(sd, str);
-		ensure_equals("output count", count, 1);
-		std::string actual(str.str());
-		ensure_equals("formatted binary encoding", actual, streamed);
-		sd.clear();
-		LLSDSerialize::fromNotation(sd, str, str.str().size());
-		std::vector<U8> after;
-		after = sd.asBinary();
-		ensure_equals("binary decoded size", after.size(), decoded.size());
-		ensure("binary decoding", (0 == memcmp(
-									   &after[0],
-									   decoded.c_str(),
-									   decoded.size())));
-	}
-
-	template<> template<>
-	void sd_object::test<3>()
-	{
-		for(S32 i = 0; i < 100; ++i)
-		{
-			// gen up a starting point
-			typedef std::vector<U8> buf_t;
-			buf_t source;
-			srand(i);		/* Flawfinder: ignore */
-			S32 size = rand() % 1000 + 10;
-			std::generate_n(
-				std::back_insert_iterator<buf_t>(source),
-				size,
-				rand);
-			LLSD sd(source);
-			std::stringstream str;
-			S32 count = LLSDSerialize::toNotation(sd, str);
-			sd.clear();
-			ensure_equals("format count", count, 1);
-			LLSD sd2;
-			count = LLSDSerialize::fromNotation(sd2, str, str.str().size());
-			ensure_equals("parse count", count, 1);
-			buf_t dest = sd2.asBinary();
-			str.str("");
-			str << "binary encoding size " << i;
-			ensure_equals(str.str().c_str(), dest.size(), source.size());
-			str.str("");
-			str << "binary encoding " << i;
-			ensure(str.str().c_str(), (source == dest));
-		}
-	}
-
-	template<> template<>
-	void sd_object::test<4>()
-	{
-		std::ostringstream ostr;
-		ostr << "{'task_id':u1fd77b79-a8e7-25a5-9454-02a4d948ba1c}\n"
-			 << "{\n\tname\tObject|\n}\n";
-		std::string expected = ostr.str();
-		std::stringstream serialized;
-		serialized << "'" << LLSDNotationFormatter::escapeString(expected)
-			   << "'";
-		LLSD sd;
-		S32 count = LLSDSerialize::fromNotation(
-			sd,
-			serialized,
-			serialized.str().size());
-		ensure_equals("parse count", count, 1);
-		ensure_equals("String streaming", sd.asString(), expected);
-	}
-
-	template<> template<>
-	void sd_object::test<5>()
-	{
-		for(S32 i = 0; i < 100; ++i)
-		{
-			// gen up a starting point
-			typedef std::vector<U8> buf_t;
-			buf_t source;
-			srand(666 + i);		/* Flawfinder: ignore */
-			S32 size = rand() % 1000 + 10;
-			std::generate_n(
-				std::back_insert_iterator<buf_t>(source),
-				size,
-				rand);
-			std::stringstream str;
-			str << "b(" << size << ")\"";
-			str.write((const char*)&source[0], size);
-			str << "\"";
-			LLSD sd;
-			S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
-			ensure_equals("binary parse", count, 1);
-			buf_t actual = sd.asBinary();
-			ensure_equals("binary size", actual.size(), (size_t)size);
-			ensure("binary data", (0 == memcmp(&source[0], &actual[0], size)));
-		}
-	}
-
-	template<> template<>
-	void sd_object::test<6>()
-	{
-		std::string expected("'{\"task_id\":u1fd77b79-a8e7-25a5-9454-02a4d948ba1c}'\t\n\t\t");
-		std::stringstream str;
-		str << "s(" << expected.size() << ")'";
-		str.write(expected.c_str(), expected.size());
-		str << "'";
-		LLSD sd;
-		S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
-		ensure_equals("parse count", count, 1);
-		std::string actual = sd.asString();
-		ensure_equals("string sizes", actual.size(), expected.size());
-		ensure_equals("string content", actual, expected);
-	}
-
-	template<> template<>
-	void sd_object::test<7>()
-	{
-		std::string msg("come on in");
-		std::stringstream stream;
-		stream << "{'connect':1, 'message':'" << msg << "',"
-			   << " 'position':[r45.65,r100.1,r25.5],"
-			   << " 'look_at':[r0,r1,r0],"
-			   << " 'agent_access':'PG'}";
-		LLSD sd;
-		S32 count = LLSDSerialize::fromNotation(
-			sd,
-			stream,
-			stream.str().size());
-		ensure_equals("parse count", count, 12);
-		ensure_equals("bool value", sd["connect"].asBoolean(), true);
-		ensure_equals("message value", sd["message"].asString(), msg);
-		ensure_equals("pos x", sd["position"][0].asReal(), 45.65);
-		ensure_equals("pos y", sd["position"][1].asReal(), 100.1);
-		ensure_equals("pos z", sd["position"][2].asReal(), 25.5);
-		ensure_equals("look x", sd["look_at"][0].asReal(), 0.0);
-		ensure_equals("look y", sd["look_at"][1].asReal(), 1.0);
-		ensure_equals("look z", sd["look_at"][2].asReal(), 0.0);
-	}
-
-	template<> template<>
-	void sd_object::test<8>()
-	{
-		std::stringstream resp;
-		resp << "{'label':'short string test', 'singlechar':'a', 'empty':'', 'endoftest':'end' }";
-		LLSD response;
-		S32 count = LLSDSerialize::fromNotation(
-			response,
-			resp,
-			resp.str().size());
-		ensure_equals("parse count", count, 5);
-		ensure_equals("sd type", response.type(), LLSD::TypeMap);
-		ensure_equals("map element count", response.size(), 4);
-		ensure_equals("singlechar", response["singlechar"].asString(), "a");
-		ensure_equals("empty", response["empty"].asString(), "");
-	}
-
-	template<> template<>
-	void sd_object::test<9>()
-	{
-		std::ostringstream resp;
-		resp << "{'label':'short binary test', 'singlebinary':b(1)\"A\", 'singlerawstring':s(1)\"A\", 'endoftest':'end' }";
-		std::string str = resp.str();
-		LLSD sd;
-		LLMemoryStream mstr((U8*)str.c_str(), str.size());
-		S32 count = LLSDSerialize::fromNotation(sd, mstr, str.size());
-		ensure_equals("parse count", count, 5);
-		ensure("sd created", sd.isDefined());
-		ensure_equals("sd type", sd.type(), LLSD::TypeMap);
-		ensure_equals("map element count", sd.size(), 4);
-		ensure_equals(
-			"label",
-			sd["label"].asString(),
-			"short binary test");
-		std::vector<U8> bin =  sd["singlebinary"].asBinary();
-		std::vector<U8> expected;
-		expected.resize(1);
-		expected[0] = 'A';
-		ensure("single binary", (0 == memcmp(&bin[0], &expected[0], 1)));
-		ensure_equals(
-			"single string",
-			sd["singlerawstring"].asString(),
-			std::string("A"));
-		ensure_equals("end", sd["endoftest"].asString(), "end");
-	}
-
-	template<> template<>
-	void sd_object::test<10>()
-	{
-
-		std::string message("parcel '' is naughty.");
-		std::stringstream str;
-		str << "{'message':'" << LLSDNotationFormatter::escapeString(message)
-			<< "'}";
-		std::string expected_str("{'message':'parcel \\'\\' is naughty.'}");
-		std::string actual_str = str.str();
-		ensure_equals("stream contents", actual_str, expected_str);
-		LLSD sd;
-		S32 count = LLSDSerialize::fromNotation(sd, str, actual_str.size());
-		ensure_equals("parse count", count, 2);
-		ensure("valid parse", sd.isDefined());
-		std::string actual = sd["message"].asString();
-		ensure_equals("message contents", actual, message);
-	}
-
-	template<> template<>
-	void sd_object::test<11>()
-	{
-		std::string expected("\"\"\"\"''''''\"");
-		std::stringstream str;
-		str << "'" << LLSDNotationFormatter::escapeString(expected) << "'";
-		LLSD sd;
-		S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
-		ensure_equals("parse count", count, 1);
-		ensure_equals("string value", sd.asString(), expected);
-	}
-
-	template<> template<>
-	void sd_object::test<12>()
-	{
-		std::string expected("mytest\\");
-		std::stringstream str;
-		str << "'" << LLSDNotationFormatter::escapeString(expected) << "'";
-		LLSD sd;
-		S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
-		ensure_equals("parse count", count, 1);
-		ensure_equals("string value", sd.asString(), expected);
-	}
-
-	template<> template<>
-	void sd_object::test<13>()
-	{
-		for(S32 i = 0; i < 1000; ++i)
-		{
-			// gen up a starting point
-			std::string expected;
-			srand(1337 + i);		/* Flawfinder: ignore */
-			S32 size = rand() % 30 + 5;
-			std::generate_n(
-				std::back_insert_iterator<std::string>(expected),
-				size,
-				rand);
-			std::stringstream str;
-			str << "'" << LLSDNotationFormatter::escapeString(expected) << "'";
-			LLSD sd;
-			S32 count = LLSDSerialize::fromNotation(sd, str, expected.size());
-			ensure_equals("parse count", count, 1);
-			std::string actual = sd.asString();
+    struct sd_data
+    {
+    };
+    typedef test_group<sd_data> sd_test;
+    typedef sd_test::object sd_object;
+    tut::sd_test sd("LLSD");
+
+    template<> template<>
+    void sd_object::test<1>()
+    {
+        std::ostringstream resp;
+        resp << "{'connect':true,  'position':[r128,r128,r128], 'look_at':[r0,r1,r0], 'agent_access':'M', 'region_x':i8192, 'region_y':i8192}";
+        std::string str = resp.str();
+        LLMemoryStream mstr((U8*)str.c_str(), str.size());
+        LLSD response;
+        S32 count = LLSDSerialize::fromNotation(response, mstr, str.size());
+        ensure("stream parsed", response.isDefined());
+        ensure_equals("stream parse count", count, 13);
+        ensure_equals("sd type", response.type(), LLSD::TypeMap);
+        ensure_equals("map element count", response.size(), 6);
+        ensure_equals("value connect", response["connect"].asBoolean(), true);
+        ensure_equals("value region_x", response["region_x"].asInteger(),8192);
+        ensure_equals("value region_y", response["region_y"].asInteger(),8192);
+    }
+
+    template<> template<>
+    void sd_object::test<2>()
+    {
+        const std::string decoded("random");
+        //const std::string encoded("cmFuZG9t\n");
+        const std::string streamed("b(6)\"random\"");
+        typedef std::vector<U8> buf_t;
+        buf_t buf;
+        std::copy(
+            decoded.begin(),
+            decoded.end(),
+            std::back_insert_iterator<buf_t>(buf));
+        LLSD sd;
+        sd = buf;
+        std::stringstream str;
+        S32 count = LLSDSerialize::toNotation(sd, str);
+        ensure_equals("output count", count, 1);
+        std::string actual(str.str());
+        ensure_equals("formatted binary encoding", actual, streamed);
+        sd.clear();
+        LLSDSerialize::fromNotation(sd, str, str.str().size());
+        std::vector<U8> after;
+        after = sd.asBinary();
+        ensure_equals("binary decoded size", after.size(), decoded.size());
+        ensure("binary decoding", (0 == memcmp(
+                                       &after[0],
+                                       decoded.c_str(),
+                                       decoded.size())));
+    }
+
+    template<> template<>
+    void sd_object::test<3>()
+    {
+        for(S32 i = 0; i < 100; ++i)
+        {
+            // gen up a starting point
+            typedef std::vector<U8> buf_t;
+            buf_t source;
+            srand(i);       /* Flawfinder: ignore */
+            S32 size = rand() % 1000 + 10;
+            std::generate_n(
+                std::back_insert_iterator<buf_t>(source),
+                size,
+                rand);
+            LLSD sd(source);
+            std::stringstream str;
+            S32 count = LLSDSerialize::toNotation(sd, str);
+            sd.clear();
+            ensure_equals("format count", count, 1);
+            LLSD sd2;
+            count = LLSDSerialize::fromNotation(sd2, str, str.str().size());
+            ensure_equals("parse count", count, 1);
+            buf_t dest = sd2.asBinary();
+            str.str("");
+            str << "binary encoding size " << i;
+            ensure_equals(str.str().c_str(), dest.size(), source.size());
+            str.str("");
+            str << "binary encoding " << i;
+            ensure(str.str().c_str(), (source == dest));
+        }
+    }
+
+    template<> template<>
+    void sd_object::test<4>()
+    {
+        std::ostringstream ostr;
+        ostr << "{'task_id':u1fd77b79-a8e7-25a5-9454-02a4d948ba1c}\n"
+             << "{\n\tname\tObject|\n}\n";
+        std::string expected = ostr.str();
+        std::stringstream serialized;
+        serialized << "'" << LLSDNotationFormatter::escapeString(expected)
+               << "'";
+        LLSD sd;
+        S32 count = LLSDSerialize::fromNotation(
+            sd,
+            serialized,
+            serialized.str().size());
+        ensure_equals("parse count", count, 1);
+        ensure_equals("String streaming", sd.asString(), expected);
+    }
+
+    template<> template<>
+    void sd_object::test<5>()
+    {
+        for(S32 i = 0; i < 100; ++i)
+        {
+            // gen up a starting point
+            typedef std::vector<U8> buf_t;
+            buf_t source;
+            srand(666 + i);     /* Flawfinder: ignore */
+            S32 size = rand() % 1000 + 10;
+            std::generate_n(
+                std::back_insert_iterator<buf_t>(source),
+                size,
+                rand);
+            std::stringstream str;
+            str << "b(" << size << ")\"";
+            str.write((const char*)&source[0], size);
+            str << "\"";
+            LLSD sd;
+            S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
+            ensure_equals("binary parse", count, 1);
+            buf_t actual = sd.asBinary();
+            ensure_equals("binary size", actual.size(), (size_t)size);
+            ensure("binary data", (0 == memcmp(&source[0], &actual[0], size)));
+        }
+    }
+
+    template<> template<>
+    void sd_object::test<6>()
+    {
+        std::string expected("'{\"task_id\":u1fd77b79-a8e7-25a5-9454-02a4d948ba1c}'\t\n\t\t");
+        std::stringstream str;
+        str << "s(" << expected.size() << ")'";
+        str.write(expected.c_str(), expected.size());
+        str << "'";
+        LLSD sd;
+        S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
+        ensure_equals("parse count", count, 1);
+        std::string actual = sd.asString();
+        ensure_equals("string sizes", actual.size(), expected.size());
+        ensure_equals("string content", actual, expected);
+    }
+
+    template<> template<>
+    void sd_object::test<7>()
+    {
+        std::string msg("come on in");
+        std::stringstream stream;
+        stream << "{'connect':1, 'message':'" << msg << "',"
+               << " 'position':[r45.65,r100.1,r25.5],"
+               << " 'look_at':[r0,r1,r0],"
+               << " 'agent_access':'PG'}";
+        LLSD sd;
+        S32 count = LLSDSerialize::fromNotation(
+            sd,
+            stream,
+            stream.str().size());
+        ensure_equals("parse count", count, 12);
+        ensure_equals("bool value", sd["connect"].asBoolean(), true);
+        ensure_equals("message value", sd["message"].asString(), msg);
+        ensure_equals("pos x", sd["position"][0].asReal(), 45.65);
+        ensure_equals("pos y", sd["position"][1].asReal(), 100.1);
+        ensure_equals("pos z", sd["position"][2].asReal(), 25.5);
+        ensure_equals("look x", sd["look_at"][0].asReal(), 0.0);
+        ensure_equals("look y", sd["look_at"][1].asReal(), 1.0);
+        ensure_equals("look z", sd["look_at"][2].asReal(), 0.0);
+    }
+
+    template<> template<>
+    void sd_object::test<8>()
+    {
+        std::stringstream resp;
+        resp << "{'label':'short string test', 'singlechar':'a', 'empty':'', 'endoftest':'end' }";
+        LLSD response;
+        S32 count = LLSDSerialize::fromNotation(
+            response,
+            resp,
+            resp.str().size());
+        ensure_equals("parse count", count, 5);
+        ensure_equals("sd type", response.type(), LLSD::TypeMap);
+        ensure_equals("map element count", response.size(), 4);
+        ensure_equals("singlechar", response["singlechar"].asString(), "a");
+        ensure_equals("empty", response["empty"].asString(), "");
+    }
+
+    template<> template<>
+    void sd_object::test<9>()
+    {
+        std::ostringstream resp;
+        resp << "{'label':'short binary test', 'singlebinary':b(1)\"A\", 'singlerawstring':s(1)\"A\", 'endoftest':'end' }";
+        std::string str = resp.str();
+        LLSD sd;
+        LLMemoryStream mstr((U8*)str.c_str(), str.size());
+        S32 count = LLSDSerialize::fromNotation(sd, mstr, str.size());
+        ensure_equals("parse count", count, 5);
+        ensure("sd created", sd.isDefined());
+        ensure_equals("sd type", sd.type(), LLSD::TypeMap);
+        ensure_equals("map element count", sd.size(), 4);
+        ensure_equals(
+            "label",
+            sd["label"].asString(),
+            "short binary test");
+        std::vector<U8> bin =  sd["singlebinary"].asBinary();
+        std::vector<U8> expected;
+        expected.resize(1);
+        expected[0] = 'A';
+        ensure("single binary", (0 == memcmp(&bin[0], &expected[0], 1)));
+        ensure_equals(
+            "single string",
+            sd["singlerawstring"].asString(),
+            std::string("A"));
+        ensure_equals("end", sd["endoftest"].asString(), "end");
+    }
+
+    template<> template<>
+    void sd_object::test<10>()
+    {
+
+        std::string message("parcel '' is naughty.");
+        std::stringstream str;
+        str << "{'message':'" << LLSDNotationFormatter::escapeString(message)
+            << "'}";
+        std::string expected_str("{'message':'parcel \\'\\' is naughty.'}");
+        std::string actual_str = str.str();
+        ensure_equals("stream contents", actual_str, expected_str);
+        LLSD sd;
+        S32 count = LLSDSerialize::fromNotation(sd, str, actual_str.size());
+        ensure_equals("parse count", count, 2);
+        ensure("valid parse", sd.isDefined());
+        std::string actual = sd["message"].asString();
+        ensure_equals("message contents", actual, message);
+    }
+
+    template<> template<>
+    void sd_object::test<11>()
+    {
+        std::string expected("\"\"\"\"''''''\"");
+        std::stringstream str;
+        str << "'" << LLSDNotationFormatter::escapeString(expected) << "'";
+        LLSD sd;
+        S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
+        ensure_equals("parse count", count, 1);
+        ensure_equals("string value", sd.asString(), expected);
+    }
+
+    template<> template<>
+    void sd_object::test<12>()
+    {
+        std::string expected("mytest\\");
+        std::stringstream str;
+        str << "'" << LLSDNotationFormatter::escapeString(expected) << "'";
+        LLSD sd;
+        S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
+        ensure_equals("parse count", count, 1);
+        ensure_equals("string value", sd.asString(), expected);
+    }
+
+    template<> template<>
+    void sd_object::test<13>()
+    {
+        for(S32 i = 0; i < 1000; ++i)
+        {
+            // gen up a starting point
+            std::string expected;
+            srand(1337 + i);        /* Flawfinder: ignore */
+            S32 size = rand() % 30 + 5;
+            std::generate_n(
+                std::back_insert_iterator<std::string>(expected),
+                size,
+                rand);
+            std::stringstream str;
+            str << "'" << LLSDNotationFormatter::escapeString(expected) << "'";
+            LLSD sd;
+            S32 count = LLSDSerialize::fromNotation(sd, str, expected.size());
+            ensure_equals("parse count", count, 1);
+            std::string actual = sd.asString();
 /*
-			if(actual != expected)
-			{
-				LL_WARNS() << "iteration " << i << LL_ENDL;
-				std::ostringstream e_str;
-				std::string::iterator iter = expected.begin();
-				std::string::iterator end = expected.end();
-				for(; iter != end; ++iter)
-				{
-					e_str << (S32)((U8)(*iter)) << " ";
-				}
-				e_str << std::endl;
-				llsd_serialize_string(e_str, expected);
-				LL_WARNS() << "expected size: " << expected.size() << LL_ENDL;
-				LL_WARNS() << "expected:      " << e_str.str() << LL_ENDL;
-
-				std::ostringstream a_str;
-				iter = actual.begin();
-				end = actual.end();
-				for(; iter != end; ++iter)
-				{
-					a_str << (S32)((U8)(*iter)) << " ";
-				}
-				a_str << std::endl;
-				llsd_serialize_string(a_str, actual);
-				LL_WARNS() << "actual size:   " << actual.size() << LL_ENDL;
-				LL_WARNS() << "actual:      " << a_str.str() << LL_ENDL;
-			}
+            if(actual != expected)
+            {
+                LL_WARNS() << "iteration " << i << LL_ENDL;
+                std::ostringstream e_str;
+                std::string::iterator iter = expected.begin();
+                std::string::iterator end = expected.end();
+                for(; iter != end; ++iter)
+                {
+                    e_str << (S32)((U8)(*iter)) << " ";
+                }
+                e_str << std::endl;
+                llsd_serialize_string(e_str, expected);
+                LL_WARNS() << "expected size: " << expected.size() << LL_ENDL;
+                LL_WARNS() << "expected:      " << e_str.str() << LL_ENDL;
+
+                std::ostringstream a_str;
+                iter = actual.begin();
+                end = actual.end();
+                for(; iter != end; ++iter)
+                {
+                    a_str << (S32)((U8)(*iter)) << " ";
+                }
+                a_str << std::endl;
+                llsd_serialize_string(a_str, actual);
+                LL_WARNS() << "actual size:   " << actual.size() << LL_ENDL;
+                LL_WARNS() << "actual:      " << a_str.str() << LL_ENDL;
+            }
 */
-			ensure_equals("string value", actual, expected);
-		}
-	}
+            ensure_equals("string value", actual, expected);
+        }
+    }
 
-	template<> template<>
-	void sd_object::test<14>()
-	{
+    template<> template<>
+    void sd_object::test<14>()
+    {
 //#if LL_WINDOWS && _MSC_VER >= 1400
 //        skip_fail("Fails on VS2005 due to broken LLSDSerialize::fromNotation() parser.");
 //#endif
-		std::string param = "[{'version':i1},{'data':{'binary_bucket':b(0)\"\"},'from_id':u3c115e51-04f4-523c-9fa6-98aff1034730,'from_name':'Phoenix Linden','id':u004e45e5-5576-277a-fba7-859d6a4cb5c8,'message':'hey','offline':i0,'timestamp':i0,'to_id':u3c5f1bb4-5182-7546-6401-1d329b4ff2f8,'type':i0},{'agent_id':u3c115e51-04f4-523c-9fa6-98aff1034730,'god_level':i0,'limited_to_estate':i1}]";
-		std::istringstream istr;
-		istr.str(param);
-		LLSD param_sd;
-		LLSDSerialize::fromNotation(param_sd, istr, param.size());
-		ensure_equals("parsed type", param_sd.type(), LLSD::TypeArray);
-		LLSD version_sd = param_sd[0];
-		ensure_equals("version type", version_sd.type(), LLSD::TypeMap);
-		ensure("has version", version_sd.has("version"));
-		ensure_equals("version number", version_sd["version"].asInteger(), 1);
-		LLSD src_sd = param_sd[1];
-		ensure_equals("src type", src_sd.type(), LLSD::TypeMap);
-		LLSD dst_sd = param_sd[2];
-		ensure_equals("dst type", dst_sd.type(), LLSD::TypeMap);
-	}
-
-	template<> template<>
-	void sd_object::test<15>()
-	{
-		std::string val = "[{'failures':!,'successfuls':[u3c115e51-04f4-523c-9fa6-98aff1034730]}]";
-		std::istringstream istr;
-		istr.str(val);
-		LLSD sd;
-		LLSDSerialize::fromNotation(sd, istr, val.size());
-		ensure_equals("parsed type", sd.type(), LLSD::TypeArray);
-		ensure_equals("parsed size", sd.size(), 1);
-		LLSD failures = sd[0]["failures"];
-		ensure("no failures.", failures.isUndefined());
-		LLSD success = sd[0]["successfuls"];
-		ensure_equals("success type", success.type(), LLSD::TypeArray);
-		ensure_equals("success size", success.size(), 1);
-		ensure_equals("success instance type", success[0].type(), LLSD::TypeUUID);
-	}
-
-	template<> template<>
-	void sd_object::test<16>()
-	{
-		std::string val = "[f,t,0,1,{'foo':t,'bar':f}]";
-		std::istringstream istr;
-		istr.str(val);
-		LLSD sd;
-		LLSDSerialize::fromNotation(sd, istr, val.size());
-		ensure_equals("parsed type", sd.type(), LLSD::TypeArray);
-		ensure_equals("parsed size", sd.size(), 5);
-		ensure_equals("element 0 false", sd[0].asBoolean(), false);
-		ensure_equals("element 1 true", sd[1].asBoolean(), true);
-		ensure_equals("element 2 false", sd[2].asBoolean(), false);
-		ensure_equals("element 3 true", sd[3].asBoolean(), true);
-		LLSD map = sd[4];
-		ensure_equals("element 4 type", map.type(), LLSD::TypeMap);
-		ensure_equals("map foo type", map["foo"].type(), LLSD::TypeBoolean);
-		ensure_equals("map foo value", map["foo"].asBoolean(), true);
-		ensure_equals("map bar type", map["bar"].type(), LLSD::TypeBoolean);
-		ensure_equals("map bar value", map["bar"].asBoolean(), false);
-	}
+        std::string param = "[{'version':i1},{'data':{'binary_bucket':b(0)\"\"},'from_id':u3c115e51-04f4-523c-9fa6-98aff1034730,'from_name':'Phoenix Linden','id':u004e45e5-5576-277a-fba7-859d6a4cb5c8,'message':'hey','offline':i0,'timestamp':i0,'to_id':u3c5f1bb4-5182-7546-6401-1d329b4ff2f8,'type':i0},{'agent_id':u3c115e51-04f4-523c-9fa6-98aff1034730,'god_level':i0,'limited_to_estate':i1}]";
+        std::istringstream istr;
+        istr.str(param);
+        LLSD param_sd;
+        LLSDSerialize::fromNotation(param_sd, istr, param.size());
+        ensure_equals("parsed type", param_sd.type(), LLSD::TypeArray);
+        LLSD version_sd = param_sd[0];
+        ensure_equals("version type", version_sd.type(), LLSD::TypeMap);
+        ensure("has version", version_sd.has("version"));
+        ensure_equals("version number", version_sd["version"].asInteger(), 1);
+        LLSD src_sd = param_sd[1];
+        ensure_equals("src type", src_sd.type(), LLSD::TypeMap);
+        LLSD dst_sd = param_sd[2];
+        ensure_equals("dst type", dst_sd.type(), LLSD::TypeMap);
+    }
+
+    template<> template<>
+    void sd_object::test<15>()
+    {
+        std::string val = "[{'failures':!,'successfuls':[u3c115e51-04f4-523c-9fa6-98aff1034730]}]";
+        std::istringstream istr;
+        istr.str(val);
+        LLSD sd;
+        LLSDSerialize::fromNotation(sd, istr, val.size());
+        ensure_equals("parsed type", sd.type(), LLSD::TypeArray);
+        ensure_equals("parsed size", sd.size(), 1);
+        LLSD failures = sd[0]["failures"];
+        ensure("no failures.", failures.isUndefined());
+        LLSD success = sd[0]["successfuls"];
+        ensure_equals("success type", success.type(), LLSD::TypeArray);
+        ensure_equals("success size", success.size(), 1);
+        ensure_equals("success instance type", success[0].type(), LLSD::TypeUUID);
+    }
+
+    template<> template<>
+    void sd_object::test<16>()
+    {
+        std::string val = "[f,t,0,1,{'foo':t,'bar':f}]";
+        std::istringstream istr;
+        istr.str(val);
+        LLSD sd;
+        LLSDSerialize::fromNotation(sd, istr, val.size());
+        ensure_equals("parsed type", sd.type(), LLSD::TypeArray);
+        ensure_equals("parsed size", sd.size(), 5);
+        ensure_equals("element 0 false", sd[0].asBoolean(), false);
+        ensure_equals("element 1 true", sd[1].asBoolean(), true);
+        ensure_equals("element 2 false", sd[2].asBoolean(), false);
+        ensure_equals("element 3 true", sd[3].asBoolean(), true);
+        LLSD map = sd[4];
+        ensure_equals("element 4 type", map.type(), LLSD::TypeMap);
+        ensure_equals("map foo type", map["foo"].type(), LLSD::TypeBoolean);
+        ensure_equals("map foo value", map["foo"].asBoolean(), true);
+        ensure_equals("map bar type", map["bar"].type(), LLSD::TypeBoolean);
+        ensure_equals("map bar value", map["bar"].asBoolean(), false);
+    }
 
 /*
-	template<> template<>
-	void sd_object::test<16>()
-	{
-	}
+    template<> template<>
+    void sd_object::test<16>()
+    {
+    }
 */
 }
 
@@ -445,227 +445,227 @@ namespace tut
 
 namespace tut
 {
-	struct mem_data
-	{
-	};
-	typedef test_group<mem_data> mem_test;
-	typedef mem_test::object mem_object;
-	tut::mem_test mem_stream("LLMemoryStream");
-
-	template<> template<>
-	void mem_object::test<1>()
-	{
-		const char HELLO_WORLD[] = "hello world";
-		LLMemoryStream mem((U8*)&HELLO_WORLD[0], strlen(HELLO_WORLD));		/* Flawfinder: ignore */
-		std::string hello;
-		std::string world;
-		mem >> hello >> world;
-		ensure_equals("first word", hello, std::string("hello"));
-		ensure_equals("second word", world, std::string("world"));
-	}
+    struct mem_data
+    {
+    };
+    typedef test_group<mem_data> mem_test;
+    typedef mem_test::object mem_object;
+    tut::mem_test mem_stream("LLMemoryStream");
+
+    template<> template<>
+    void mem_object::test<1>()
+    {
+        const char HELLO_WORLD[] = "hello world";
+        LLMemoryStream mem((U8*)&HELLO_WORLD[0], strlen(HELLO_WORLD));      /* Flawfinder: ignore */
+        std::string hello;
+        std::string world;
+        mem >> hello >> world;
+        ensure_equals("first word", hello, std::string("hello"));
+        ensure_equals("second word", world, std::string("world"));
+    }
 }
 
 namespace tut
 {
-	struct U64_data
-	{
-	};
-	typedef test_group<U64_data> U64_test;
-	typedef U64_test::object U64_object;
-	tut::U64_test U64_testcase("U64_conversion");
-
-	// U64_to_str
-	template<> template<>
-	void U64_object::test<1>()
-	{
-		U64 val;
-		std::string val_str;
-		char result[256];
-		std::string result_str;
-
-		val = U64L(18446744073709551610); // slightly less than MAX_U64
-		val_str = "18446744073709551610";
-
-		U64_to_str(val, result, sizeof(result));
-		result_str = (const char*) result;
-		ensure_equals("U64_to_str converted 1.1", val_str, result_str);
-
-		val = 0;
-		val_str = "0";
-		U64_to_str(val, result, sizeof(result));
-		result_str = (const char*) result;
-		ensure_equals("U64_to_str converted 1.2", val_str, result_str);
-
-		val = U64L(18446744073709551615); // 0xFFFFFFFFFFFFFFFF
-		val_str = "18446744073709551615";
-		U64_to_str(val, result, sizeof(result));
-		result_str = (const char*) result;
-		ensure_equals("U64_to_str converted 1.3", val_str, result_str);
-
-		// overflow - will result in warning at compile time
-		val = U64L(18446744073709551615) + 1; // overflow 0xFFFFFFFFFFFFFFFF + 1 == 0
-		val_str = "0";
-		U64_to_str(val, result, sizeof(result));
-		result_str = (const char*) result;
-		ensure_equals("U64_to_str converted 1.4", val_str, result_str);
-
-		val = U64L(-1); // 0xFFFFFFFFFFFFFFFF == 18446744073709551615
-		val_str = "18446744073709551615";
-		U64_to_str(val, result, sizeof(result));
-		result_str = (const char*) result;
-		ensure_equals("U64_to_str converted 1.5", val_str, result_str);
-
-		val = U64L(10000000000000000000); // testing preserving of 0s
-		val_str = "10000000000000000000";
-		U64_to_str(val, result, sizeof(result));
-		result_str = (const char*) result;
-		ensure_equals("U64_to_str converted 1.6", val_str, result_str);
-
-		val = 1; // testing no leading 0s
-		val_str = "1";
-		U64_to_str(val, result, sizeof(result));
-		result_str = (const char*) result;
-		ensure_equals("U64_to_str converted 1.7", val_str, result_str);
-
-		val = U64L(18446744073709551615); // testing exact sized buffer for result
-		val_str = "18446744073709551615";
-		memset(result, 'A', sizeof(result)); // initialize buffer with all 'A'
-		U64_to_str(val, result, sizeof("18446744073709551615")); //pass in the exact size
-		result_str = (const char*) result;
-		ensure_equals("U64_to_str converted 1.8", val_str, result_str);
-
-		val = U64L(18446744073709551615); // testing smaller sized buffer for result
-		val_str = "1844";
-		memset(result, 'A', sizeof(result)); // initialize buffer with all 'A'
-		U64_to_str(val, result, 5); //pass in a size of 5. should only copy first 4 integers and add a null terminator
-		result_str = (const char*) result;
-		ensure_equals("U64_to_str converted 1.9", val_str, result_str);
-	}
-
-	// str_to_U64
-	template<> template<>
-	void U64_object::test<2>()
-	{
-		U64 val;
-		U64 result;
-
-		val = U64L(18446744073709551610); // slightly less than MAX_U64
-		result = str_to_U64("18446744073709551610");
-		ensure_equals("str_to_U64 converted 2.1", val, result);
-
-		val = U64L(0); // empty string
-		result = str_to_U64(LLStringUtil::null);
-		ensure_equals("str_to_U64 converted 2.2", val, result);
-
-		val = U64L(0); // 0
-		result = str_to_U64("0");
-		ensure_equals("str_to_U64 converted 2.3", val, result);
-
-		val = U64L(18446744073709551615); // 0xFFFFFFFFFFFFFFFF
-		result = str_to_U64("18446744073709551615");
-		ensure_equals("str_to_U64 converted 2.4", val, result);
-
-		// overflow - will result in warning at compile time
-		val = U64L(18446744073709551615) + 1; // overflow 0xFFFFFFFFFFFFFFFF + 1 == 0
-		result = str_to_U64("18446744073709551616");
-		ensure_equals("str_to_U64 converted 2.5", val, result);
-
-		val = U64L(1234); // process till first non-integral character
-		result = str_to_U64("1234A5678");
-		ensure_equals("str_to_U64 converted 2.6", val, result);
-
-		val = U64L(5678); // skip all non-integral characters
-		result = str_to_U64("ABCD5678");
-		ensure_equals("str_to_U64 converted 2.7", val, result);
-
-		// should it skip negative sign and process 
-		// rest of string or return 0
-		val = U64L(1234); // skip initial negative sign 
-		result = str_to_U64("-1234");
-		ensure_equals("str_to_U64 converted 2.8", val, result);
-
-		val = U64L(5678); // stop at negative sign in the middle
-		result = str_to_U64("5678-1234");
-		ensure_equals("str_to_U64 converted 2.9", val, result);
-
-		val = U64L(0); // no integers
-		result = str_to_U64("AaCD");
-		ensure_equals("str_to_U64 converted 2.10", val, result);
-	}
-
-	// U64_to_F64
-	template<> template<>
-	void U64_object::test<3>()
-	{
-		F64 val;
-		F64 result;
-
-		result = 18446744073709551610.0;
-		val = U64_to_F64(U64L(18446744073709551610));
-		ensure_equals("U64_to_F64 converted 3.1", val, result);
-
-		result = 18446744073709551615.0; // 0xFFFFFFFFFFFFFFFF
-		val = U64_to_F64(U64L(18446744073709551615));
-		ensure_equals("U64_to_F64 converted 3.2", val, result);
-
-		result = 0.0; // overflow 0xFFFFFFFFFFFFFFFF + 1 == 0
-		// overflow - will result in warning at compile time
-		val = U64_to_F64(U64L(18446744073709551615)+1);
-		ensure_equals("U64_to_F64 converted 3.3", val, result);
-
-		result = 0.0; // 0
-		val = U64_to_F64(U64L(0));
-		ensure_equals("U64_to_F64 converted 3.4", val, result);
-
-		result = 1.0; // odd
-		val = U64_to_F64(U64L(1));
-		ensure_equals("U64_to_F64 converted 3.5", val, result);
-
-		result = 2.0; // even
-		val = U64_to_F64(U64L(2));
-		ensure_equals("U64_to_F64 converted 3.6", val, result);
-
-		result = U64L(0x7FFFFFFFFFFFFFFF) * 1.0L; // 0x7FFFFFFFFFFFFFFF
-		val = U64_to_F64(U64L(0x7FFFFFFFFFFFFFFF));
-		ensure_equals("U64_to_F64 converted 3.7", val, result);
-	}
-
-	// llstrtou64 
-	// seems to be deprecated - could not find it being used 
-	// anywhere in the tarball - skipping unit tests for now
+    struct U64_data
+    {
+    };
+    typedef test_group<U64_data> U64_test;
+    typedef U64_test::object U64_object;
+    tut::U64_test U64_testcase("U64_conversion");
+
+    // U64_to_str
+    template<> template<>
+    void U64_object::test<1>()
+    {
+        U64 val;
+        std::string val_str;
+        char result[256];
+        std::string result_str;
+
+        val = U64L(18446744073709551610); // slightly less than MAX_U64
+        val_str = "18446744073709551610";
+
+        U64_to_str(val, result, sizeof(result));
+        result_str = (const char*) result;
+        ensure_equals("U64_to_str converted 1.1", val_str, result_str);
+
+        val = 0;
+        val_str = "0";
+        U64_to_str(val, result, sizeof(result));
+        result_str = (const char*) result;
+        ensure_equals("U64_to_str converted 1.2", val_str, result_str);
+
+        val = U64L(18446744073709551615); // 0xFFFFFFFFFFFFFFFF
+        val_str = "18446744073709551615";
+        U64_to_str(val, result, sizeof(result));
+        result_str = (const char*) result;
+        ensure_equals("U64_to_str converted 1.3", val_str, result_str);
+
+        // overflow - will result in warning at compile time
+        val = U64L(18446744073709551615) + 1; // overflow 0xFFFFFFFFFFFFFFFF + 1 == 0
+        val_str = "0";
+        U64_to_str(val, result, sizeof(result));
+        result_str = (const char*) result;
+        ensure_equals("U64_to_str converted 1.4", val_str, result_str);
+
+        val = U64L(-1); // 0xFFFFFFFFFFFFFFFF == 18446744073709551615
+        val_str = "18446744073709551615";
+        U64_to_str(val, result, sizeof(result));
+        result_str = (const char*) result;
+        ensure_equals("U64_to_str converted 1.5", val_str, result_str);
+
+        val = U64L(10000000000000000000); // testing preserving of 0s
+        val_str = "10000000000000000000";
+        U64_to_str(val, result, sizeof(result));
+        result_str = (const char*) result;
+        ensure_equals("U64_to_str converted 1.6", val_str, result_str);
+
+        val = 1; // testing no leading 0s
+        val_str = "1";
+        U64_to_str(val, result, sizeof(result));
+        result_str = (const char*) result;
+        ensure_equals("U64_to_str converted 1.7", val_str, result_str);
+
+        val = U64L(18446744073709551615); // testing exact sized buffer for result
+        val_str = "18446744073709551615";
+        memset(result, 'A', sizeof(result)); // initialize buffer with all 'A'
+        U64_to_str(val, result, sizeof("18446744073709551615")); //pass in the exact size
+        result_str = (const char*) result;
+        ensure_equals("U64_to_str converted 1.8", val_str, result_str);
+
+        val = U64L(18446744073709551615); // testing smaller sized buffer for result
+        val_str = "1844";
+        memset(result, 'A', sizeof(result)); // initialize buffer with all 'A'
+        U64_to_str(val, result, 5); //pass in a size of 5. should only copy first 4 integers and add a null terminator
+        result_str = (const char*) result;
+        ensure_equals("U64_to_str converted 1.9", val_str, result_str);
+    }
+
+    // str_to_U64
+    template<> template<>
+    void U64_object::test<2>()
+    {
+        U64 val;
+        U64 result;
+
+        val = U64L(18446744073709551610); // slightly less than MAX_U64
+        result = str_to_U64("18446744073709551610");
+        ensure_equals("str_to_U64 converted 2.1", val, result);
+
+        val = U64L(0); // empty string
+        result = str_to_U64(LLStringUtil::null);
+        ensure_equals("str_to_U64 converted 2.2", val, result);
+
+        val = U64L(0); // 0
+        result = str_to_U64("0");
+        ensure_equals("str_to_U64 converted 2.3", val, result);
+
+        val = U64L(18446744073709551615); // 0xFFFFFFFFFFFFFFFF
+        result = str_to_U64("18446744073709551615");
+        ensure_equals("str_to_U64 converted 2.4", val, result);
+
+        // overflow - will result in warning at compile time
+        val = U64L(18446744073709551615) + 1; // overflow 0xFFFFFFFFFFFFFFFF + 1 == 0
+        result = str_to_U64("18446744073709551616");
+        ensure_equals("str_to_U64 converted 2.5", val, result);
+
+        val = U64L(1234); // process till first non-integral character
+        result = str_to_U64("1234A5678");
+        ensure_equals("str_to_U64 converted 2.6", val, result);
+
+        val = U64L(5678); // skip all non-integral characters
+        result = str_to_U64("ABCD5678");
+        ensure_equals("str_to_U64 converted 2.7", val, result);
+
+        // should it skip negative sign and process
+        // rest of string or return 0
+        val = U64L(1234); // skip initial negative sign
+        result = str_to_U64("-1234");
+        ensure_equals("str_to_U64 converted 2.8", val, result);
+
+        val = U64L(5678); // stop at negative sign in the middle
+        result = str_to_U64("5678-1234");
+        ensure_equals("str_to_U64 converted 2.9", val, result);
+
+        val = U64L(0); // no integers
+        result = str_to_U64("AaCD");
+        ensure_equals("str_to_U64 converted 2.10", val, result);
+    }
+
+    // U64_to_F64
+    template<> template<>
+    void U64_object::test<3>()
+    {
+        F64 val;
+        F64 result;
+
+        result = 18446744073709551610.0;
+        val = U64_to_F64(U64L(18446744073709551610));
+        ensure_equals("U64_to_F64 converted 3.1", val, result);
+
+        result = 18446744073709551615.0; // 0xFFFFFFFFFFFFFFFF
+        val = U64_to_F64(U64L(18446744073709551615));
+        ensure_equals("U64_to_F64 converted 3.2", val, result);
+
+        result = 0.0; // overflow 0xFFFFFFFFFFFFFFFF + 1 == 0
+        // overflow - will result in warning at compile time
+        val = U64_to_F64(U64L(18446744073709551615)+1);
+        ensure_equals("U64_to_F64 converted 3.3", val, result);
+
+        result = 0.0; // 0
+        val = U64_to_F64(U64L(0));
+        ensure_equals("U64_to_F64 converted 3.4", val, result);
+
+        result = 1.0; // odd
+        val = U64_to_F64(U64L(1));
+        ensure_equals("U64_to_F64 converted 3.5", val, result);
+
+        result = 2.0; // even
+        val = U64_to_F64(U64L(2));
+        ensure_equals("U64_to_F64 converted 3.6", val, result);
+
+        result = U64L(0x7FFFFFFFFFFFFFFF) * 1.0L; // 0x7FFFFFFFFFFFFFFF
+        val = U64_to_F64(U64L(0x7FFFFFFFFFFFFFFF));
+        ensure_equals("U64_to_F64 converted 3.7", val, result);
+    }
+
+    // llstrtou64
+    // seems to be deprecated - could not find it being used
+    // anywhere in the tarball - skipping unit tests for now
 }
 
 
 namespace tut
 {
-	struct hash_data
-	{
-	};
-	typedef test_group<hash_data> hash_test;
-	typedef hash_test::object hash_object;
-	tut::hash_test hash_tester("LLHash");
+    struct hash_data
+    {
+    };
+    typedef test_group<hash_data> hash_test;
+    typedef hash_test::object hash_object;
+    tut::hash_test hash_tester("LLHash");
+
+    template<> template<>
+    void hash_object::test<1>()
+    {
+        const char * str1 = "test string one";
+        const char * same_as_str1 = "test string one";
+
+        size_t hash1 = llhash(str1);
+        size_t same_as_hash1 = llhash(same_as_str1);
 
-	template<> template<>
-	void hash_object::test<1>()
-	{
-		const char * str1 = "test string one";
-		const char * same_as_str1 = "test string one";
 
-		size_t hash1 = llhash(str1);
-		size_t same_as_hash1 = llhash(same_as_str1);
+        ensure("Hashes from identical strings should be equal", hash1 == same_as_hash1);
 
+        char str[100];
+        strcpy( str, "Another test" );
 
-		ensure("Hashes from identical strings should be equal", hash1 == same_as_hash1);
-		
-		char str[100];
-		strcpy( str, "Another test" );
+        size_t hash2 = llhash(str);
 
-		size_t hash2 = llhash(str);
-		
-		strcpy( str, "Different string, same pointer" );
+        strcpy( str, "Different string, same pointer" );
 
-		size_t hash3 = llhash(str);
+        size_t hash3 = llhash(str);
 
-		ensure("Hashes from same pointer but different string should not be equal", hash2 != hash3);
-	}
+        ensure("Hashes from same pointer but different string should not be equal", hash2 != hash3);
+    }
 }
diff --git a/indra/llcommon/tests/lazyeventapi_test.cpp b/indra/llcommon/tests/lazyeventapi_test.cpp
index 31b2d6d17f..f3fcf84e49 100644
--- a/indra/llcommon/tests/lazyeventapi_test.cpp
+++ b/indra/llcommon/tests/lazyeventapi_test.cpp
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2022-06-18
  * @brief  Test for lazyeventapi.
- * 
+ *
  * $LicenseInfo:firstyear=2022&license=viewerlgpl$
  * Copyright (c) 2022, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/llcommon/tests/listener.h b/indra/llcommon/tests/listener.h
index 6072060bb6..887a2c9082 100644
--- a/indra/llcommon/tests/listener.h
+++ b/indra/llcommon/tests/listener.h
@@ -3,25 +3,25 @@
  * @author Nat Goodspeed
  * @date   2009-03-06
  * @brief  Useful for tests of the LLEventPump family of classes
- * 
+ *
  * $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/llcommon/tests/llallocator_heap_profile_test.cpp b/indra/llcommon/tests/llallocator_heap_profile_test.cpp
index 44a9705803..da8b54ffc0 100644
--- a/indra/llcommon/tests/llallocator_heap_profile_test.cpp
+++ b/indra/llcommon/tests/llallocator_heap_profile_test.cpp
@@ -3,25 +3,25 @@
  * @author Brad Kittenbrink
  * @date   2008-02-
  * @brief  Test for llallocator_heap_profile.cpp.
- * 
+ *
  * $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/llcommon/tests/llallocator_test.cpp b/indra/llcommon/tests/llallocator_test.cpp
index 4e62eaee67..a7573641c7 100644
--- a/indra/llcommon/tests/llallocator_test.cpp
+++ b/indra/llcommon/tests/llallocator_test.cpp
@@ -3,25 +3,25 @@
  * @author Brad Kittenbrink
  * @date   2008-02-
  * @brief  Test for llallocator.cpp.
- * 
+ *
  * $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$
  */
@@ -71,7 +71,7 @@ namespace tut
 
         delete [] test_alloc;
 
-        llallocator.getProfile();        
+        llallocator.getProfile();
 
         // *NOTE - this test isn't ensuring anything right now other than no
         // exceptions are thrown.
diff --git a/indra/llcommon/tests/llbase64_test.cpp b/indra/llcommon/tests/llbase64_test.cpp
index d0394150fa..69b062fc0c 100644
--- a/indra/llcommon/tests/llbase64_test.cpp
+++ b/indra/llcommon/tests/llbase64_test.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llbase64_test.cpp
  * @author James Cook
  * @date 2007-02-04
@@ -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$
  */
@@ -36,42 +36,42 @@
 
 namespace tut
 {
-	struct base64_data
-	{
-	};
-	typedef test_group<base64_data> base64_test;
-	typedef base64_test::object base64_object;
-	tut::base64_test base64("LLBase64");
+    struct base64_data
+    {
+    };
+    typedef test_group<base64_data> base64_test;
+    typedef base64_test::object base64_object;
+    tut::base64_test base64("LLBase64");
 
-	template<> template<>
-	void base64_object::test<1>()
-	{
-		std::string result;
+    template<> template<>
+    void base64_object::test<1>()
+    {
+        std::string result;
 
-		result = LLBase64::encode(NULL, 0);
-		ensure("encode nothing", (result == "") );
+        result = LLBase64::encode(NULL, 0);
+        ensure("encode nothing", (result == "") );
 
-		LLUUID nothing;
-		result = LLBase64::encode(&nothing.mData[0], UUID_BYTES);
-		ensure("encode blank uuid",
-				(result == "AAAAAAAAAAAAAAAAAAAAAA==") );
+        LLUUID nothing;
+        result = LLBase64::encode(&nothing.mData[0], UUID_BYTES);
+        ensure("encode blank uuid",
+                (result == "AAAAAAAAAAAAAAAAAAAAAA==") );
 
-		LLUUID id("526a1e07-a19d-baed-84c4-ff08a488d15e");
-		result = LLBase64::encode(&id.mData[0], UUID_BYTES);
-		ensure("encode random uuid",
-				(result == "UmoeB6Gduu2ExP8IpIjRXg==") );
+        LLUUID id("526a1e07-a19d-baed-84c4-ff08a488d15e");
+        result = LLBase64::encode(&id.mData[0], UUID_BYTES);
+        ensure("encode random uuid",
+                (result == "UmoeB6Gduu2ExP8IpIjRXg==") );
 
-	}
+    }
 
-	template<> template<>
-	void base64_object::test<2>()
-	{
-		std::string result;
+    template<> template<>
+    void base64_object::test<2>()
+    {
+        std::string result;
 
-		U8 blob[40] = { 115, 223, 172, 255, 140, 70, 49, 125, 236, 155, 45, 199, 101, 17, 164, 131, 230, 19, 80, 64, 112, 53, 135, 98, 237, 12, 26, 72, 126, 14, 145, 143, 118, 196, 11, 177, 132, 169, 195, 134 };
-		result = LLBase64::encode(&blob[0], 40);
-		ensure("encode 40 bytes", 
-				(result == "c9+s/4xGMX3smy3HZRGkg+YTUEBwNYdi7QwaSH4OkY92xAuxhKnDhg==") );
-	}
+        U8 blob[40] = { 115, 223, 172, 255, 140, 70, 49, 125, 236, 155, 45, 199, 101, 17, 164, 131, 230, 19, 80, 64, 112, 53, 135, 98, 237, 12, 26, 72, 126, 14, 145, 143, 118, 196, 11, 177, 132, 169, 195, 134 };
+        result = LLBase64::encode(&blob[0], 40);
+        ensure("encode 40 bytes",
+                (result == "c9+s/4xGMX3smy3HZRGkg+YTUEBwNYdi7QwaSH4OkY92xAuxhKnDhg==") );
+    }
 
 }
diff --git a/indra/llcommon/tests/llcond_test.cpp b/indra/llcommon/tests/llcond_test.cpp
index 478149eacf..f2a302ed13 100644
--- a/indra/llcommon/tests/llcond_test.cpp
+++ b/indra/llcommon/tests/llcond_test.cpp
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2019-07-18
  * @brief  Test for llcond.
- * 
+ *
  * $LicenseInfo:firstyear=2019&license=viewerlgpl$
  * Copyright (c) 2019, Linden Research, Inc.
  * $/LicenseInfo$
@@ -38,7 +38,7 @@ namespace tut
     {
         set_test_name("Immediate gratification");
         cond.set_one(1);
-        ensure("wait_for_equal() failed", 
+        ensure("wait_for_equal() failed",
                cond.wait_for_equal(F32Milliseconds(1), 1));
         ensure("wait_for_unequal() should have failed",
                ! cond.wait_for_unequal(F32Milliseconds(1), 1));
diff --git a/indra/llcommon/tests/lldate_test.cpp b/indra/llcommon/tests/lldate_test.cpp
index 7c95ccb91f..6d38b71649 100644
--- a/indra/llcommon/tests/lldate_test.cpp
+++ b/indra/llcommon/tests/lldate_test.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$
  */
@@ -34,180 +34,180 @@
 #include "../test/lltut.h"
 
 
-#define VALID_DATE									"2003-04-30T04:00:00Z"
-#define VALID_DATE_LEAP								"2004-02-29T04:00:00Z"
-#define VALID_DATE_HOUR_BOUNDARY					"2003-04-30T23:59:59Z"
-#define VALID_DATE_FRACTIONAL_SECS					"2007-09-26T20:31:33.70Z"
+#define VALID_DATE                                  "2003-04-30T04:00:00Z"
+#define VALID_DATE_LEAP                             "2004-02-29T04:00:00Z"
+#define VALID_DATE_HOUR_BOUNDARY                    "2003-04-30T23:59:59Z"
+#define VALID_DATE_FRACTIONAL_SECS                  "2007-09-26T20:31:33.70Z"
 
 // invalid format
-#define INVALID_DATE_MISSING_YEAR					"-04-30T22:59:59Z"
-#define INVALID_DATE_MISSING_MONTH					"1900-0430T22:59:59Z"
-#define INVALID_DATE_MISSING_DATE					"1900-0430-T22:59:59Z"
-#define INVALID_DATE_MISSING_T						"1900-04-30-22:59:59Z"
-#define INVALID_DATE_MISSING_HOUR					"1900-04-30T:59:59Z"
-#define INVALID_DATE_MISSING_MIN					"1900-04-30T01::59Z"
-#define INVALID_DATE_MISSING_SEC					"1900-04-30T01:59Z"
-#define INVALID_DATE_MISSING_Z						"1900-04-30T01:59:23"
-#define INVALID_DATE_EMPTY							""
+#define INVALID_DATE_MISSING_YEAR                   "-04-30T22:59:59Z"
+#define INVALID_DATE_MISSING_MONTH                  "1900-0430T22:59:59Z"
+#define INVALID_DATE_MISSING_DATE                   "1900-0430-T22:59:59Z"
+#define INVALID_DATE_MISSING_T                      "1900-04-30-22:59:59Z"
+#define INVALID_DATE_MISSING_HOUR                   "1900-04-30T:59:59Z"
+#define INVALID_DATE_MISSING_MIN                    "1900-04-30T01::59Z"
+#define INVALID_DATE_MISSING_SEC                    "1900-04-30T01:59Z"
+#define INVALID_DATE_MISSING_Z                      "1900-04-30T01:59:23"
+#define INVALID_DATE_EMPTY                          ""
 
 // invalid values
 // apr 1.1.1 seems to not care about constraining the date to valid
 // dates. Put these back when the parser checks.
 #define LL_DATE_PARSER_CHECKS_BOUNDARY 0
-//#define INVALID_DATE_24HOUR_BOUNDARY				"2003-04-30T24:00:00Z"
-//#define INVALID_DATE_LEAP							"2003-04-29T04:00:00Z"
-//#define INVALID_DATE_HOUR							"2003-04-30T24:59:59Z"
-//#define INVALID_DATE_MIN							"2003-04-30T22:69:59Z"
-//#define INVALID_DATE_SEC							"2003-04-30T22:59:69Z"
-//#define INVALID_DATE_YEAR							"0-04-30T22:59:59Z"
-//#define INVALID_DATE_MONTH							"2003-13-30T22:59:59Z"
-//#define INVALID_DATE_DAY							"2003-04-35T22:59:59Z"
+//#define INVALID_DATE_24HOUR_BOUNDARY              "2003-04-30T24:00:00Z"
+//#define INVALID_DATE_LEAP                         "2003-04-29T04:00:00Z"
+//#define INVALID_DATE_HOUR                         "2003-04-30T24:59:59Z"
+//#define INVALID_DATE_MIN                          "2003-04-30T22:69:59Z"
+//#define INVALID_DATE_SEC                          "2003-04-30T22:59:69Z"
+//#define INVALID_DATE_YEAR                         "0-04-30T22:59:59Z"
+//#define INVALID_DATE_MONTH                            "2003-13-30T22:59:59Z"
+//#define INVALID_DATE_DAY                          "2003-04-35T22:59:59Z"
 
 namespace tut
 {
-	struct date_test
-	{
+    struct date_test
+    {
 
-	};
-	typedef test_group<date_test> date_test_t;
-	typedef date_test_t::object date_test_object_t;
-	tut::date_test_t tut_date_test("LLDate");
+    };
+    typedef test_group<date_test> date_test_t;
+    typedef date_test_t::object date_test_object_t;
+    tut::date_test_t tut_date_test("LLDate");
 
-	/* format validation */
-	template<> template<>
-	void date_test_object_t::test<1>()
-	{
-		LLDate date(VALID_DATE);
-		std::string  expected_string;
-		bool result;
-		expected_string = VALID_DATE;
-		ensure_equals("Valid Date failed" , expected_string, date.asString());
+    /* format validation */
+    template<> template<>
+    void date_test_object_t::test<1>()
+    {
+        LLDate date(VALID_DATE);
+        std::string  expected_string;
+        bool result;
+        expected_string = VALID_DATE;
+        ensure_equals("Valid Date failed" , expected_string, date.asString());
 
-		result = date.fromString(VALID_DATE_LEAP);
-		expected_string = VALID_DATE_LEAP; 	
-		ensure_equals("VALID_DATE_LEAP failed" , expected_string, date.asString());
+        result = date.fromString(VALID_DATE_LEAP);
+        expected_string = VALID_DATE_LEAP;
+        ensure_equals("VALID_DATE_LEAP failed" , expected_string, date.asString());
 
-		result = date.fromString(VALID_DATE_HOUR_BOUNDARY);
-		expected_string = VALID_DATE_HOUR_BOUNDARY; 	
-		ensure_equals("VALID_DATE_HOUR_BOUNDARY failed" , expected_string, date.asString());
+        result = date.fromString(VALID_DATE_HOUR_BOUNDARY);
+        expected_string = VALID_DATE_HOUR_BOUNDARY;
+        ensure_equals("VALID_DATE_HOUR_BOUNDARY failed" , expected_string, date.asString());
 
-		result = date.fromString(VALID_DATE_FRACTIONAL_SECS);
-		expected_string = VALID_DATE_FRACTIONAL_SECS;
-		ensure_equals("VALID_DATE_FRACTIONAL_SECS failed" , expected_string, date.asString());
+        result = date.fromString(VALID_DATE_FRACTIONAL_SECS);
+        expected_string = VALID_DATE_FRACTIONAL_SECS;
+        ensure_equals("VALID_DATE_FRACTIONAL_SECS failed" , expected_string, date.asString());
 
-		result = date.fromString(INVALID_DATE_MISSING_YEAR);
-		ensure_equals("INVALID_DATE_MISSING_YEAR should have failed" , result, false);
+        result = date.fromString(INVALID_DATE_MISSING_YEAR);
+        ensure_equals("INVALID_DATE_MISSING_YEAR should have failed" , result, false);
 
-		result = date.fromString(INVALID_DATE_MISSING_MONTH);
-		ensure_equals("INVALID_DATE_MISSING_MONTH should have failed" , result, false);
+        result = date.fromString(INVALID_DATE_MISSING_MONTH);
+        ensure_equals("INVALID_DATE_MISSING_MONTH should have failed" , result, false);
 
-		result = date.fromString(INVALID_DATE_MISSING_DATE);
-		ensure_equals("INVALID_DATE_MISSING_DATE should have failed" , result, false);
+        result = date.fromString(INVALID_DATE_MISSING_DATE);
+        ensure_equals("INVALID_DATE_MISSING_DATE should have failed" , result, false);
 
-		result = date.fromString(INVALID_DATE_MISSING_T);
-		ensure_equals("INVALID_DATE_MISSING_T should have failed" , result, false);
+        result = date.fromString(INVALID_DATE_MISSING_T);
+        ensure_equals("INVALID_DATE_MISSING_T should have failed" , result, false);
 
-		result = date.fromString(INVALID_DATE_MISSING_HOUR);
-		ensure_equals("INVALID_DATE_MISSING_HOUR should have failed" , result, false);
+        result = date.fromString(INVALID_DATE_MISSING_HOUR);
+        ensure_equals("INVALID_DATE_MISSING_HOUR should have failed" , result, false);
 
-		result = date.fromString(INVALID_DATE_MISSING_MIN);
-		ensure_equals("INVALID_DATE_MISSING_MIN should have failed" , result, false);
+        result = date.fromString(INVALID_DATE_MISSING_MIN);
+        ensure_equals("INVALID_DATE_MISSING_MIN should have failed" , result, false);
 
-		result = date.fromString(INVALID_DATE_MISSING_SEC);
-		ensure_equals("INVALID_DATE_MISSING_SEC should have failed" , result, false);
+        result = date.fromString(INVALID_DATE_MISSING_SEC);
+        ensure_equals("INVALID_DATE_MISSING_SEC should have failed" , result, false);
 
-		result = date.fromString(INVALID_DATE_MISSING_Z);
-		ensure_equals("INVALID_DATE_MISSING_Z should have failed" , result, false);
+        result = date.fromString(INVALID_DATE_MISSING_Z);
+        ensure_equals("INVALID_DATE_MISSING_Z should have failed" , result, false);
 
-		result = date.fromString(INVALID_DATE_EMPTY);
-		ensure_equals("INVALID_DATE_EMPTY should have failed" , result, false);
-	}
+        result = date.fromString(INVALID_DATE_EMPTY);
+        ensure_equals("INVALID_DATE_EMPTY should have failed" , result, false);
+    }
 
-	/* Invalid Value Handling */
-	template<> template<>
-	void date_test_object_t::test<2>()
-	{
+    /* Invalid Value Handling */
+    template<> template<>
+    void date_test_object_t::test<2>()
+    {
 #if LL_DATE_PARSER_CHECKS_BOUNDARY
-		LLDate date;
-		std::string  expected_string;
-		bool result;
+        LLDate date;
+        std::string  expected_string;
+        bool result;
 
-		result = date.fromString(INVALID_DATE_24HOUR_BOUNDARY);
-		ensure_equals("INVALID_DATE_24HOUR_BOUNDARY should have failed" , result, false);
-		ensure_equals("INVALID_DATE_24HOUR_BOUNDARY date still set to old value on failure!" , date.secondsSinceEpoch(), 0);
+        result = date.fromString(INVALID_DATE_24HOUR_BOUNDARY);
+        ensure_equals("INVALID_DATE_24HOUR_BOUNDARY should have failed" , result, false);
+        ensure_equals("INVALID_DATE_24HOUR_BOUNDARY date still set to old value on failure!" , date.secondsSinceEpoch(), 0);
 
-		result = date.fromString(INVALID_DATE_LEAP);
-		ensure_equals("INVALID_DATE_LEAP should have failed" , result, false);
+        result = date.fromString(INVALID_DATE_LEAP);
+        ensure_equals("INVALID_DATE_LEAP should have failed" , result, false);
 
-		result = date.fromString(INVALID_DATE_HOUR);
-		ensure_equals("INVALID_DATE_HOUR should have failed" , result, false);
+        result = date.fromString(INVALID_DATE_HOUR);
+        ensure_equals("INVALID_DATE_HOUR should have failed" , result, false);
 
-		result = date.fromString(INVALID_DATE_MIN);
-		ensure_equals("INVALID_DATE_MIN should have failed" , result, false);
+        result = date.fromString(INVALID_DATE_MIN);
+        ensure_equals("INVALID_DATE_MIN should have failed" , result, false);
 
-		result = date.fromString(INVALID_DATE_SEC);
-		ensure_equals("INVALID_DATE_SEC should have failed" , result, false);
+        result = date.fromString(INVALID_DATE_SEC);
+        ensure_equals("INVALID_DATE_SEC should have failed" , result, false);
 
-		result = date.fromString(INVALID_DATE_YEAR);
-		ensure_equals("INVALID_DATE_YEAR should have failed" , result, false);
+        result = date.fromString(INVALID_DATE_YEAR);
+        ensure_equals("INVALID_DATE_YEAR should have failed" , result, false);
 
-		result = date.fromString(INVALID_DATE_MONTH);
-		ensure_equals("INVALID_DATE_MONTH should have failed" , result, false);
+        result = date.fromString(INVALID_DATE_MONTH);
+        ensure_equals("INVALID_DATE_MONTH should have failed" , result, false);
 
-		result = date.fromString(INVALID_DATE_DAY);
-		ensure_equals("INVALID_DATE_DAY should have failed" , result, false);
+        result = date.fromString(INVALID_DATE_DAY);
+        ensure_equals("INVALID_DATE_DAY should have failed" , result, false);
 #endif
-	}
-
-	/* API checks */
-	template<> template<>
-	void date_test_object_t::test<3>()
-	{
-		LLDate date;
-		std::istringstream stream(VALID_DATE);
-		std::string  expected_string = VALID_DATE;
-		date.fromStream(stream);
-		ensure_equals("fromStream failed", date.asString(), expected_string);
-	}
-
-	template<> template<>
-	void date_test_object_t::test<4>()
-	{
-		LLDate date1(VALID_DATE);
-		LLDate date2(date1);
-		ensure_equals("LLDate(const LLDate& date) constructor failed", date1.asString(), date2.asString());
-	}
-
-	template<> template<>
-	void date_test_object_t::test<5>()
-	{
-		LLDate date1(VALID_DATE);
-		LLDate date2(date1.secondsSinceEpoch());
-		ensure_equals("secondsSinceEpoch not equal",date1.secondsSinceEpoch(), date2.secondsSinceEpoch());
-		ensure_equals("LLDate created using secondsSinceEpoch not equal", date1.asString(), date2.asString());
-	}
-
-	template<> template<>
-	void date_test_object_t::test<6>()
-	{
-		LLDate date(VALID_DATE);
-		std::ostringstream stream;
-		stream << date;
-		std::string expected_str = VALID_DATE;
-		ensure_equals("ostringstream failed", expected_str, stream.str());
-	}
-
-	template<> template<>
-	void date_test_object_t::test<7>()
-	{
-		LLDate date;
-		std::istringstream stream(VALID_DATE);
-		stream >> date;
-		std::string expected_str = VALID_DATE;
-		std::ostringstream out_stream;
+    }
+
+    /* API checks */
+    template<> template<>
+    void date_test_object_t::test<3>()
+    {
+        LLDate date;
+        std::istringstream stream(VALID_DATE);
+        std::string  expected_string = VALID_DATE;
+        date.fromStream(stream);
+        ensure_equals("fromStream failed", date.asString(), expected_string);
+    }
+
+    template<> template<>
+    void date_test_object_t::test<4>()
+    {
+        LLDate date1(VALID_DATE);
+        LLDate date2(date1);
+        ensure_equals("LLDate(const LLDate& date) constructor failed", date1.asString(), date2.asString());
+    }
+
+    template<> template<>
+    void date_test_object_t::test<5>()
+    {
+        LLDate date1(VALID_DATE);
+        LLDate date2(date1.secondsSinceEpoch());
+        ensure_equals("secondsSinceEpoch not equal",date1.secondsSinceEpoch(), date2.secondsSinceEpoch());
+        ensure_equals("LLDate created using secondsSinceEpoch not equal", date1.asString(), date2.asString());
+    }
+
+    template<> template<>
+    void date_test_object_t::test<6>()
+    {
+        LLDate date(VALID_DATE);
+        std::ostringstream stream;
+        stream << date;
+        std::string expected_str = VALID_DATE;
+        ensure_equals("ostringstream failed", expected_str, stream.str());
+    }
+
+    template<> template<>
+    void date_test_object_t::test<7>()
+    {
+        LLDate date;
+        std::istringstream stream(VALID_DATE);
+        stream >> date;
+        std::string expected_str = VALID_DATE;
+        std::ostringstream out_stream;
         out_stream << date;
 
-		ensure_equals("<< failed", date.asString(),expected_str);
-		ensure_equals("<< to >> failed", stream.str(),out_stream.str());		
-	}
+        ensure_equals("<< failed", date.asString(),expected_str);
+        ensure_equals("<< to >> failed", stream.str(),out_stream.str());
+    }
 }
diff --git a/indra/llcommon/tests/lldeadmantimer_test.cpp b/indra/llcommon/tests/lldeadmantimer_test.cpp
index 23167762c3..01e6e8e2f7 100644
--- a/indra/llcommon/tests/lldeadmantimer_test.cpp
+++ b/indra/llcommon/tests/lldeadmantimer_test.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file lldeadmantimer_test.cpp
  * @brief Tests for the LLDeadmanTimer class.
  *
  * $LicenseInfo:firstyear=2013&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2013, 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,12 +37,12 @@
 
 static LLDeadmanTimer::time_type float_time_to_u64(F64 delta)
 {
-	return LLDeadmanTimer::time_type(delta * get_timer_info().mClockFrequency);
+    return LLDeadmanTimer::time_type(delta * get_timer_info().mClockFrequency);
 }
 
 static F64 u64_time_to_float(LLDeadmanTimer::time_type delta)
 {
-	return delta * get_timer_info().mClockFrequencyInv;
+    return delta * get_timer_info().mClockFrequencyInv;
 }
 
 
@@ -51,11 +51,11 @@ namespace tut
 
 struct deadmantimer_test
 {
-	deadmantimer_test()
-		{
-			// LLTimer internals updating
-			get_timer_info().update();
-		}
+    deadmantimer_test()
+        {
+            // LLTimer internals updating
+            get_timer_info().update();
+        }
 };
 
 typedef test_group<deadmantimer_test> deadmantimer_group_t;
@@ -66,31 +66,31 @@ tut::deadmantimer_group_t deadmantimer_instance("LLDeadmanTimer");
 template<> template<>
 void deadmantimer_object_t::test<1>()
 {
-	{
-		// Without cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8));
-		LLDeadmanTimer timer(10.0, false);
-
-		ensure_equals("WOCM isExpired() returns false after ctor()", timer.isExpired(0, started, stopped, count), false);
-		ensure_approximately_equals("WOCM t1 - isExpired() does not modify started", started, F64(42.0), 2);
-		ensure_approximately_equals("WOCM t1 - isExpired() does not modify stopped", stopped, F64(97.0), 2);
-		ensure_equals("WOCM t1 - isExpired() does not modify count", count, U64L(8));
-	}
-
-	{
-		// With cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
-		LLDeadmanTimer timer(10.0, true);
-
-		ensure_equals("WCM isExpired() returns false after ctor()", timer.isExpired(0, started, stopped, count, user_cpu, sys_cpu), false);
-		ensure_approximately_equals("WCM t1 - isExpired() does not modify started", started, F64(42.0), 2);
-		ensure_approximately_equals("WCM t1 - isExpired() does not modify stopped", stopped, F64(97.0), 2);
-		ensure_equals("WCM t1 - isExpired() does not modify count", count, U64L(8));
-		ensure_equals("WCM t1 - isExpired() does not modify user_cpu", user_cpu, U64L(29000));
-		ensure_equals("WCM t1 - isExpired() does not modify sys_cpu", sys_cpu, U64L(57000));
-	}
+    {
+        // Without cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8));
+        LLDeadmanTimer timer(10.0, false);
+
+        ensure_equals("WOCM isExpired() returns false after ctor()", timer.isExpired(0, started, stopped, count), false);
+        ensure_approximately_equals("WOCM t1 - isExpired() does not modify started", started, F64(42.0), 2);
+        ensure_approximately_equals("WOCM t1 - isExpired() does not modify stopped", stopped, F64(97.0), 2);
+        ensure_equals("WOCM t1 - isExpired() does not modify count", count, U64L(8));
+    }
+
+    {
+        // With cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
+        LLDeadmanTimer timer(10.0, true);
+
+        ensure_equals("WCM isExpired() returns false after ctor()", timer.isExpired(0, started, stopped, count, user_cpu, sys_cpu), false);
+        ensure_approximately_equals("WCM t1 - isExpired() does not modify started", started, F64(42.0), 2);
+        ensure_approximately_equals("WCM t1 - isExpired() does not modify stopped", stopped, F64(97.0), 2);
+        ensure_equals("WCM t1 - isExpired() does not modify count", count, U64L(8));
+        ensure_equals("WCM t1 - isExpired() does not modify user_cpu", user_cpu, U64L(29000));
+        ensure_equals("WCM t1 - isExpired() does not modify sys_cpu", sys_cpu, U64L(57000));
+    }
 }
 
 
@@ -98,25 +98,25 @@ void deadmantimer_object_t::test<1>()
 template<> template<>
 void deadmantimer_object_t::test<2>()
 {
-	{
-		// Without cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8));
-		LLDeadmanTimer timer(0.0, false);			// Zero is pre-expired
-		
-		ensure_equals("WOCM isExpired() still returns false with 0.0 time ctor()",
-					  timer.isExpired(0, started, stopped, count), false);
-	}
-
-	{
-		// With cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
-		LLDeadmanTimer timer(0.0, true);			// Zero is pre-expired
-		
-		ensure_equals("WCM isExpired() still returns false with 0.0 time ctor()",
-					  timer.isExpired(0, started, stopped, count, user_cpu, sys_cpu), false);
-	}
+    {
+        // Without cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8));
+        LLDeadmanTimer timer(0.0, false);           // Zero is pre-expired
+
+        ensure_equals("WOCM isExpired() still returns false with 0.0 time ctor()",
+                      timer.isExpired(0, started, stopped, count), false);
+    }
+
+    {
+        // With cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
+        LLDeadmanTimer timer(0.0, true);            // Zero is pre-expired
+
+        ensure_equals("WCM isExpired() still returns false with 0.0 time ctor()",
+                      timer.isExpired(0, started, stopped, count, user_cpu, sys_cpu), false);
+    }
 }
 
 
@@ -125,28 +125,28 @@ void deadmantimer_object_t::test<2>()
 template<> template<>
 void deadmantimer_object_t::test<3>()
 {
-	{
-		// Without cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8));
-		LLDeadmanTimer timer(0.0, false);
-
-		timer.start(0);
-		ensure_equals("WOCM isExpired() returns true with 0.0 horizon time",
-					  timer.isExpired(0, started, stopped, count), true);
- 		ensure_approximately_equals("WOCM expired timer with no bell ringing has stopped == started", started, stopped, 8);
-	}
-	{
-		// With cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
-		LLDeadmanTimer timer(0.0, true);
-
-		timer.start(0);
-		ensure_equals("WCM isExpired() returns true with 0.0 horizon time",
-					  timer.isExpired(0, started, stopped, count, user_cpu, sys_cpu), true);
-		ensure_approximately_equals("WCM expired timer with no bell ringing has stopped == started", started, stopped, 8);
-	}
+    {
+        // Without cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8));
+        LLDeadmanTimer timer(0.0, false);
+
+        timer.start(0);
+        ensure_equals("WOCM isExpired() returns true with 0.0 horizon time",
+                      timer.isExpired(0, started, stopped, count), true);
+        ensure_approximately_equals("WOCM expired timer with no bell ringing has stopped == started", started, stopped, 8);
+    }
+    {
+        // With cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
+        LLDeadmanTimer timer(0.0, true);
+
+        timer.start(0);
+        ensure_equals("WCM isExpired() returns true with 0.0 horizon time",
+                      timer.isExpired(0, started, stopped, count, user_cpu, sys_cpu), true);
+        ensure_approximately_equals("WCM expired timer with no bell ringing has stopped == started", started, stopped, 8);
+    }
 }
 
 
@@ -154,30 +154,30 @@ void deadmantimer_object_t::test<3>()
 template<> template<>
 void deadmantimer_object_t::test<4>()
 {
-	{
-		// Without cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8));
-		LLDeadmanTimer timer(0.0, false);
-	
-		timer.start(0);
-		timer.ringBell(LLDeadmanTimer::getNow() + float_time_to_u64(1000.0), 1);
-		ensure_equals("WOCM isExpired() returns true with 0.0 horizon time after bell ring",
-					  timer.isExpired(0, started, stopped, count), true);
-		ensure_approximately_equals("WOCM ringBell has no impact on expired timer leaving stopped == started", started, stopped, 8);
-	}
-	{
-		// With cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
-		LLDeadmanTimer timer(0.0, true);
-	
-		timer.start(0);
-		timer.ringBell(LLDeadmanTimer::getNow() + float_time_to_u64(1000.0), 1);
-		ensure_equals("WCM isExpired() returns true with 0.0 horizon time after bell ring",
-					  timer.isExpired(0, started, stopped, count, user_cpu, sys_cpu), true);
-		ensure_approximately_equals("WCM ringBell has no impact on expired timer leaving stopped == started", started, stopped, 8);
-	}
+    {
+        // Without cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8));
+        LLDeadmanTimer timer(0.0, false);
+
+        timer.start(0);
+        timer.ringBell(LLDeadmanTimer::getNow() + float_time_to_u64(1000.0), 1);
+        ensure_equals("WOCM isExpired() returns true with 0.0 horizon time after bell ring",
+                      timer.isExpired(0, started, stopped, count), true);
+        ensure_approximately_equals("WOCM ringBell has no impact on expired timer leaving stopped == started", started, stopped, 8);
+    }
+    {
+        // With cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
+        LLDeadmanTimer timer(0.0, true);
+
+        timer.start(0);
+        timer.ringBell(LLDeadmanTimer::getNow() + float_time_to_u64(1000.0), 1);
+        ensure_equals("WCM isExpired() returns true with 0.0 horizon time after bell ring",
+                      timer.isExpired(0, started, stopped, count, user_cpu, sys_cpu), true);
+        ensure_approximately_equals("WCM ringBell has no impact on expired timer leaving stopped == started", started, stopped, 8);
+    }
 }
 
 
@@ -185,34 +185,34 @@ void deadmantimer_object_t::test<4>()
 template<> template<>
 void deadmantimer_object_t::test<5>()
 {
-	{
-		// Without cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8));
-		LLDeadmanTimer timer(10.0, false);
-	
-		timer.start(0);
-		ensure_equals("WOCM isExpired() returns false after starting with 10.0 horizon time",
-					  timer.isExpired(0, started, stopped, count), false);
-		ensure_approximately_equals("WOCM t5 - isExpired() does not modify started", started, F64(42.0), 2);
-		ensure_approximately_equals("WOCM t5 - isExpired() does not modify stopped", stopped, F64(97.0), 2);
-		ensure_equals("WOCM t5 - isExpired() does not modify count", count, U64L(8));
-	}
-	{
-		// With cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
-		LLDeadmanTimer timer(10.0, true);
-	
-		timer.start(0);
-		ensure_equals("WCM isExpired() returns false after starting with 10.0 horizon time",
-					  timer.isExpired(0, started, stopped, count, user_cpu, sys_cpu), false);
-		ensure_approximately_equals("WCM t5 - isExpired() does not modify started", started, F64(42.0), 2);
-		ensure_approximately_equals("WCM t5 - isExpired() does not modify stopped", stopped, F64(97.0), 2);
-		ensure_equals("WCM t5 - isExpired() does not modify count", count, U64L(8));
-		ensure_equals("WCM t5 - isExpired() does not modify user_cpu", user_cpu, U64L(29000));
-		ensure_equals("WCM t5 - isExpired() does not modify sys_cpu", sys_cpu, U64L(57000));
-	}
+    {
+        // Without cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8));
+        LLDeadmanTimer timer(10.0, false);
+
+        timer.start(0);
+        ensure_equals("WOCM isExpired() returns false after starting with 10.0 horizon time",
+                      timer.isExpired(0, started, stopped, count), false);
+        ensure_approximately_equals("WOCM t5 - isExpired() does not modify started", started, F64(42.0), 2);
+        ensure_approximately_equals("WOCM t5 - isExpired() does not modify stopped", stopped, F64(97.0), 2);
+        ensure_equals("WOCM t5 - isExpired() does not modify count", count, U64L(8));
+    }
+    {
+        // With cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
+        LLDeadmanTimer timer(10.0, true);
+
+        timer.start(0);
+        ensure_equals("WCM isExpired() returns false after starting with 10.0 horizon time",
+                      timer.isExpired(0, started, stopped, count, user_cpu, sys_cpu), false);
+        ensure_approximately_equals("WCM t5 - isExpired() does not modify started", started, F64(42.0), 2);
+        ensure_approximately_equals("WCM t5 - isExpired() does not modify stopped", stopped, F64(97.0), 2);
+        ensure_equals("WCM t5 - isExpired() does not modify count", count, U64L(8));
+        ensure_equals("WCM t5 - isExpired() does not modify user_cpu", user_cpu, U64L(29000));
+        ensure_equals("WCM t5 - isExpired() does not modify sys_cpu", sys_cpu, U64L(57000));
+    }
 }
 
 
@@ -220,46 +220,46 @@ void deadmantimer_object_t::test<5>()
 template<> template<>
 void deadmantimer_object_t::test<6>()
 {
-	{
-		// Without cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8));
-		LLDeadmanTimer timer(10.0, false);
-
-		// Would like to do subtraction on current time but can't because
-		// the implementation on Windows is zero-based.  We wrap around
-		// the backside resulting in a large U64 number.
-	
-		LLDeadmanTimer::time_type the_past(LLDeadmanTimer::getNow());
-		LLDeadmanTimer::time_type now(the_past + float_time_to_u64(5.0));
-		timer.start(the_past);
-		ensure_equals("WOCM t6 - isExpired() returns false with 10.0 horizon time starting 5.0 in past",
-					  timer.isExpired(now, started, stopped, count), false);
-		ensure_approximately_equals("WOCM t6 - isExpired() does not modify started", started, F64(42.0), 2);
-		ensure_approximately_equals("WOCM t6 - isExpired() does not modify stopped", stopped, F64(97.0), 2);
-		ensure_equals("WOCM t6 - isExpired() does not modify count", count, U64L(8));
-	}
-	{
-		// With cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
-		LLDeadmanTimer timer(10.0, true);
-
-		// Would like to do subtraction on current time but can't because
-		// the implementation on Windows is zero-based.  We wrap around
-		// the backside resulting in a large U64 number.
-	
-		LLDeadmanTimer::time_type the_past(LLDeadmanTimer::getNow());
-		LLDeadmanTimer::time_type now(the_past + float_time_to_u64(5.0));
-		timer.start(the_past);
-		ensure_equals("WCM t6 - isExpired() returns false with 10.0 horizon time starting 5.0 in past",
-					  timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), false);
-		ensure_approximately_equals("WCM t6 - isExpired() does not modify started", started, F64(42.0), 2);
-		ensure_approximately_equals("WCM t6 - isExpired() does not modify stopped", stopped, F64(97.0), 2);
-		ensure_equals("t6 - isExpired() does not modify count", count, U64L(8));
-		ensure_equals("WCM t6 - isExpired() does not modify user_cpu", user_cpu, U64L(29000));
-		ensure_equals("WCM t6 - isExpired() does not modify sys_cpu", sys_cpu, U64L(57000));
-	}
+    {
+        // Without cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8));
+        LLDeadmanTimer timer(10.0, false);
+
+        // Would like to do subtraction on current time but can't because
+        // the implementation on Windows is zero-based.  We wrap around
+        // the backside resulting in a large U64 number.
+
+        LLDeadmanTimer::time_type the_past(LLDeadmanTimer::getNow());
+        LLDeadmanTimer::time_type now(the_past + float_time_to_u64(5.0));
+        timer.start(the_past);
+        ensure_equals("WOCM t6 - isExpired() returns false with 10.0 horizon time starting 5.0 in past",
+                      timer.isExpired(now, started, stopped, count), false);
+        ensure_approximately_equals("WOCM t6 - isExpired() does not modify started", started, F64(42.0), 2);
+        ensure_approximately_equals("WOCM t6 - isExpired() does not modify stopped", stopped, F64(97.0), 2);
+        ensure_equals("WOCM t6 - isExpired() does not modify count", count, U64L(8));
+    }
+    {
+        // With cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
+        LLDeadmanTimer timer(10.0, true);
+
+        // Would like to do subtraction on current time but can't because
+        // the implementation on Windows is zero-based.  We wrap around
+        // the backside resulting in a large U64 number.
+
+        LLDeadmanTimer::time_type the_past(LLDeadmanTimer::getNow());
+        LLDeadmanTimer::time_type now(the_past + float_time_to_u64(5.0));
+        timer.start(the_past);
+        ensure_equals("WCM t6 - isExpired() returns false with 10.0 horizon time starting 5.0 in past",
+                      timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), false);
+        ensure_approximately_equals("WCM t6 - isExpired() does not modify started", started, F64(42.0), 2);
+        ensure_approximately_equals("WCM t6 - isExpired() does not modify stopped", stopped, F64(97.0), 2);
+        ensure_equals("t6 - isExpired() does not modify count", count, U64L(8));
+        ensure_equals("WCM t6 - isExpired() does not modify user_cpu", user_cpu, U64L(29000));
+        ensure_equals("WCM t6 - isExpired() does not modify sys_cpu", sys_cpu, U64L(57000));
+    }
 }
 
 
@@ -267,40 +267,40 @@ void deadmantimer_object_t::test<6>()
 template<> template<>
 void deadmantimer_object_t::test<7>()
 {
-	{
-		// Without cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8));
-		LLDeadmanTimer timer(10.0, false);
-		
-		// Would like to do subtraction on current time but can't because
-		// the implementation on Windows is zero-based.  We wrap around
-		// the backside resulting in a large U64 number.
-	
-		LLDeadmanTimer::time_type the_past(LLDeadmanTimer::getNow());
-		LLDeadmanTimer::time_type now(the_past + float_time_to_u64(20.0));
-		timer.start(the_past);
-		ensure_equals("WOCM t7 - isExpired() returns true with 10.0 horizon time starting 20.0 in past",
-					  timer.isExpired(now,started, stopped, count), true);
-		ensure_approximately_equals("WOCM t7 - starting before horizon still gives equal started / stopped", started, stopped, 8);
-	}
-	{
-		// With cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
-		LLDeadmanTimer timer(10.0, true);
-		
-		// Would like to do subtraction on current time but can't because
-		// the implementation on Windows is zero-based.  We wrap around
-		// the backside resulting in a large U64 number.
-	
-		LLDeadmanTimer::time_type the_past(LLDeadmanTimer::getNow());
-		LLDeadmanTimer::time_type now(the_past + float_time_to_u64(20.0));
-		timer.start(the_past);
-		ensure_equals("WCM t7 - isExpired() returns true with 10.0 horizon time starting 20.0 in past",
-					  timer.isExpired(now,started, stopped, count, user_cpu, sys_cpu), true);
-		ensure_approximately_equals("WOCM t7 - starting before horizon still gives equal started / stopped", started, stopped, 8);
-	}
+    {
+        // Without cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8));
+        LLDeadmanTimer timer(10.0, false);
+
+        // Would like to do subtraction on current time but can't because
+        // the implementation on Windows is zero-based.  We wrap around
+        // the backside resulting in a large U64 number.
+
+        LLDeadmanTimer::time_type the_past(LLDeadmanTimer::getNow());
+        LLDeadmanTimer::time_type now(the_past + float_time_to_u64(20.0));
+        timer.start(the_past);
+        ensure_equals("WOCM t7 - isExpired() returns true with 10.0 horizon time starting 20.0 in past",
+                      timer.isExpired(now,started, stopped, count), true);
+        ensure_approximately_equals("WOCM t7 - starting before horizon still gives equal started / stopped", started, stopped, 8);
+    }
+    {
+        // With cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
+        LLDeadmanTimer timer(10.0, true);
+
+        // Would like to do subtraction on current time but can't because
+        // the implementation on Windows is zero-based.  We wrap around
+        // the backside resulting in a large U64 number.
+
+        LLDeadmanTimer::time_type the_past(LLDeadmanTimer::getNow());
+        LLDeadmanTimer::time_type now(the_past + float_time_to_u64(20.0));
+        timer.start(the_past);
+        ensure_equals("WCM t7 - isExpired() returns true with 10.0 horizon time starting 20.0 in past",
+                      timer.isExpired(now,started, stopped, count, user_cpu, sys_cpu), true);
+        ensure_approximately_equals("WOCM t7 - starting before horizon still gives equal started / stopped", started, stopped, 8);
+    }
 }
 
 
@@ -308,60 +308,60 @@ void deadmantimer_object_t::test<7>()
 template<> template<>
 void deadmantimer_object_t::test<8>()
 {
-	{
-		// Without cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8));
-		LLDeadmanTimer timer(10.0, false);
-
-		// Would like to do subtraction on current time but can't because
-		// the implementation on Windows is zero-based.  We wrap around
-		// the backside resulting in a large U64 number.
-	
-		LLDeadmanTimer::time_type the_past(LLDeadmanTimer::getNow());
-		LLDeadmanTimer::time_type now(the_past + float_time_to_u64(20.0));
-		timer.start(the_past);
-		ensure_equals("WOCM t8 - isExpired() returns true with 10.0 horizon time starting 20.0 in past",
-					  timer.isExpired(now, started, stopped, count), true);
-		
-		started = 42.0;
-		stopped = 97.0;
-		count = U64L(8);
-		ensure_equals("WOCM t8 - second isExpired() returns false after true",
-					  timer.isExpired(now, started, stopped, count), false);
-		ensure_approximately_equals("WOCM t8 - 2nd isExpired() does not modify started", started, F64(42.0), 2);
-		ensure_approximately_equals("WOCM t8 - 2nd isExpired() does not modify stopped", stopped, F64(97.0), 2);
-		ensure_equals("WOCM t8 - 2nd isExpired() does not modify count", count, U64L(8));
-	}
-	{
-		// With cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
-		LLDeadmanTimer timer(10.0, true);
-
-		// Would like to do subtraction on current time but can't because
-		// the implementation on Windows is zero-based.  We wrap around
-		// the backside resulting in a large U64 number.
-	
-		LLDeadmanTimer::time_type the_past(LLDeadmanTimer::getNow());
-		LLDeadmanTimer::time_type now(the_past + float_time_to_u64(20.0));
-		timer.start(the_past);
-		ensure_equals("WCM t8 - isExpired() returns true with 10.0 horizon time starting 20.0 in past",
-					  timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), true);
-		
-		started = 42.0;
-		stopped = 97.0;
-		count = U64L(8);
-		user_cpu = 29000;
-		sys_cpu = 57000;
-		ensure_equals("WCM t8 - second isExpired() returns false after true",
-					  timer.isExpired(now, started, stopped, count), false);
-		ensure_approximately_equals("WCM t8 - 2nd isExpired() does not modify started", started, F64(42.0), 2);
-		ensure_approximately_equals("WCM t8 - 2nd isExpired() does not modify stopped", stopped, F64(97.0), 2);
-		ensure_equals("WCM t8 - 2nd isExpired() does not modify count", count, U64L(8));
-		ensure_equals("WCM t8 - 2nd isExpired() does not modify user_cpu", user_cpu, U64L(29000));
-		ensure_equals("WCM t8 - 2nd isExpired() does not modify sys_cpu", sys_cpu, U64L(57000));
-	}
+    {
+        // Without cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8));
+        LLDeadmanTimer timer(10.0, false);
+
+        // Would like to do subtraction on current time but can't because
+        // the implementation on Windows is zero-based.  We wrap around
+        // the backside resulting in a large U64 number.
+
+        LLDeadmanTimer::time_type the_past(LLDeadmanTimer::getNow());
+        LLDeadmanTimer::time_type now(the_past + float_time_to_u64(20.0));
+        timer.start(the_past);
+        ensure_equals("WOCM t8 - isExpired() returns true with 10.0 horizon time starting 20.0 in past",
+                      timer.isExpired(now, started, stopped, count), true);
+
+        started = 42.0;
+        stopped = 97.0;
+        count = U64L(8);
+        ensure_equals("WOCM t8 - second isExpired() returns false after true",
+                      timer.isExpired(now, started, stopped, count), false);
+        ensure_approximately_equals("WOCM t8 - 2nd isExpired() does not modify started", started, F64(42.0), 2);
+        ensure_approximately_equals("WOCM t8 - 2nd isExpired() does not modify stopped", stopped, F64(97.0), 2);
+        ensure_equals("WOCM t8 - 2nd isExpired() does not modify count", count, U64L(8));
+    }
+    {
+        // With cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
+        LLDeadmanTimer timer(10.0, true);
+
+        // Would like to do subtraction on current time but can't because
+        // the implementation on Windows is zero-based.  We wrap around
+        // the backside resulting in a large U64 number.
+
+        LLDeadmanTimer::time_type the_past(LLDeadmanTimer::getNow());
+        LLDeadmanTimer::time_type now(the_past + float_time_to_u64(20.0));
+        timer.start(the_past);
+        ensure_equals("WCM t8 - isExpired() returns true with 10.0 horizon time starting 20.0 in past",
+                      timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), true);
+
+        started = 42.0;
+        stopped = 97.0;
+        count = U64L(8);
+        user_cpu = 29000;
+        sys_cpu = 57000;
+        ensure_equals("WCM t8 - second isExpired() returns false after true",
+                      timer.isExpired(now, started, stopped, count), false);
+        ensure_approximately_equals("WCM t8 - 2nd isExpired() does not modify started", started, F64(42.0), 2);
+        ensure_approximately_equals("WCM t8 - 2nd isExpired() does not modify stopped", stopped, F64(97.0), 2);
+        ensure_equals("WCM t8 - 2nd isExpired() does not modify count", count, U64L(8));
+        ensure_equals("WCM t8 - 2nd isExpired() does not modify user_cpu", user_cpu, U64L(29000));
+        ensure_equals("WCM t8 - 2nd isExpired() does not modify sys_cpu", sys_cpu, U64L(57000));
+    }
 }
 
 
@@ -369,92 +369,92 @@ void deadmantimer_object_t::test<8>()
 template<> template<>
 void deadmantimer_object_t::test<9>()
 {
-	{
-		// Without cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8));
-		LLDeadmanTimer timer(5.0, false);
-
-		LLDeadmanTimer::time_type now(LLDeadmanTimer::getNow());
-		F64 real_start(u64_time_to_float(now));
-		timer.start(0);
-
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		ensure_equals("WOCM t9 - 5.0 horizon timer has not timed out after 10 1-second bell rings",
-					  timer.isExpired(now, started, stopped, count), false);
-		F64 last_good_ring(u64_time_to_float(now));
-
-		// Jump forward and expire
-		now += float_time_to_u64(10.0);
-		ensure_equals("WOCM t9 - 5.0 horizon timer expires on 10-second jump",
-					  timer.isExpired(now, started, stopped, count), true);
-		ensure_approximately_equals("WOCM t9 - started matches start() time", started, real_start, 4);
-		ensure_approximately_equals("WOCM t9 - stopped matches last ringBell() time", stopped, last_good_ring, 4);
-		ensure_equals("WOCM t9 - 10 good ringBell()s", count, U64L(10));
-		ensure_equals("WOCM t9 - single read only", timer.isExpired(now, started, stopped, count), false);
-	}
-	{
-		// With cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
-		LLDeadmanTimer timer(5.0, true);
-
-		LLDeadmanTimer::time_type now(LLDeadmanTimer::getNow());
-		F64 real_start(u64_time_to_float(now));
-		timer.start(0);
-
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		ensure_equals("WCM t9 - 5.0 horizon timer has not timed out after 10 1-second bell rings",
-					  timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), false);
-		F64 last_good_ring(u64_time_to_float(now));
-
-		// Jump forward and expire
-		now += float_time_to_u64(10.0);
-		ensure_equals("WCM t9 - 5.0 horizon timer expires on 10-second jump",
-					  timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), true);
-		ensure_approximately_equals("WCM t9 - started matches start() time", started, real_start, 4);
-		ensure_approximately_equals("WCM t9 - stopped matches last ringBell() time", stopped, last_good_ring, 4);
-		ensure_equals("WCM t9 - 10 good ringBell()s", count, U64L(10));
-		ensure_equals("WCM t9 - single read only", timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), false);
-	}
+    {
+        // Without cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8));
+        LLDeadmanTimer timer(5.0, false);
+
+        LLDeadmanTimer::time_type now(LLDeadmanTimer::getNow());
+        F64 real_start(u64_time_to_float(now));
+        timer.start(0);
+
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        ensure_equals("WOCM t9 - 5.0 horizon timer has not timed out after 10 1-second bell rings",
+                      timer.isExpired(now, started, stopped, count), false);
+        F64 last_good_ring(u64_time_to_float(now));
+
+        // Jump forward and expire
+        now += float_time_to_u64(10.0);
+        ensure_equals("WOCM t9 - 5.0 horizon timer expires on 10-second jump",
+                      timer.isExpired(now, started, stopped, count), true);
+        ensure_approximately_equals("WOCM t9 - started matches start() time", started, real_start, 4);
+        ensure_approximately_equals("WOCM t9 - stopped matches last ringBell() time", stopped, last_good_ring, 4);
+        ensure_equals("WOCM t9 - 10 good ringBell()s", count, U64L(10));
+        ensure_equals("WOCM t9 - single read only", timer.isExpired(now, started, stopped, count), false);
+    }
+    {
+        // With cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
+        LLDeadmanTimer timer(5.0, true);
+
+        LLDeadmanTimer::time_type now(LLDeadmanTimer::getNow());
+        F64 real_start(u64_time_to_float(now));
+        timer.start(0);
+
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        ensure_equals("WCM t9 - 5.0 horizon timer has not timed out after 10 1-second bell rings",
+                      timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), false);
+        F64 last_good_ring(u64_time_to_float(now));
+
+        // Jump forward and expire
+        now += float_time_to_u64(10.0);
+        ensure_equals("WCM t9 - 5.0 horizon timer expires on 10-second jump",
+                      timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), true);
+        ensure_approximately_equals("WCM t9 - started matches start() time", started, real_start, 4);
+        ensure_approximately_equals("WCM t9 - stopped matches last ringBell() time", stopped, last_good_ring, 4);
+        ensure_equals("WCM t9 - 10 good ringBell()s", count, U64L(10));
+        ensure_equals("WCM t9 - single read only", timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), false);
+    }
 }
 
 
@@ -462,165 +462,165 @@ void deadmantimer_object_t::test<9>()
 template<> template<>
 void deadmantimer_object_t::test<10>()
 {
-	{
-		// Without cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8));
-		LLDeadmanTimer timer(5.0, false);
-
-		LLDeadmanTimer::time_type now(LLDeadmanTimer::getNow());
-		F64 real_start(u64_time_to_float(now));
-		timer.start(0);
-
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		ensure_equals("WOCM t10 - 5.0 horizon timer has not timed out after 10 1-second bell rings",
-					  timer.isExpired(now, started, stopped, count), false);
-		F64 last_good_ring(u64_time_to_float(now));
-
-		// Jump forward and expire
-		now += float_time_to_u64(10.0);
-		ensure_equals("WOCM t10 - 5.0 horizon timer expires on 10-second jump",
-					  timer.isExpired(now, started, stopped, count), true);
-		ensure_approximately_equals("WOCM t10 - started matches start() time", started, real_start, 4);
-		ensure_approximately_equals("WOCM t10 - stopped matches last ringBell() time", stopped, last_good_ring, 4);
-		ensure_equals("WOCM t10 - 10 good ringBell()s", count, U64L(10));
-		ensure_equals("WOCM t10 - single read only", timer.isExpired(now, started, stopped, count), false);
-		
-		// Jump forward and restart
-		now += float_time_to_u64(1.0);
-		real_start = u64_time_to_float(now);
-		timer.start(now);
-		
-		// Run a modified bell ring sequence
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		ensure_equals("WOCM t10 - 5.0 horizon timer has not timed out after 8 1-second bell rings",
-					  timer.isExpired(now, started, stopped, count), false);
-		last_good_ring = u64_time_to_float(now);
-
-		// Jump forward and expire
-		now += float_time_to_u64(10.0);
-		ensure_equals("WOCM t10 - 5.0 horizon timer expires on 8-second jump",
-					  timer.isExpired(now, started, stopped, count), true);
-		ensure_approximately_equals("WOCM t10 - 2nd started matches start() time", started, real_start, 4);
-		ensure_approximately_equals("WOCM t10 - 2nd stopped matches last ringBell() time", stopped, last_good_ring, 4);
-		ensure_equals("WOCM t10 - 8 good ringBell()s", count, U64L(8));
-		ensure_equals("WOCM t10 - single read only - 2nd start",
-					  timer.isExpired(now, started, stopped, count), false);
-	}
-	{
-		// With cpu metrics
-		F64 started(42.0), stopped(97.0);
-		U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
-
-		LLDeadmanTimer timer(5.0, true);
-
-		LLDeadmanTimer::time_type now(LLDeadmanTimer::getNow());
-		F64 real_start(u64_time_to_float(now));
-		timer.start(0);
-
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		ensure_equals("WCM t10 - 5.0 horizon timer has not timed out after 10 1-second bell rings",
-					  timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), false);
-		F64 last_good_ring(u64_time_to_float(now));
-
-		// Jump forward and expire
-		now += float_time_to_u64(10.0);
-		ensure_equals("WCM t10 - 5.0 horizon timer expires on 10-second jump",
-					  timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), true);
-		ensure_approximately_equals("WCM t10 - started matches start() time", started, real_start, 4);
-		ensure_approximately_equals("WCM t10 - stopped matches last ringBell() time", stopped, last_good_ring, 4);
-		ensure_equals("WCM t10 - 10 good ringBell()s", count, U64L(10));
-		ensure_equals("WCM t10 - single read only", timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), false);
-		
-		// Jump forward and restart
-		now += float_time_to_u64(1.0);
-		real_start = u64_time_to_float(now);
-		timer.start(now);
-		
-		// Run a modified bell ring sequence
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		now += float_time_to_u64(1.0);
-		timer.ringBell(now, 1);
-		ensure_equals("WCM t10 - 5.0 horizon timer has not timed out after 8 1-second bell rings",
-					  timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), false);
-		last_good_ring = u64_time_to_float(now);
-
-		// Jump forward and expire
-		now += float_time_to_u64(10.0);
-		ensure_equals("WCM t10 - 5.0 horizon timer expires on 8-second jump",
-					  timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), true);
-		ensure_approximately_equals("WCM t10 - 2nd started matches start() time", started, real_start, 4);
-		ensure_approximately_equals("WCM t10 - 2nd stopped matches last ringBell() time", stopped, last_good_ring, 4);
-		ensure_equals("WCM t10 - 8 good ringBell()s", count, U64L(8));
-		ensure_equals("WCM t10 - single read only - 2nd start",
-					  timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), false);
-	}
+    {
+        // Without cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8));
+        LLDeadmanTimer timer(5.0, false);
+
+        LLDeadmanTimer::time_type now(LLDeadmanTimer::getNow());
+        F64 real_start(u64_time_to_float(now));
+        timer.start(0);
+
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        ensure_equals("WOCM t10 - 5.0 horizon timer has not timed out after 10 1-second bell rings",
+                      timer.isExpired(now, started, stopped, count), false);
+        F64 last_good_ring(u64_time_to_float(now));
+
+        // Jump forward and expire
+        now += float_time_to_u64(10.0);
+        ensure_equals("WOCM t10 - 5.0 horizon timer expires on 10-second jump",
+                      timer.isExpired(now, started, stopped, count), true);
+        ensure_approximately_equals("WOCM t10 - started matches start() time", started, real_start, 4);
+        ensure_approximately_equals("WOCM t10 - stopped matches last ringBell() time", stopped, last_good_ring, 4);
+        ensure_equals("WOCM t10 - 10 good ringBell()s", count, U64L(10));
+        ensure_equals("WOCM t10 - single read only", timer.isExpired(now, started, stopped, count), false);
+
+        // Jump forward and restart
+        now += float_time_to_u64(1.0);
+        real_start = u64_time_to_float(now);
+        timer.start(now);
+
+        // Run a modified bell ring sequence
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        ensure_equals("WOCM t10 - 5.0 horizon timer has not timed out after 8 1-second bell rings",
+                      timer.isExpired(now, started, stopped, count), false);
+        last_good_ring = u64_time_to_float(now);
+
+        // Jump forward and expire
+        now += float_time_to_u64(10.0);
+        ensure_equals("WOCM t10 - 5.0 horizon timer expires on 8-second jump",
+                      timer.isExpired(now, started, stopped, count), true);
+        ensure_approximately_equals("WOCM t10 - 2nd started matches start() time", started, real_start, 4);
+        ensure_approximately_equals("WOCM t10 - 2nd stopped matches last ringBell() time", stopped, last_good_ring, 4);
+        ensure_equals("WOCM t10 - 8 good ringBell()s", count, U64L(8));
+        ensure_equals("WOCM t10 - single read only - 2nd start",
+                      timer.isExpired(now, started, stopped, count), false);
+    }
+    {
+        // With cpu metrics
+        F64 started(42.0), stopped(97.0);
+        U64 count(U64L(8)), user_cpu(29000), sys_cpu(57000);
+
+        LLDeadmanTimer timer(5.0, true);
+
+        LLDeadmanTimer::time_type now(LLDeadmanTimer::getNow());
+        F64 real_start(u64_time_to_float(now));
+        timer.start(0);
+
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        ensure_equals("WCM t10 - 5.0 horizon timer has not timed out after 10 1-second bell rings",
+                      timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), false);
+        F64 last_good_ring(u64_time_to_float(now));
+
+        // Jump forward and expire
+        now += float_time_to_u64(10.0);
+        ensure_equals("WCM t10 - 5.0 horizon timer expires on 10-second jump",
+                      timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), true);
+        ensure_approximately_equals("WCM t10 - started matches start() time", started, real_start, 4);
+        ensure_approximately_equals("WCM t10 - stopped matches last ringBell() time", stopped, last_good_ring, 4);
+        ensure_equals("WCM t10 - 10 good ringBell()s", count, U64L(10));
+        ensure_equals("WCM t10 - single read only", timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), false);
+
+        // Jump forward and restart
+        now += float_time_to_u64(1.0);
+        real_start = u64_time_to_float(now);
+        timer.start(now);
+
+        // Run a modified bell ring sequence
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        now += float_time_to_u64(1.0);
+        timer.ringBell(now, 1);
+        ensure_equals("WCM t10 - 5.0 horizon timer has not timed out after 8 1-second bell rings",
+                      timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), false);
+        last_good_ring = u64_time_to_float(now);
+
+        // Jump forward and expire
+        now += float_time_to_u64(10.0);
+        ensure_equals("WCM t10 - 5.0 horizon timer expires on 8-second jump",
+                      timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), true);
+        ensure_approximately_equals("WCM t10 - 2nd started matches start() time", started, real_start, 4);
+        ensure_approximately_equals("WCM t10 - 2nd stopped matches last ringBell() time", stopped, last_good_ring, 4);
+        ensure_equals("WCM t10 - 8 good ringBell()s", count, U64L(8));
+        ensure_equals("WCM t10 - single read only - 2nd start",
+                      timer.isExpired(now, started, stopped, count, user_cpu, sys_cpu), false);
+    }
 }
 
 
diff --git a/indra/llcommon/tests/lldependencies_test.cpp b/indra/llcommon/tests/lldependencies_test.cpp
index b5e189a465..84eb41b5fe 100644
--- a/indra/llcommon/tests/lldependencies_test.cpp
+++ b/indra/llcommon/tests/lldependencies_test.cpp
@@ -3,25 +3,25 @@
  * @author Nat Goodspeed
  * @date   2008-09-17
  * @brief  Test of lldependencies.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$
  */
diff --git a/indra/llcommon/tests/llerror_test.cpp b/indra/llcommon/tests/llerror_test.cpp
index 148c18aabe..3ec429530c 100644
--- a/indra/llcommon/tests/llerror_test.cpp
+++ b/indra/llcommon/tests/llerror_test.cpp
@@ -47,7 +47,7 @@ enum LogFieldIndex
     MSG_FIELD
 };
 
-static const char* FieldName[] = 
+static const char* FieldName[] =
 {
     "TIME",
     "LEVEL",
@@ -62,15 +62,15 @@ namespace
 #ifdef __clang__
 #   pragma clang diagnostic ignored "-Wunused-function"
 #endif
-	void test_that_error_h_includes_enough_things_to_compile_a_message()
-	{
-		LL_INFOS() << "!" << LL_ENDL;
-	}
+    void test_that_error_h_includes_enough_things_to_compile_a_message()
+    {
+        LL_INFOS() << "!" << LL_ENDL;
+    }
 }
 
 namespace
 {
-	static bool fatalWasCalled = false;
+    static bool fatalWasCalled = false;
     struct FatalWasCalled: public std::runtime_error
     {
         FatalWasCalled(const std::string& what): std::runtime_error(what) {}
@@ -96,95 +96,95 @@ namespace
 
 namespace tut
 {
-	class TestRecorder : public LLError::Recorder
-	{
-	public:
-		TestRecorder()
-			{
-				showTime(false);
-			}
-		virtual ~TestRecorder()
-			{}
-
-		virtual void recordMessage(LLError::ELevel level,
-						   const std::string& message)
-		{
-			mMessages.push_back(message);
-		}
-
-		int countMessages()			{ return (int) mMessages.size(); }
-		void clearMessages()		{ mMessages.clear(); }
-
-		std::string message(int n)
-		{
-			std::ostringstream test_name;
-			test_name << "testing message " << n << ", not enough messages";
-
-			tut::ensure(test_name.str(), n < countMessages());
-			return mMessages[n];
-		}
-
-	private:
-		typedef std::vector<std::string> MessageVector;
-		MessageVector mMessages;
-	};
-
-	struct ErrorTestData
-	{
-		LLError::RecorderPtr mRecorder;
-		LLError::SettingsStoragePtr mPriorErrorSettings;
-
-		ErrorTestData():
-			mRecorder(new TestRecorder())
-		{
-			fatalWasCalled = false;
-
-			mPriorErrorSettings = LLError::saveAndResetSettings();
-			LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
-			LLError::setFatalFunction(fatalCall);
-			LLError::addRecorder(mRecorder);
-		}
-
-		~ErrorTestData()
-		{
-			LLError::removeRecorder(mRecorder);
-			LLError::restoreSettings(mPriorErrorSettings);
-		}
-
-		int countMessages()
-		{
-			return boost::dynamic_pointer_cast<TestRecorder>(mRecorder)->countMessages();
-		}
-
-		void clearMessages()
-		{
-			boost::dynamic_pointer_cast<TestRecorder>(mRecorder)->clearMessages();
-		}
-
-		void setWantsTime(bool t)
+    class TestRecorder : public LLError::Recorder
+    {
+    public:
+        TestRecorder()
             {
-                boost::dynamic_pointer_cast<TestRecorder>(mRecorder)->showTime(t);
+                showTime(false);
             }
+        virtual ~TestRecorder()
+            {}
+
+        virtual void recordMessage(LLError::ELevel level,
+                           const std::string& message)
+        {
+            mMessages.push_back(message);
+        }
+
+        int countMessages()         { return (int) mMessages.size(); }
+        void clearMessages()        { mMessages.clear(); }
+
+        std::string message(int n)
+        {
+            std::ostringstream test_name;
+            test_name << "testing message " << n << ", not enough messages";
+
+            tut::ensure(test_name.str(), n < countMessages());
+            return mMessages[n];
+        }
+
+    private:
+        typedef std::vector<std::string> MessageVector;
+        MessageVector mMessages;
+    };
 
-		void setWantsMultiline(bool t)
+    struct ErrorTestData
+    {
+        LLError::RecorderPtr mRecorder;
+        LLError::SettingsStoragePtr mPriorErrorSettings;
+
+        ErrorTestData():
+            mRecorder(new TestRecorder())
+        {
+            fatalWasCalled = false;
+
+            mPriorErrorSettings = LLError::saveAndResetSettings();
+            LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
+            LLError::setFatalFunction(fatalCall);
+            LLError::addRecorder(mRecorder);
+        }
+
+        ~ErrorTestData()
+        {
+            LLError::removeRecorder(mRecorder);
+            LLError::restoreSettings(mPriorErrorSettings);
+        }
+
+        int countMessages()
+        {
+            return std::dynamic_pointer_cast<TestRecorder>(mRecorder)->countMessages();
+        }
+
+        void clearMessages()
+        {
+            std::dynamic_pointer_cast<TestRecorder>(mRecorder)->clearMessages();
+        }
+
+        void setWantsTime(bool t)
             {
-                boost::dynamic_pointer_cast<TestRecorder>(mRecorder)->showMultiline(t);
+                std::dynamic_pointer_cast<TestRecorder>(mRecorder)->showTime(t);
             }
 
-		std::string message(int n)
-		{
-			return boost::dynamic_pointer_cast<TestRecorder>(mRecorder)->message(n);
-		}
+        void setWantsMultiline(bool t)
+            {
+                std::dynamic_pointer_cast<TestRecorder>(mRecorder)->showMultiline(t);
+            }
 
-		void ensure_message_count(int expectedCount)
-		{
-			ensure_equals("message count", countMessages(), expectedCount);
-		}
+        std::string message(int n)
+        {
+            return std::dynamic_pointer_cast<TestRecorder>(mRecorder)->message(n);
+        }
+
+        void ensure_message_count(int expectedCount)
+        {
+            ensure_equals("message count", countMessages(), expectedCount);
+        }
 
         std::string message_field(int msgnum, LogFieldIndex fieldnum)
         {
             std::ostringstream test_name;
-            test_name << "testing message " << msgnum << ", not enough messages";            
+            test_name << "testing message " << msgnum << ", not enough messages";
             tut::ensure(test_name.str(), msgnum < countMessages());
 
             std::string msg(message(msgnum));
@@ -204,7 +204,7 @@ namespace tut
                         on_field++;
                     }
                     // except function, which may have embedded spaces so ends with " : "
-                    else if (   ( on_field == FUNCTION_FIELD ) 
+                    else if (   ( on_field == FUNCTION_FIELD )
                              && ( ':' == msg[scan+1] && ' ' == msg[scan+2] )
                              )
                     {
@@ -220,9 +220,9 @@ namespace tut
             {
                 fieldlen = msg.find(' ', start_field) - start_field;
             }
-            else if ( fieldnum == FUNCTION_FIELD ) 
+            else if ( fieldnum == FUNCTION_FIELD )
             {
-                fieldlen = msg.find(" : ", start_field) - start_field;                
+                fieldlen = msg.find(" : ", start_field) - start_field;
             }
             else if ( MSG_FIELD == fieldnum ) // no delimiter, just everything to the end
             {
@@ -231,8 +231,8 @@ namespace tut
 
             return msg.substr(start_field, fieldlen);
         }
-        
-		void ensure_message_field_equals(int msgnum, LogFieldIndex fieldnum, const std::string& expectedText)
+
+        void ensure_message_field_equals(int msgnum, LogFieldIndex fieldnum, const std::string& expectedText)
          {
              std::ostringstream test_name;
              test_name << "testing message " << msgnum << " field " << FieldName[fieldnum] << "\n  message: \"" << message(msgnum) << "\"\n  ";
@@ -240,105 +240,105 @@ namespace tut
              ensure_equals(test_name.str(), message_field(msgnum, fieldnum), expectedText);
          }
 
-		void ensure_message_does_not_contain(int n, const std::string& expectedText)
-		{
-			std::ostringstream test_name;
-			test_name << "testing message " << n;
+        void ensure_message_does_not_contain(int n, const std::string& expectedText)
+        {
+            std::ostringstream test_name;
+            test_name << "testing message " << n;
 
-			ensure_does_not_contain(test_name.str(), message(n), expectedText);
-		}
-	};
+            ensure_does_not_contain(test_name.str(), message(n), expectedText);
+        }
+    };
 
-	typedef test_group<ErrorTestData>	ErrorTestGroup;
-	typedef ErrorTestGroup::object		ErrorTestObject;
+    typedef test_group<ErrorTestData>   ErrorTestGroup;
+    typedef ErrorTestGroup::object      ErrorTestObject;
 
-	ErrorTestGroup errorTestGroup("error");
+    ErrorTestGroup errorTestGroup("error");
 
-	template<> template<>
-	void ErrorTestObject::test<1>()
-		// basic test of output
-	{
-		LL_INFOS() << "test" << LL_ENDL;
-		LL_INFOS() << "bob" << LL_ENDL;
+    template<> template<>
+    void ErrorTestObject::test<1>()
+        // basic test of output
+    {
+        LL_INFOS() << "test" << LL_ENDL;
+        LL_INFOS() << "bob" << LL_ENDL;
 
-		ensure_message_field_equals(0, MSG_FIELD, "test");
-		ensure_message_field_equals(1, MSG_FIELD, "bob");
-	}
+        ensure_message_field_equals(0, MSG_FIELD, "test");
+        ensure_message_field_equals(1, MSG_FIELD, "bob");
+    }
 }
 
 namespace
 {
-	void writeSome()
-	{
-		LL_DEBUGS("WriteTag","AnotherTag") << "one" << LL_ENDL;
-		LL_INFOS("WriteTag") << "two" << LL_ENDL;
-		LL_WARNS("WriteTag") << "three" << LL_ENDL;
-		CATCH(LL_ERRS("WriteTag"), "four");
-	}
+    void writeSome()
+    {
+        LL_DEBUGS("WriteTag","AnotherTag") << "one" << LL_ENDL;
+        LL_INFOS("WriteTag") << "two" << LL_ENDL;
+        LL_WARNS("WriteTag") << "three" << LL_ENDL;
+        CATCH(LL_ERRS("WriteTag"), "four");
+    }
 };
 
 namespace tut
 {
-	template<> template<>
-	void ErrorTestObject::test<2>()
-		// messages are filtered based on default level
-	{
-		LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
-		writeSome();
-		ensure_message_field_equals(0, MSG_FIELD, "one");
-		ensure_message_field_equals(0, LEVEL_FIELD, "DEBUG");
-		ensure_message_field_equals(0, TAGS_FIELD, "#WriteTag#AnotherTag#");
-		ensure_message_field_equals(1, MSG_FIELD, "two");
-		ensure_message_field_equals(1, LEVEL_FIELD, "INFO");
-		ensure_message_field_equals(1, TAGS_FIELD, "#WriteTag#");
-		ensure_message_field_equals(2, MSG_FIELD, "three");
-		ensure_message_field_equals(2, LEVEL_FIELD, "WARNING");
-		ensure_message_field_equals(2, TAGS_FIELD, "#WriteTag#");
-		ensure_message_field_equals(3, MSG_FIELD, "four");
-		ensure_message_field_equals(3, LEVEL_FIELD, "ERROR");
-		ensure_message_field_equals(3, TAGS_FIELD, "#WriteTag#");
-		ensure_message_count(4);
-
-		LLError::setDefaultLevel(LLError::LEVEL_INFO);
-		writeSome();
-		ensure_message_field_equals(4, MSG_FIELD, "two");
-		ensure_message_field_equals(5, MSG_FIELD, "three");
-		ensure_message_field_equals(6, MSG_FIELD, "four");
-		ensure_message_count(7);
-
-		LLError::setDefaultLevel(LLError::LEVEL_WARN);
-		writeSome();
-		ensure_message_field_equals(7, MSG_FIELD, "three");
-		ensure_message_field_equals(8, MSG_FIELD, "four");
-		ensure_message_count(9);
-
-		LLError::setDefaultLevel(LLError::LEVEL_ERROR);
-		writeSome();
-		ensure_message_field_equals(9, MSG_FIELD, "four");
-		ensure_message_count(10);
-
-		LLError::setDefaultLevel(LLError::LEVEL_NONE);
-		writeSome();
-		ensure_message_count(10);
-	}
-
-	template<> template<>
-	void ErrorTestObject::test<3>()
-		// error type string in output
-	{
-		writeSome();
-		ensure_message_field_equals(0, LEVEL_FIELD, "DEBUG");
-		ensure_message_field_equals(1, LEVEL_FIELD, "INFO");
-		ensure_message_field_equals(2, LEVEL_FIELD, "WARNING");
-		ensure_message_field_equals(3, LEVEL_FIELD, "ERROR");
-		ensure_message_count(4);
-	}
-
-	template<> template<>
-	void ErrorTestObject::test<4>()
-		// file abbreviation
-	{
-		std::string prev, abbreviateFile = __FILE__;
+    template<> template<>
+    void ErrorTestObject::test<2>()
+        // messages are filtered based on default level
+    {
+        LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
+        writeSome();
+        ensure_message_field_equals(0, MSG_FIELD, "one");
+        ensure_message_field_equals(0, LEVEL_FIELD, "DEBUG");
+        ensure_message_field_equals(0, TAGS_FIELD, "#WriteTag#AnotherTag#");
+        ensure_message_field_equals(1, MSG_FIELD, "two");
+        ensure_message_field_equals(1, LEVEL_FIELD, "INFO");
+        ensure_message_field_equals(1, TAGS_FIELD, "#WriteTag#");
+        ensure_message_field_equals(2, MSG_FIELD, "three");
+        ensure_message_field_equals(2, LEVEL_FIELD, "WARNING");
+        ensure_message_field_equals(2, TAGS_FIELD, "#WriteTag#");
+        ensure_message_field_equals(3, MSG_FIELD, "four");
+        ensure_message_field_equals(3, LEVEL_FIELD, "ERROR");
+        ensure_message_field_equals(3, TAGS_FIELD, "#WriteTag#");
+        ensure_message_count(4);
+
+        LLError::setDefaultLevel(LLError::LEVEL_INFO);
+        writeSome();
+        ensure_message_field_equals(4, MSG_FIELD, "two");
+        ensure_message_field_equals(5, MSG_FIELD, "three");
+        ensure_message_field_equals(6, MSG_FIELD, "four");
+        ensure_message_count(7);
+
+        LLError::setDefaultLevel(LLError::LEVEL_WARN);
+        writeSome();
+        ensure_message_field_equals(7, MSG_FIELD, "three");
+        ensure_message_field_equals(8, MSG_FIELD, "four");
+        ensure_message_count(9);
+
+        LLError::setDefaultLevel(LLError::LEVEL_ERROR);
+        writeSome();
+        ensure_message_field_equals(9, MSG_FIELD, "four");
+        ensure_message_count(10);
+
+        LLError::setDefaultLevel(LLError::LEVEL_NONE);
+        writeSome();
+        ensure_message_count(10);
+    }
+
+    template<> template<>
+    void ErrorTestObject::test<3>()
+        // error type string in output
+    {
+        writeSome();
+        ensure_message_field_equals(0, LEVEL_FIELD, "DEBUG");
+        ensure_message_field_equals(1, LEVEL_FIELD, "INFO");
+        ensure_message_field_equals(2, LEVEL_FIELD, "WARNING");
+        ensure_message_field_equals(3, LEVEL_FIELD, "ERROR");
+        ensure_message_count(4);
+    }
+
+    template<> template<>
+    void ErrorTestObject::test<4>()
+        // file abbreviation
+    {
+        std::string prev, abbreviateFile = __FILE__;
         do
         {
             prev = abbreviateFile;
@@ -354,169 +354,169 @@ namespace tut
             // argument unchanged, THEN check.
         } while (abbreviateFile != prev);
 
-		ensure_ends_with("file name abbreviation",
-			abbreviateFile,
-			"llcommon/tests/llerror_test.cpp"
-			);
-		ensure_does_not_contain("file name abbreviation",
-			abbreviateFile, "indra");
+        ensure_ends_with("file name abbreviation",
+            abbreviateFile,
+            "llcommon/tests/llerror_test.cpp"
+            );
+        ensure_does_not_contain("file name abbreviation",
+            abbreviateFile, "indra");
 
-		std::string someFile =
+        std::string someFile =
 #if LL_WINDOWS
-			"C:/amy/bob/cam.cpp"
+            "C:/amy/bob/cam.cpp"
 #else
-			"/amy/bob/cam.cpp"
+            "/amy/bob/cam.cpp"
 #endif
-			;
-		std::string someAbbreviation = LLError::abbreviateFile(someFile);
+            ;
+        std::string someAbbreviation = LLError::abbreviateFile(someFile);
 
-		ensure_equals("non-indra file abbreviation",
-			someAbbreviation, someFile);
-	}
+        ensure_equals("non-indra file abbreviation",
+            someAbbreviation, someFile);
+    }
 }
 
 namespace
 {
-	std::string locationString(int line)
-	{
-		std::ostringstream location;
-		location << LLError::abbreviateFile(__FILE__)
-				 << "(" << line << ")";
-
-		return location.str();
-	}
-
-	std::string writeReturningLocation()
-	{
-		LL_INFOS() << "apple" << LL_ENDL;	int this_line = __LINE__;
-		return locationString(this_line);
-	}
-
-	void writeReturningLocationAndFunction(std::string& location, std::string& function)
-	{
-		LL_INFOS() << "apple" << LL_ENDL;	int this_line = __LINE__;
-		location = locationString(this_line);
-		function = __FUNCTION__;
-	}
-
-	std::string errorReturningLocation()
-	{
-		int this_line = __LINE__;	CATCH(LL_ERRS(), "die");
-		return locationString(this_line);
-	}
+    std::string locationString(int line)
+    {
+        std::ostringstream location;
+        location << LLError::abbreviateFile(__FILE__)
+                 << "(" << line << ")";
+
+        return location.str();
+    }
+
+    std::string writeReturningLocation()
+    {
+        LL_INFOS() << "apple" << LL_ENDL;   int this_line = __LINE__;
+        return locationString(this_line);
+    }
+
+    void writeReturningLocationAndFunction(std::string& location, std::string& function)
+    {
+        LL_INFOS() << "apple" << LL_ENDL;   int this_line = __LINE__;
+        location = locationString(this_line);
+        function = __FUNCTION__;
+    }
+
+    std::string errorReturningLocation()
+    {
+        int this_line = __LINE__;   CATCH(LL_ERRS(), "die");
+        return locationString(this_line);
+    }
 }
 
 /* The following helper functions and class members all log a simple message
-	from some particular function scope.  Each function takes a bool argument
-	that indicates if it should log its own name or not (in the manner that
-	existing log messages often do.)  The functions all return their C++
-	name so that test can be substantial mechanized.
+    from some particular function scope.  Each function takes a bool argument
+    that indicates if it should log its own name or not (in the manner that
+    existing log messages often do.)  The functions all return their C++
+    name so that test can be substantial mechanized.
  */
 
 std::string logFromGlobal(bool id)
 {
-	LL_INFOS() << (id ? "logFromGlobal: " : "") << "hi" << LL_ENDL;
-	return "logFromGlobal";
+    LL_INFOS() << (id ? "logFromGlobal: " : "") << "hi" << LL_ENDL;
+    return "logFromGlobal";
 }
 
 static std::string logFromStatic(bool id)
 {
-	LL_INFOS() << (id ? "logFromStatic: " : "") << "hi" << LL_ENDL;
-	return "logFromStatic";
+    LL_INFOS() << (id ? "logFromStatic: " : "") << "hi" << LL_ENDL;
+    return "logFromStatic";
 }
 
 namespace
 {
-	std::string logFromAnon(bool id)
-	{
-		LL_INFOS() << (id ? "logFromAnon: " : "") << "hi" << LL_ENDL;
-		return "logFromAnon";
-	}
+    std::string logFromAnon(bool id)
+    {
+        LL_INFOS() << (id ? "logFromAnon: " : "") << "hi" << LL_ENDL;
+        return "logFromAnon";
+    }
 }
 
 namespace Foo {
-	std::string logFromNamespace(bool id)
-	{
-		LL_INFOS() << (id ? "Foo::logFromNamespace: " : "") << "hi" << LL_ENDL;
-		//return "Foo::logFromNamespace";
-			// there is no standard way to get the namespace name, hence
-			// we won't be testing for it
-		return "logFromNamespace";
-	}
+    std::string logFromNamespace(bool id)
+    {
+        LL_INFOS() << (id ? "Foo::logFromNamespace: " : "") << "hi" << LL_ENDL;
+        //return "Foo::logFromNamespace";
+            // there is no standard way to get the namespace name, hence
+            // we won't be testing for it
+        return "logFromNamespace";
+    }
 }
 
 namespace
 {
-	class ClassWithNoLogType {
-	public:
-		std::string logFromMember(bool id)
-		{
-			LL_INFOS() << (id ? "ClassWithNoLogType::logFromMember: " : "") << "hi" << LL_ENDL;
-			return "ClassWithNoLogType::logFromMember";
-		}
-		static std::string logFromStatic(bool id)
-		{
-			LL_INFOS() << (id ? "ClassWithNoLogType::logFromStatic: " : "") << "hi" << LL_ENDL;
-			return "ClassWithNoLogType::logFromStatic";
-		}
-	};
-
-	class ClassWithLogType {
-		LOG_CLASS(ClassWithLogType);
-	public:
-		std::string logFromMember(bool id)
-		{
-			LL_INFOS() << (id ? "ClassWithLogType::logFromMember: " : "") << "hi" << LL_ENDL;
-			return "ClassWithLogType::logFromMember";
-		}
-		static std::string logFromStatic(bool id)
-		{
-			LL_INFOS() << (id ? "ClassWithLogType::logFromStatic: " : "") << "hi" << LL_ENDL;
-			return "ClassWithLogType::logFromStatic";
-		}
-	};
-
-	std::string logFromNamespace(bool id) { return Foo::logFromNamespace(id); }
-	std::string logFromClassWithLogTypeMember(bool id) { ClassWithLogType c; return c.logFromMember(id); }
-	std::string logFromClassWithLogTypeStatic(bool id) { return ClassWithLogType::logFromStatic(id); }
-
-	void ensure_has(const std::string& message,
-		const std::string& actual, const std::string& expected)
-	{
-		std::string::size_type n1 = actual.find(expected);
-		if (n1 == std::string::npos)
-		{
-			std::stringstream ss;
-			ss << message << ": " << "expected to find a copy of '" << expected
-			   << "' in actual '" << actual << "'";
-			throw tut::failure(ss.str().c_str());
-		}
-	}
-
-	typedef std::string (*LogFromFunction)(bool);
-	void testLogName(LLError::RecorderPtr recorder, LogFromFunction f,
-		const std::string& class_name = "")
-	{
-		boost::dynamic_pointer_cast<tut::TestRecorder>(recorder)->clearMessages();
-		std::string name = f(false);
-		f(true);
-
-		std::string messageWithoutName = boost::dynamic_pointer_cast<tut::TestRecorder>(recorder)->message(0);
-		std::string messageWithName = boost::dynamic_pointer_cast<tut::TestRecorder>(recorder)->message(1);
-
-		ensure_has(name + " logged without name",
-			messageWithoutName, name);
-		ensure_has(name + " logged with name",
-			messageWithName, name);
-
-		if (!class_name.empty())
-		{
-			ensure_has(name + "logged without name",
-				messageWithoutName, class_name);
-			ensure_has(name + "logged with name",
-				messageWithName, class_name);
-		}
-	}
+    class ClassWithNoLogType {
+    public:
+        std::string logFromMember(bool id)
+        {
+            LL_INFOS() << (id ? "ClassWithNoLogType::logFromMember: " : "") << "hi" << LL_ENDL;
+            return "ClassWithNoLogType::logFromMember";
+        }
+        static std::string logFromStatic(bool id)
+        {
+            LL_INFOS() << (id ? "ClassWithNoLogType::logFromStatic: " : "") << "hi" << LL_ENDL;
+            return "ClassWithNoLogType::logFromStatic";
+        }
+    };
+
+    class ClassWithLogType {
+        LOG_CLASS(ClassWithLogType);
+    public:
+        std::string logFromMember(bool id)
+        {
+            LL_INFOS() << (id ? "ClassWithLogType::logFromMember: " : "") << "hi" << LL_ENDL;
+            return "ClassWithLogType::logFromMember";
+        }
+        static std::string logFromStatic(bool id)
+        {
+            LL_INFOS() << (id ? "ClassWithLogType::logFromStatic: " : "") << "hi" << LL_ENDL;
+            return "ClassWithLogType::logFromStatic";
+        }
+    };
+
+    std::string logFromNamespace(bool id) { return Foo::logFromNamespace(id); }
+    std::string logFromClassWithLogTypeMember(bool id) { ClassWithLogType c; return c.logFromMember(id); }
+    std::string logFromClassWithLogTypeStatic(bool id) { return ClassWithLogType::logFromStatic(id); }
+
+    void ensure_has(const std::string& message,
+        const std::string& actual, const std::string& expected)
+    {
+        std::string::size_type n1 = actual.find(expected);
+        if (n1 == std::string::npos)
+        {
+            std::stringstream ss;
+            ss << message << ": " << "expected to find a copy of '" << expected
+               << "' in actual '" << actual << "'";
+            throw tut::failure(ss.str().c_str());
+        }
+    }
+
+    typedef std::string (*LogFromFunction)(bool);
+    void testLogName(LLError::RecorderPtr recorder, LogFromFunction f,
+        const std::string& class_name = "")
+    {
+        std::dynamic_pointer_cast<tut::TestRecorder>(recorder)->clearMessages();
+        std::string name = f(false);
+        f(true);
+
+        std::string messageWithoutName = std::dynamic_pointer_cast<tut::TestRecorder>(recorder)->message(0);
+        std::string messageWithName = std::dynamic_pointer_cast<tut::TestRecorder>(recorder)->message(1);
+
+        ensure_has(name + " logged without name",
+            messageWithoutName, name);
+        ensure_has(name + " logged with name",
+            messageWithName, name);
+
+        if (!class_name.empty())
+        {
+            ensure_has(name + "logged without name",
+                messageWithoutName, class_name);
+            ensure_has(name + "logged with name",
+                messageWithName, class_name);
+        }
+    }
 }
 
 namespace
@@ -540,7 +540,7 @@ namespace tut
         // backslash, return, and newline are not escaped with backslashes
     {
         LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
-        setWantsMultiline(true); 
+        setWantsMultiline(true);
         writeMsgNeedsEscaping(); // but should not be now
         ensure_message_field_equals(0, MSG_FIELD, "backslash\\");
         ensure_message_field_equals(1, MSG_FIELD, "newline\nafternewline");
@@ -554,324 +554,324 @@ namespace tut
 
 namespace tut
 {
-	template<> template<>
-		// 	class/function information in output
-	void ErrorTestObject::test<6>()
-	{
-		testLogName(mRecorder, logFromGlobal);
-		testLogName(mRecorder, logFromStatic);
-		testLogName(mRecorder, logFromAnon);
-		testLogName(mRecorder, logFromNamespace);
-		testLogName(mRecorder, logFromClassWithLogTypeMember, "ClassWithLogType");
-		testLogName(mRecorder, logFromClassWithLogTypeStatic, "ClassWithLogType");
-	}
+    template<> template<>
+        //  class/function information in output
+    void ErrorTestObject::test<6>()
+    {
+        testLogName(mRecorder, logFromGlobal);
+        testLogName(mRecorder, logFromStatic);
+        testLogName(mRecorder, logFromAnon);
+        testLogName(mRecorder, logFromNamespace);
+        testLogName(mRecorder, logFromClassWithLogTypeMember, "ClassWithLogType");
+        testLogName(mRecorder, logFromClassWithLogTypeStatic, "ClassWithLogType");
+    }
 }
 
 namespace
 {
-	std::string innerLogger()
-	{
-		LL_INFOS() << "inside" << LL_ENDL;
-		return "moo";
-	}
-
-	std::string outerLogger()
-	{
-		LL_INFOS() << "outside(" << innerLogger() << ")" << LL_ENDL;
-		return "bar";
-	}
-
-	class LogWhileLogging
-	{
-	public:
-		void print(std::ostream& out) const
-		{
-			LL_INFOS() << "logging" << LL_ENDL;
-			out << "baz";
-		}
-	};
-
-	std::ostream& operator<<(std::ostream& out, const LogWhileLogging& l)
-		{ l.print(out); return out; }
-
-	void metaLogger()
-	{
-		LogWhileLogging l;
-		LL_INFOS() << "meta(" << l << ")" << LL_ENDL;
-	}
+    std::string innerLogger()
+    {
+        LL_INFOS() << "inside" << LL_ENDL;
+        return "moo";
+    }
+
+    std::string outerLogger()
+    {
+        LL_INFOS() << "outside(" << innerLogger() << ")" << LL_ENDL;
+        return "bar";
+    }
+
+    class LogWhileLogging
+    {
+    public:
+        void print(std::ostream& out) const
+        {
+            LL_INFOS() << "logging" << LL_ENDL;
+            out << "baz";
+        }
+    };
+
+    std::ostream& operator<<(std::ostream& out, const LogWhileLogging& l)
+        { l.print(out); return out; }
+
+    void metaLogger()
+    {
+        LogWhileLogging l;
+        LL_INFOS() << "meta(" << l << ")" << LL_ENDL;
+    }
 
 }
 
 namespace tut
 {
-	template<> template<>
-		// handle nested logging
-	void ErrorTestObject::test<7>()
-	{
-		outerLogger();
-		ensure_message_field_equals(0, MSG_FIELD, "inside");
-		ensure_message_field_equals(1, MSG_FIELD, "outside(moo)");
-		ensure_message_count(2);
-
-		metaLogger();
-		ensure_message_field_equals(2, MSG_FIELD, "logging");
-		ensure_message_field_equals(3, MSG_FIELD, "meta(baz)");
-		ensure_message_count(4);
-	}
-
-	template<> template<>
-		// special handling of LL_ERRS() calls
-	void ErrorTestObject::test<8>()
-	{
-		std::string location = errorReturningLocation();
-
-		ensure_message_field_equals(0, LOCATION_FIELD, location);
-		ensure_message_field_equals(0, MSG_FIELD, "die");
-		ensure_message_count(1);
-
-		ensure("fatal callback called", fatalWasCalled);
-	}
+    template<> template<>
+        // handle nested logging
+    void ErrorTestObject::test<7>()
+    {
+        outerLogger();
+        ensure_message_field_equals(0, MSG_FIELD, "inside");
+        ensure_message_field_equals(1, MSG_FIELD, "outside(moo)");
+        ensure_message_count(2);
+
+        metaLogger();
+        ensure_message_field_equals(2, MSG_FIELD, "logging");
+        ensure_message_field_equals(3, MSG_FIELD, "meta(baz)");
+        ensure_message_count(4);
+    }
+
+    template<> template<>
+        // special handling of LL_ERRS() calls
+    void ErrorTestObject::test<8>()
+    {
+        std::string location = errorReturningLocation();
+
+        ensure_message_field_equals(0, LOCATION_FIELD, location);
+        ensure_message_field_equals(0, MSG_FIELD, "die");
+        ensure_message_count(1);
+
+        ensure("fatal callback called", fatalWasCalled);
+    }
 }
 
 namespace
 {
-	std::string roswell()
-	{
-		return "1947-07-08T03:04:05Z";
-	}
-
-	void ufoSighting()
-	{
-		LL_INFOS() << "ufo" << LL_ENDL;
-	}
+    std::string roswell()
+    {
+        return "1947-07-08T03:04:05Z";
+    }
+
+    void ufoSighting()
+    {
+        LL_INFOS() << "ufo" << LL_ENDL;
+    }
 }
 
 namespace tut
 {
-	template<> template<>
-		// time in output (for recorders that need it)
-	void ErrorTestObject::test<9>()
-	{
-		LLError::setTimeFunction(roswell);
-
-		setWantsTime(false);
-		ufoSighting();
-		ensure_message_field_equals(0, MSG_FIELD, "ufo");
-		ensure_message_does_not_contain(0, roswell());
-
-		setWantsTime(true);
-		ufoSighting();
-		ensure_message_field_equals(1, MSG_FIELD, "ufo");
-		ensure_message_field_equals(1, TIME_FIELD, roswell());
-	}
-
-	template<> template<>
-		// output order
-	void ErrorTestObject::test<10>()
-	{
-		LLError::setTimeFunction(roswell);
-		setWantsTime(true);
-
-		std::string location,
-					function;
-		writeReturningLocationAndFunction(location, function);
-
-		ensure_equals("order is time level tags location function message",
+    template<> template<>
+        // time in output (for recorders that need it)
+    void ErrorTestObject::test<9>()
+    {
+        LLError::setTimeFunction(roswell);
+
+        setWantsTime(false);
+        ufoSighting();
+        ensure_message_field_equals(0, MSG_FIELD, "ufo");
+        ensure_message_does_not_contain(0, roswell());
+
+        setWantsTime(true);
+        ufoSighting();
+        ensure_message_field_equals(1, MSG_FIELD, "ufo");
+        ensure_message_field_equals(1, TIME_FIELD, roswell());
+    }
+
+    template<> template<>
+        // output order
+    void ErrorTestObject::test<10>()
+    {
+        LLError::setTimeFunction(roswell);
+        setWantsTime(true);
+
+        std::string location,
+                    function;
+        writeReturningLocationAndFunction(location, function);
+
+        ensure_equals("order is time level tags location function message",
                       message(0),
                       roswell() + " INFO " + "# " /* no tag */ + location + " " + function + " : " + "apple");
-	}
+    }
 
-	template<> template<>
-		// multiple recorders
-	void ErrorTestObject::test<11>()
-	{
-		LLError::RecorderPtr altRecorder(new TestRecorder());
-		LLError::addRecorder(altRecorder);
+    template<> template<>
+        // multiple recorders
+    void ErrorTestObject::test<11>()
+    {
+        LLError::RecorderPtr altRecorder(new TestRecorder());
+        LLError::addRecorder(altRecorder);
 
-		LL_INFOS() << "boo" << LL_ENDL;
+        LL_INFOS() << "boo" << LL_ENDL;
 
-		ensure_message_field_equals(0, MSG_FIELD, "boo");
-		ensure_equals("alt recorder count", boost::dynamic_pointer_cast<TestRecorder>(altRecorder)->countMessages(), 1);
-		ensure_contains("alt recorder message 0", boost::dynamic_pointer_cast<TestRecorder>(altRecorder)->message(0), "boo");
+        ensure_message_field_equals(0, MSG_FIELD, "boo");
+        ensure_equals("alt recorder count", std::dynamic_pointer_cast<TestRecorder>(altRecorder)->countMessages(), 1);
+        ensure_contains("alt recorder message 0", std::dynamic_pointer_cast<TestRecorder>(altRecorder)->message(0), "boo");
 
-		LLError::setTimeFunction(roswell);
+        LLError::setTimeFunction(roswell);
 
-		LLError::RecorderPtr anotherRecorder(new TestRecorder());
-		boost::dynamic_pointer_cast<TestRecorder>(anotherRecorder)->showTime(true);
-		LLError::addRecorder(anotherRecorder);
+        LLError::RecorderPtr anotherRecorder(new TestRecorder());
+        std::dynamic_pointer_cast<TestRecorder>(anotherRecorder)->showTime(true);
+        LLError::addRecorder(anotherRecorder);
 
-		LL_INFOS() << "baz" << LL_ENDL;
+        LL_INFOS() << "baz" << LL_ENDL;
 
-		std::string when = roswell();
+        std::string when = roswell();
 
-		ensure_message_does_not_contain(1, when);
-		ensure_equals("alt recorder count", boost::dynamic_pointer_cast<TestRecorder>(altRecorder)->countMessages(), 2);
-		ensure_does_not_contain("alt recorder message 1", boost::dynamic_pointer_cast<TestRecorder>(altRecorder)->message(1), when);
-		ensure_equals("another recorder count", boost::dynamic_pointer_cast<TestRecorder>(anotherRecorder)->countMessages(), 1);
-		ensure_contains("another recorder message 0", boost::dynamic_pointer_cast<TestRecorder>(anotherRecorder)->message(0), when);
+        ensure_message_does_not_contain(1, when);
+        ensure_equals("alt recorder count", std::dynamic_pointer_cast<TestRecorder>(altRecorder)->countMessages(), 2);
+        ensure_does_not_contain("alt recorder message 1", std::dynamic_pointer_cast<TestRecorder>(altRecorder)->message(1), when);
+        ensure_equals("another recorder count", std::dynamic_pointer_cast<TestRecorder>(anotherRecorder)->countMessages(), 1);
+        ensure_contains("another recorder message 0", std::dynamic_pointer_cast<TestRecorder>(anotherRecorder)->message(0), when);
 
-		LLError::removeRecorder(altRecorder);
-		LLError::removeRecorder(anotherRecorder);
-	}
+        LLError::removeRecorder(altRecorder);
+        LLError::removeRecorder(anotherRecorder);
+    }
 }
 
 class TestAlpha
 {
-	LOG_CLASS(TestAlpha);
+    LOG_CLASS(TestAlpha);
 public:
-	static void doDebug()	{ LL_DEBUGS() << "add dice" << LL_ENDL; }
-	static void doInfo()	{ LL_INFOS()  << "any idea" << LL_ENDL; }
-	static void doWarn()	{ LL_WARNS()  << "aim west" << LL_ENDL; }
-	static void doError()	{ CATCH(LL_ERRS(), "ate eels"); }
-	static void doAll() { doDebug(); doInfo(); doWarn(); doError(); }
+    static void doDebug()   { LL_DEBUGS() << "add dice" << LL_ENDL; }
+    static void doInfo()    { LL_INFOS()  << "any idea" << LL_ENDL; }
+    static void doWarn()    { LL_WARNS()  << "aim west" << LL_ENDL; }
+    static void doError()   { CATCH(LL_ERRS(), "ate eels"); }
+    static void doAll() { doDebug(); doInfo(); doWarn(); doError(); }
 };
 
 class TestBeta
 {
-	LOG_CLASS(TestBeta);
+    LOG_CLASS(TestBeta);
 public:
-	static void doDebug()	{ LL_DEBUGS() << "bed down" << LL_ENDL; }
-	static void doInfo()	{ LL_INFOS()  << "buy iron" << LL_ENDL; }
-	static void doWarn()	{ LL_WARNS()  << "bad word" << LL_ENDL; }
-	static void doError()	{ CATCH(LL_ERRS(), "big easy"); }
-	static void doAll() { doDebug(); doInfo(); doWarn(); doError(); }
+    static void doDebug()   { LL_DEBUGS() << "bed down" << LL_ENDL; }
+    static void doInfo()    { LL_INFOS()  << "buy iron" << LL_ENDL; }
+    static void doWarn()    { LL_WARNS()  << "bad word" << LL_ENDL; }
+    static void doError()   { CATCH(LL_ERRS(), "big easy"); }
+    static void doAll() { doDebug(); doInfo(); doWarn(); doError(); }
 };
 
 namespace tut
 {
-	template<> template<>
-		// filtering by class
-	void ErrorTestObject::test<12>()
-	{
-		LLError::setDefaultLevel(LLError::LEVEL_WARN);
-		LLError::setClassLevel("TestBeta", LLError::LEVEL_INFO);
-
-		TestAlpha::doAll();
-		TestBeta::doAll();
-
-		ensure_message_field_equals(0, MSG_FIELD, "aim west");
-		ensure_message_field_equals(1, MSG_FIELD, "ate eels");
-		ensure_message_field_equals(2, MSG_FIELD, "buy iron");
-		ensure_message_field_equals(3, MSG_FIELD, "bad word");
-		ensure_message_field_equals(4, MSG_FIELD, "big easy");
-		ensure_message_count(5);
-	}
-
-	template<> template<>
-		// filtering by function, and that it will override class filtering
-	void ErrorTestObject::test<13>()
-	{
-		LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
-		LLError::setClassLevel("TestBeta", LLError::LEVEL_WARN);
-		LLError::setFunctionLevel("TestBeta::doInfo", LLError::LEVEL_DEBUG);
-		LLError::setFunctionLevel("TestBeta::doError", LLError::LEVEL_NONE);
-
-		TestBeta::doAll();
-		ensure_message_field_equals(0, MSG_FIELD, "buy iron");
-		ensure_message_field_equals(1, MSG_FIELD, "bad word");
-		ensure_message_count(2);
-	}
-
-	template<> template<>
-		// filtering by file
-		// and that it is overridden by both class and function filtering
-	void ErrorTestObject::test<14>()
-	{
-		LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
-		LLError::setFileLevel(LLError::abbreviateFile(__FILE__),
-									LLError::LEVEL_WARN);
-		LLError::setClassLevel("TestAlpha", LLError::LEVEL_INFO);
-		LLError::setFunctionLevel("TestAlpha::doError",
-									LLError::LEVEL_NONE);
-		LLError::setFunctionLevel("TestBeta::doError",
-									LLError::LEVEL_NONE);
-
-		TestAlpha::doAll();
-		TestBeta::doAll();
-		ensure_message_field_equals(0, MSG_FIELD, "any idea");
-		ensure_message_field_equals(1, MSG_FIELD, "aim west");
-		ensure_message_field_equals(2, MSG_FIELD, "bad word");
-		ensure_message_count(3);
-	}
-
-	template<> template<>
-		// proper cached, efficient lookup of filtering
-	void ErrorTestObject::test<15>()
-	{
-		LLError::setDefaultLevel(LLError::LEVEL_NONE);
-
-		TestAlpha::doInfo();
-		ensure_message_count(0);
-		ensure_equals("first check", LLError::shouldLogCallCount(), 1);
-		TestAlpha::doInfo();
-		ensure_message_count(0);
-		ensure_equals("second check", LLError::shouldLogCallCount(), 1);
-
-		LLError::setClassLevel("TestAlpha", LLError::LEVEL_DEBUG);
-		TestAlpha::doInfo();
-		ensure_message_count(1);
-		ensure_equals("third check", LLError::shouldLogCallCount(), 2);
-		TestAlpha::doInfo();
-		ensure_message_count(2);
-		ensure_equals("fourth check", LLError::shouldLogCallCount(), 2);
-
-		LLError::setClassLevel("TestAlpha", LLError::LEVEL_WARN);
-		TestAlpha::doInfo();
-		ensure_message_count(2);
-		ensure_equals("fifth check", LLError::shouldLogCallCount(), 3);
-		TestAlpha::doInfo();
-		ensure_message_count(2);
-		ensure_equals("sixth check", LLError::shouldLogCallCount(), 3);
-	}
-
-	template<> template<>
-		// configuration from LLSD
-	void ErrorTestObject::test<16>()
-	{
-		LLSD config;
-		config["print-location"] = true;
-		config["default-level"] = "DEBUG";
-
-		LLSD set1;
-		set1["level"] = "WARN";
+    template<> template<>
+        // filtering by class
+    void ErrorTestObject::test<12>()
+    {
+        LLError::setDefaultLevel(LLError::LEVEL_WARN);
+        LLError::setClassLevel("TestBeta", LLError::LEVEL_INFO);
+
+        TestAlpha::doAll();
+        TestBeta::doAll();
+
+        ensure_message_field_equals(0, MSG_FIELD, "aim west");
+        ensure_message_field_equals(1, MSG_FIELD, "ate eels");
+        ensure_message_field_equals(2, MSG_FIELD, "buy iron");
+        ensure_message_field_equals(3, MSG_FIELD, "bad word");
+        ensure_message_field_equals(4, MSG_FIELD, "big easy");
+        ensure_message_count(5);
+    }
+
+    template<> template<>
+        // filtering by function, and that it will override class filtering
+    void ErrorTestObject::test<13>()
+    {
+        LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
+        LLError::setClassLevel("TestBeta", LLError::LEVEL_WARN);
+        LLError::setFunctionLevel("TestBeta::doInfo", LLError::LEVEL_DEBUG);
+        LLError::setFunctionLevel("TestBeta::doError", LLError::LEVEL_NONE);
+
+        TestBeta::doAll();
+        ensure_message_field_equals(0, MSG_FIELD, "buy iron");
+        ensure_message_field_equals(1, MSG_FIELD, "bad word");
+        ensure_message_count(2);
+    }
+
+    template<> template<>
+        // filtering by file
+        // and that it is overridden by both class and function filtering
+    void ErrorTestObject::test<14>()
+    {
+        LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
+        LLError::setFileLevel(LLError::abbreviateFile(__FILE__),
+                                    LLError::LEVEL_WARN);
+        LLError::setClassLevel("TestAlpha", LLError::LEVEL_INFO);
+        LLError::setFunctionLevel("TestAlpha::doError",
+                                    LLError::LEVEL_NONE);
+        LLError::setFunctionLevel("TestBeta::doError",
+                                    LLError::LEVEL_NONE);
+
+        TestAlpha::doAll();
+        TestBeta::doAll();
+        ensure_message_field_equals(0, MSG_FIELD, "any idea");
+        ensure_message_field_equals(1, MSG_FIELD, "aim west");
+        ensure_message_field_equals(2, MSG_FIELD, "bad word");
+        ensure_message_count(3);
+    }
+
+    template<> template<>
+        // proper cached, efficient lookup of filtering
+    void ErrorTestObject::test<15>()
+    {
+        LLError::setDefaultLevel(LLError::LEVEL_NONE);
+
+        TestAlpha::doInfo();
+        ensure_message_count(0);
+        ensure_equals("first check", LLError::shouldLogCallCount(), 1);
+        TestAlpha::doInfo();
+        ensure_message_count(0);
+        ensure_equals("second check", LLError::shouldLogCallCount(), 1);
+
+        LLError::setClassLevel("TestAlpha", LLError::LEVEL_DEBUG);
+        TestAlpha::doInfo();
+        ensure_message_count(1);
+        ensure_equals("third check", LLError::shouldLogCallCount(), 2);
+        TestAlpha::doInfo();
+        ensure_message_count(2);
+        ensure_equals("fourth check", LLError::shouldLogCallCount(), 2);
+
+        LLError::setClassLevel("TestAlpha", LLError::LEVEL_WARN);
+        TestAlpha::doInfo();
+        ensure_message_count(2);
+        ensure_equals("fifth check", LLError::shouldLogCallCount(), 3);
+        TestAlpha::doInfo();
+        ensure_message_count(2);
+        ensure_equals("sixth check", LLError::shouldLogCallCount(), 3);
+    }
+
+    template<> template<>
+        // configuration from LLSD
+    void ErrorTestObject::test<16>()
+    {
+        LLSD config;
+        config["print-location"] = true;
+        config["default-level"] = "DEBUG";
+
+        LLSD set1;
+        set1["level"] = "WARN";
         set1["files"][0] = LLError::abbreviateFile(__FILE__);
 
-		LLSD set2;
-		set2["level"] = "INFO";
-		set2["classes"][0] = "TestAlpha";
-
-		LLSD set3;
-		set3["level"] = "NONE";
-		set3["functions"][0] = "TestAlpha::doError";
-		set3["functions"][1] = "TestBeta::doError";
-
-		config["settings"][0] = set1;
-		config["settings"][1] = set2;
-		config["settings"][2] = set3;
-
-		LLError::configure(config);
-
-		TestAlpha::doAll();
-		TestBeta::doAll();
-		ensure_message_field_equals(0, MSG_FIELD, "any idea");
-		ensure_message_field_equals(1, MSG_FIELD, "aim west");
-		ensure_message_field_equals(2, MSG_FIELD, "bad word");
-		ensure_message_count(3);
-
-		// make sure reconfiguring works
-		LLSD config2;
-		config2["default-level"] = "WARN";
-
-		LLError::configure(config2);
-
-		TestAlpha::doAll();
-		TestBeta::doAll();
-		ensure_message_field_equals(3, MSG_FIELD, "aim west");
-		ensure_message_field_equals(4, MSG_FIELD, "ate eels");
-		ensure_message_field_equals(5, MSG_FIELD, "bad word");
-		ensure_message_field_equals(6, MSG_FIELD, "big easy");
-		ensure_message_count(7);
-	}
+        LLSD set2;
+        set2["level"] = "INFO";
+        set2["classes"][0] = "TestAlpha";
+
+        LLSD set3;
+        set3["level"] = "NONE";
+        set3["functions"][0] = "TestAlpha::doError";
+        set3["functions"][1] = "TestBeta::doError";
+
+        config["settings"][0] = set1;
+        config["settings"][1] = set2;
+        config["settings"][2] = set3;
+
+        LLError::configure(config);
+
+        TestAlpha::doAll();
+        TestBeta::doAll();
+        ensure_message_field_equals(0, MSG_FIELD, "any idea");
+        ensure_message_field_equals(1, MSG_FIELD, "aim west");
+        ensure_message_field_equals(2, MSG_FIELD, "bad word");
+        ensure_message_count(3);
+
+        // make sure reconfiguring works
+        LLSD config2;
+        config2["default-level"] = "WARN";
+
+        LLError::configure(config2);
+
+        TestAlpha::doAll();
+        TestBeta::doAll();
+        ensure_message_field_equals(3, MSG_FIELD, "aim west");
+        ensure_message_field_equals(4, MSG_FIELD, "ate eels");
+        ensure_message_field_equals(5, MSG_FIELD, "bad word");
+        ensure_message_field_equals(6, MSG_FIELD, "big easy");
+        ensure_message_count(7);
+    }
 }
 
 namespace tut
@@ -919,16 +919,16 @@ namespace tut
 }
 
 /* Tests left:
-	handling of classes without LOG_CLASS
+    handling of classes without LOG_CLASS
 
-	live update of filtering from file
+    live update of filtering from file
 
-	syslog recorder
-	file recorder
-	cerr/stderr recorder
-	fixed buffer recorder
-	windows recorder
+    syslog recorder
+    file recorder
+    cerr/stderr recorder
+    fixed buffer recorder
+    windows recorder
 
-	mutex use when logging (?)
-	strange careful about to crash handling (?)
+    mutex use when logging (?)
+    strange careful about to crash handling (?)
 */
diff --git a/indra/llcommon/tests/lleventcoro_test.cpp b/indra/llcommon/tests/lleventcoro_test.cpp
index 032923a108..a3c54ffaa2 100644
--- a/indra/llcommon/tests/lleventcoro_test.cpp
+++ b/indra/llcommon/tests/lleventcoro_test.cpp
@@ -3,25 +3,25 @@
  * @author Nat Goodspeed
  * @date   2009-04-22
  * @brief  Test for coroutine.
- * 
+ *
  * $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$
  */
@@ -101,7 +101,7 @@ namespace tut
         int which;
         LLTestApp testApp;
 
-        void explicit_wait(boost::shared_ptr<LLCoros::Promise<std::string>>& cbp);
+        void explicit_wait(std::shared_ptr<LLCoros::Promise<std::string>>& cbp);
         void waitForEventOn1();
         void coroPump();
         void postAndWait1();
@@ -111,7 +111,7 @@ namespace tut
     typedef coroutine_group::object object;
     coroutine_group coroutinegrp("coroutine");
 
-    void test_data::explicit_wait(boost::shared_ptr<LLCoros::Promise<std::string>>& cbp)
+    void test_data::explicit_wait(std::shared_ptr<LLCoros::Promise<std::string>>& cbp)
     {
         BEGIN
         {
@@ -127,7 +127,7 @@ namespace tut
             // For test purposes, instead of handing 'callback' (or an
             // adapter) off to some I/O subsystem, we'll just pass it back to
             // our caller.
-            cbp = boost::make_shared<LLCoros::Promise<std::string>>();
+            cbp = std::make_shared<LLCoros::Promise<std::string>>();
             LLCoros::Future<std::string> future = LLCoros::getFuture(*cbp);
 
             // calling get() on the future causes us to suspend
@@ -146,7 +146,7 @@ namespace tut
         DEBUG;
 
         // Construct the coroutine instance that will run explicit_wait.
-        boost::shared_ptr<LLCoros::Promise<std::string>> respond;
+        std::shared_ptr<LLCoros::Promise<std::string>> respond;
         LLCoros::instance().launch("test<1>",
                                    [this, &respond](){ explicit_wait(respond); });
         mSync.bump();
diff --git a/indra/llcommon/tests/lleventdispatcher_test.cpp b/indra/llcommon/tests/lleventdispatcher_test.cpp
index b0c532887c..a99acba848 100644
--- a/indra/llcommon/tests/lleventdispatcher_test.cpp
+++ b/indra/llcommon/tests/lleventdispatcher_test.cpp
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2011-01-20
  * @brief  Test for lleventdispatcher.
- * 
+ *
  * $LicenseInfo:firstyear=2011&license=viewerlgpl$
  * Copyright (c) 2011, Linden Research, Inc.
  * $/LicenseInfo$
@@ -470,7 +470,7 @@ namespace tut
                   params["a"], "\n"
                   "params[\"b\"]:\n",
                   params["b"]);
-            // default LLSD::Binary value   
+            // default LLSD::Binary value
             std::vector<U8> binary;
             for (size_t ix = 0, h = 0xaa; ix < 6; ++ix, h += 0x11)
             {
diff --git a/indra/llcommon/tests/lleventfilter_test.cpp b/indra/llcommon/tests/lleventfilter_test.cpp
index fa2cb03e95..a01d7fe415 100644
--- a/indra/llcommon/tests/lleventfilter_test.cpp
+++ b/indra/llcommon/tests/lleventfilter_test.cpp
@@ -3,25 +3,25 @@
  * @author Nat Goodspeed
  * @date   2009-03-06
  * @brief  Test for lleventfilter.
- * 
+ *
  * $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/llcommon/tests/llframetimer_test.cpp b/indra/llcommon/tests/llframetimer_test.cpp
index be372bb855..b9a8c91abf 100644
--- a/indra/llcommon/tests/llframetimer_test.cpp
+++ b/indra/llcommon/tests/llframetimer_test.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file lltiming_test.cpp
  * @date 2006-07-23
  * @brief Tests the timers.
@@ -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$
  */
@@ -34,88 +34,88 @@
 
 namespace tut
 {
-	struct frametimer_test
-	{
-		frametimer_test()
-		{
-			LLFrameTimer::updateFrameTime();			
-		}
-	};
-	typedef test_group<frametimer_test> frametimer_group_t;
-	typedef frametimer_group_t::object frametimer_object_t;
-	tut::frametimer_group_t frametimer_instance("LLFrameTimer");
+    struct frametimer_test
+    {
+        frametimer_test()
+        {
+            LLFrameTimer::updateFrameTime();
+        }
+    };
+    typedef test_group<frametimer_test> frametimer_group_t;
+    typedef frametimer_group_t::object frametimer_object_t;
+    tut::frametimer_group_t frametimer_instance("LLFrameTimer");
+
+    template<> template<>
+    void frametimer_object_t::test<1>()
+    {
+        F64 seconds_since_epoch = LLFrameTimer::getTotalSeconds();
+        LLFrameTimer timer;
+        timer.setExpiryAt(seconds_since_epoch);
+        F64 expires_at = timer.expiresAt();
+        ensure_distance(
+            "set expiry matches get expiry",
+            expires_at,
+            seconds_since_epoch,
+            0.001);
+    }
 
-	template<> template<>
-	void frametimer_object_t::test<1>()
-	{
-		F64 seconds_since_epoch = LLFrameTimer::getTotalSeconds();
-		LLFrameTimer timer;
-		timer.setExpiryAt(seconds_since_epoch);
-		F64 expires_at = timer.expiresAt();
-		ensure_distance(
-			"set expiry matches get expiry",
-			expires_at,
-			seconds_since_epoch,
-			0.001);
-	}
+    template<> template<>
+    void frametimer_object_t::test<2>()
+    {
+        F64 seconds_since_epoch = LLFrameTimer::getTotalSeconds();
+        seconds_since_epoch += 10.0;
+        LLFrameTimer timer;
+        timer.setExpiryAt(seconds_since_epoch);
+        F64 expires_at = timer.expiresAt();
+        ensure_distance(
+            "set expiry matches get expiry 1",
+            expires_at,
+            seconds_since_epoch,
+            0.001);
+        seconds_since_epoch += 10.0;
+        timer.setExpiryAt(seconds_since_epoch);
+        expires_at = timer.expiresAt();
+        ensure_distance(
+            "set expiry matches get expiry 2",
+            expires_at,
+            seconds_since_epoch,
+            0.001);
+    }
+    template<> template<>
+    void frametimer_object_t::test<3>()
+    {
+        clock_t t1 = clock();
+        ms_sleep(200);
+        clock_t t2 = clock();
+        clock_t elapsed = t2 - t1 + 1;
+        std::cout << "Note: using clock(), ms_sleep() actually took " << (long)elapsed << "ms" << std::endl;
 
-	template<> template<>
-	void frametimer_object_t::test<2>()
-	{
-		F64 seconds_since_epoch = LLFrameTimer::getTotalSeconds();
-		seconds_since_epoch += 10.0;
-		LLFrameTimer timer;
-		timer.setExpiryAt(seconds_since_epoch);
-		F64 expires_at = timer.expiresAt();
-		ensure_distance(
-			"set expiry matches get expiry 1",
-			expires_at,
-			seconds_since_epoch,
-			0.001);
-		seconds_since_epoch += 10.0;
-		timer.setExpiryAt(seconds_since_epoch);
-		expires_at = timer.expiresAt();
-		ensure_distance(
-			"set expiry matches get expiry 2",
-			expires_at,
-			seconds_since_epoch,
-			0.001);
-	}
-	template<> template<>
-	void frametimer_object_t::test<3>()
-	{
-		clock_t t1 = clock();
-		ms_sleep(200);
-		clock_t t2 = clock();
-		clock_t elapsed = t2 - t1 + 1;
-		std::cout << "Note: using clock(), ms_sleep() actually took " << (long)elapsed << "ms" << std::endl;
+        F64 seconds_since_epoch = LLFrameTimer::getTotalSeconds();
+        seconds_since_epoch += 2.0;
+        LLFrameTimer timer;
+        timer.setExpiryAt(seconds_since_epoch);
+        /*
+         * Note that the ms_sleep(200) below is only guaranteed to return
+         * in 200ms _or_more_, so it should be true that by the 10th
+         * iteration we've gotten to the 2 seconds requested above
+         * and the timer should expire, but it can expire in fewer iterations
+         * if one or more of the ms_sleep calls takes longer.
+         * (as it did when we moved to Mac OS X 10.10)
+         */
+        int iterations_until_expiration = 0;
+        while ( !timer.hasExpired() )
+        {
+            ms_sleep(200);
+            LLFrameTimer::updateFrameTime();
+            iterations_until_expiration++;
+        }
+        ensure("timer took too long to expire", iterations_until_expiration <= 10);
+    }
 
-		F64 seconds_since_epoch = LLFrameTimer::getTotalSeconds();
-		seconds_since_epoch += 2.0;
-		LLFrameTimer timer;
-		timer.setExpiryAt(seconds_since_epoch);
-		/*
-		 * Note that the ms_sleep(200) below is only guaranteed to return
-		 * in 200ms _or_more_, so it should be true that by the 10th
-		 * iteration we've gotten to the 2 seconds requested above
-		 * and the timer should expire, but it can expire in fewer iterations
-		 * if one or more of the ms_sleep calls takes longer.
-		 * (as it did when we moved to Mac OS X 10.10)
-		 */
-		int iterations_until_expiration = 0;
-		while ( !timer.hasExpired() )
-		{
-			ms_sleep(200);
-			LLFrameTimer::updateFrameTime();
-			iterations_until_expiration++;
-		}
-		ensure("timer took too long to expire", iterations_until_expiration <= 10);
-	}
-	
 /*
-	template<> template<>
-	void frametimer_object_t::test<4>()
-	{
-	}
+    template<> template<>
+    void frametimer_object_t::test<4>()
+    {
+    }
 */
 }
diff --git a/indra/llcommon/tests/llheteromap_test.cpp b/indra/llcommon/tests/llheteromap_test.cpp
index 686bffb878..cabfb91593 100644
--- a/indra/llcommon/tests/llheteromap_test.cpp
+++ b/indra/llcommon/tests/llheteromap_test.cpp
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2016-10-12
  * @brief  Test for llheteromap.
- * 
+ *
  * $LicenseInfo:firstyear=2016&license=viewerlgpl$
  * Copyright (c) 2016, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/llcommon/tests/llinstancetracker_test.cpp b/indra/llcommon/tests/llinstancetracker_test.cpp
index 5daa29adf4..c6eb0fdf75 100644
--- a/indra/llcommon/tests/llinstancetracker_test.cpp
+++ b/indra/llcommon/tests/llinstancetracker_test.cpp
@@ -3,25 +3,25 @@
  * @author Nat Goodspeed
  * @date   2009-11-10
  * @brief  Test for llinstancetracker.
- * 
+ *
  * $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$
  */
@@ -94,7 +94,7 @@ namespace tut
             ensure("couldn't find stack Keyed", bool(found));
             ensure_equals("found wrong Keyed instance", found.get(), &one);
             {
-                boost::scoped_ptr<Keyed> two(new Keyed("two"));
+                std::unique_ptr<Keyed> two(new Keyed("two"));
                 ensure_equals(Keyed::instanceCount(), 2);
                 auto found = Keyed::getInstance("two");
                 ensure("couldn't find heap Keyed", bool(found));
@@ -118,7 +118,7 @@ namespace tut
             std::weak_ptr<Unkeyed> found = one.getWeak();
             ensure(! found.expired());
             {
-                boost::scoped_ptr<Unkeyed> two(new Unkeyed);
+                std::unique_ptr<Unkeyed> two(new Unkeyed);
                 ensure_equals(Unkeyed::instanceCount(), 2);
             }
             ensure_equals(Unkeyed::instanceCount(), 1);
@@ -170,7 +170,7 @@ namespace tut
     {
         Unkeyed one, two, three;
         typedef std::set<Unkeyed*> KeySet;
-    
+
         KeySet instances;
         instances.insert(&one);
         instances.insert(&two);
diff --git a/indra/llcommon/tests/lllazy_test.cpp b/indra/llcommon/tests/lllazy_test.cpp
index 542306ee22..923fe952a9 100644
--- a/indra/llcommon/tests/lllazy_test.cpp
+++ b/indra/llcommon/tests/lllazy_test.cpp
@@ -3,25 +3,25 @@
  * @author Nat Goodspeed
  * @date   2009-01-28
  * @brief  Tests of lllazy.h.
- * 
+ *
  * $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/llcommon/tests/llleap_test.cpp b/indra/llcommon/tests/llleap_test.cpp
index 7197dedfbf..fa48bcdefd 100644
--- a/indra/llcommon/tests/llleap_test.cpp
+++ b/indra/llcommon/tests/llleap_test.cpp
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2012-02-21
  * @brief  Test for llleap.
- * 
+ *
  * $LicenseInfo:firstyear=2012&license=viewerlgpl$
  * Copyright (c) 2012, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/llcommon/tests/llmainthreadtask_test.cpp b/indra/llcommon/tests/llmainthreadtask_test.cpp
index 69b11ccafb..9ccf391327 100644
--- a/indra/llcommon/tests/llmainthreadtask_test.cpp
+++ b/indra/llcommon/tests/llmainthreadtask_test.cpp
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2019-12-05
  * @brief  Test for llmainthreadtask.
- * 
+ *
  * $LicenseInfo:firstyear=2019&license=viewerlgpl$
  * Copyright (c) 2019, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/llcommon/tests/llmemtype_test.cpp b/indra/llcommon/tests/llmemtype_test.cpp
index 1f050d6dc7..2d64d342ae 100644
--- a/indra/llcommon/tests/llmemtype_test.cpp
+++ b/indra/llcommon/tests/llmemtype_test.cpp
@@ -3,25 +3,25 @@
  * @author Palmer Truelson
  * @date   2008-03-
  * @brief  Test for llmemtype.cpp.
- * 
+ *
  * $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$
  */
@@ -37,14 +37,14 @@ std::stack<S32> memTypeStack;
 
 void LLAllocator::pushMemType(S32 i)
 {
-	memTypeStack.push(i);
+    memTypeStack.push(i);
 }
 
 S32 LLAllocator::popMemType(void)
 {
-	S32 ret = memTypeStack.top();
-	memTypeStack.pop();
-	return ret;
+    S32 ret = memTypeStack.top();
+    memTypeStack.pop();
+    return ret;
 }
 
 namespace tut
@@ -69,49 +69,49 @@ namespace tut
         ensure("Simplest test ever", true);
     }
 
-	// test with no scripts
-	template<> template<>
-	void object::test<2>()
-	{
-		{
-			LLMemType m1(LLMemType::MTYPE_INIT);
-		}
-		ensure("Test that you can construct and destruct the mem type");
-	}
-
-	// test creation and stack testing
-	template<> template<>
-	void object::test<3>()
-	{
-		{
-			ensure("Test that creation and destruction properly inc/dec the stack");			
-			ensure_equals(memTypeStack.size(), 0);
-			{
-				LLMemType m1(LLMemType::MTYPE_INIT);
-				ensure_equals(memTypeStack.size(), 1);
-				LLMemType m2(LLMemType::MTYPE_STARTUP);
-				ensure_equals(memTypeStack.size(), 2);
-			}
-			ensure_equals(memTypeStack.size(), 0);
-		}
-	}
-
-	// test with no scripts
-	template<> template<>
-	void object::test<4>()
-	{
-		// catch the begining and end
-		std::string test_name = LLMemType::getNameFromID(LLMemType::MTYPE_INIT.mID);
-		ensure_equals("Init name", test_name, "Init");
-
-		std::string test_name2 = LLMemType::getNameFromID(LLMemType::MTYPE_VOLUME.mID);
-		ensure_equals("Volume name", test_name2, "Volume");
-
-		std::string test_name3 = LLMemType::getNameFromID(LLMemType::MTYPE_OTHER.mID);
-		ensure_equals("Other name", test_name3, "Other");
+    // test with no scripts
+    template<> template<>
+    void object::test<2>()
+    {
+        {
+            LLMemType m1(LLMemType::MTYPE_INIT);
+        }
+        ensure("Test that you can construct and destruct the mem type");
+    }
+
+    // test creation and stack testing
+    template<> template<>
+    void object::test<3>()
+    {
+        {
+            ensure("Test that creation and destruction properly inc/dec the stack");
+            ensure_equals(memTypeStack.size(), 0);
+            {
+                LLMemType m1(LLMemType::MTYPE_INIT);
+                ensure_equals(memTypeStack.size(), 1);
+                LLMemType m2(LLMemType::MTYPE_STARTUP);
+                ensure_equals(memTypeStack.size(), 2);
+            }
+            ensure_equals(memTypeStack.size(), 0);
+        }
+    }
+
+    // test with no scripts
+    template<> template<>
+    void object::test<4>()
+    {
+        // catch the begining and end
+        std::string test_name = LLMemType::getNameFromID(LLMemType::MTYPE_INIT.mID);
+        ensure_equals("Init name", test_name, "Init");
+
+        std::string test_name2 = LLMemType::getNameFromID(LLMemType::MTYPE_VOLUME.mID);
+        ensure_equals("Volume name", test_name2, "Volume");
+
+        std::string test_name3 = LLMemType::getNameFromID(LLMemType::MTYPE_OTHER.mID);
+        ensure_equals("Other name", test_name3, "Other");
 
         std::string test_name4 = LLMemType::getNameFromID(-1);
         ensure_equals("Invalid name", test_name4, "INVALID");
-	}
+    }
 
 };
diff --git a/indra/llcommon/tests/llpounceable_test.cpp b/indra/llcommon/tests/llpounceable_test.cpp
index 2f4915ce11..b3024966c5 100644
--- a/indra/llcommon/tests/llpounceable_test.cpp
+++ b/indra/llcommon/tests/llpounceable_test.cpp
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2015-05-22
  * @brief  Test for llpounceable.
- * 
+ *
  * $LicenseInfo:firstyear=2015&license=viewerlgpl$
  * Copyright (c) 2015, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/llcommon/tests/llprocess_test.cpp b/indra/llcommon/tests/llprocess_test.cpp
index b6b297b8d7..6e8422ca0c 100644
--- a/indra/llcommon/tests/llprocess_test.cpp
+++ b/indra/llcommon/tests/llprocess_test.cpp
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2011-12-19
  * @brief  Test for llprocess.
- * 
+ *
  * $LicenseInfo:firstyear=2011&license=viewerlgpl$
  * Copyright (c) 2011, Linden Research, Inc.
  * $/LicenseInfo$
@@ -21,7 +21,6 @@
 // external library headers
 #include "llapr.h"
 #include "apr_thread_proc.h"
-#include <boost/foreach.hpp>
 #include <boost/function.hpp>
 #include <boost/algorithm/string/find_iterator.hpp>
 #include <boost/algorithm/string/finder.hpp>
@@ -323,7 +322,7 @@ namespace tut
     {
 /*==========================================================================*|
         std::string reason_str;
-        BOOST_FOREACH(const ReasonCode& rcp, reasons)
+        for (const ReasonCode& rcp : reasons)
         {
             if (reason == rcp.code)
             {
@@ -554,7 +553,7 @@ namespace tut
         catch (const failure&)
         {
             std::cout << "History:\n";
-            BOOST_FOREACH(const Item& item, history)
+            for (const Item& item : history)
             {
                 std::string what(item.what);
                 if ((! what.empty()) && what[what.length() - 1] == '\n')
@@ -1076,7 +1075,7 @@ namespace tut
     {
         EventListener(LLEventPump& pump)
         {
-            mConnection = 
+            mConnection =
                 pump.listen("EventListener", boost::bind(&EventListener::tick, this, _1));
         }
 
diff --git a/indra/llcommon/tests/llprocessor_test.cpp b/indra/llcommon/tests/llprocessor_test.cpp
index 884e1b5e5b..a2467d9205 100644
--- a/indra/llcommon/tests/llprocessor_test.cpp
+++ b/indra/llcommon/tests/llprocessor_test.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llprocessor_test.cpp
  * @date 2010-06-01
  *
  * $LicenseInfo:firstyear=2010&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,30 +32,30 @@
 
 namespace tut
 {
-	struct processor
-	{
-	};
-
-	typedef test_group<processor> processor_t;
-	typedef processor_t::object processor_object_t;
-	tut::processor_t tut_processor("LLProcessor");
-
-	template<> template<>
-	void processor_object_t::test<1>()
-	{
-		set_test_name("LLProcessorInfo regression test");
-
-		LLProcessorInfo pi;
-		F64 freq =  pi.getCPUFrequency();
-		//bool sse =  pi.hasSSE();
-		//bool sse2 = pi.hasSSE2();
-		//bool alitvec = pi.hasAltivec();
-		std::string family = pi.getCPUFamilyName();
-		std::string brand =  pi.getCPUBrandName();
-		//std::string steam =  pi.getCPUFeatureDescription();
-
-		ensure_not_equals("Unknown Brand name", brand, "Unknown"); 
-		ensure_not_equals("Unknown Family name", family, "Unknown"); 
-		ensure("Reasonable CPU Frequency > 100 && < 10000", freq > 100 && freq < 10000);
-	}
+    struct processor
+    {
+    };
+
+    typedef test_group<processor> processor_t;
+    typedef processor_t::object processor_object_t;
+    tut::processor_t tut_processor("LLProcessor");
+
+    template<> template<>
+    void processor_object_t::test<1>()
+    {
+        set_test_name("LLProcessorInfo regression test");
+
+        LLProcessorInfo pi;
+        F64 freq =  pi.getCPUFrequency();
+        //bool sse =  pi.hasSSE();
+        //bool sse2 = pi.hasSSE2();
+        //bool alitvec = pi.hasAltivec();
+        std::string family = pi.getCPUFamilyName();
+        std::string brand =  pi.getCPUBrandName();
+        //std::string steam =  pi.getCPUFeatureDescription();
+
+        ensure_not_equals("Unknown Brand name", brand, "Unknown");
+        ensure_not_equals("Unknown Family name", family, "Unknown");
+        ensure("Reasonable CPU Frequency > 100 && < 10000", freq > 100 && freq < 10000);
+    }
 }
diff --git a/indra/llcommon/tests/llprocinfo_test.cpp b/indra/llcommon/tests/llprocinfo_test.cpp
index 12d5a695ee..6a151048c2 100644
--- a/indra/llcommon/tests/llprocinfo_test.cpp
+++ b/indra/llcommon/tests/llprocinfo_test.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llprocinfo_test.cpp
  * @brief Tests for the LLProcInfo class.
  *
  * $LicenseInfo:firstyear=2013&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2013, 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$
  */
@@ -40,9 +40,9 @@ namespace tut
 
 struct procinfo_test
 {
-	procinfo_test()
-		{
-		}
+    procinfo_test()
+        {
+        }
 };
 
 typedef test_group<procinfo_test> procinfo_group_t;
@@ -54,14 +54,14 @@ tut::procinfo_group_t procinfo_instance("LLProcInfo");
 template<> template<>
 void procinfo_object_t::test<1>()
 {
-	LLProcInfo::time_type user(bad_user), system(bad_system);
+    LLProcInfo::time_type user(bad_user), system(bad_system);
+
+    set_test_name("getCPUUsage() basic function");
 
-	set_test_name("getCPUUsage() basic function");
+    LLProcInfo::getCPUUsage(user, system);
 
-	LLProcInfo::getCPUUsage(user, system);
-	
-	ensure_not_equals("getCPUUsage() writes to its user argument", user, bad_user);
-	ensure_not_equals("getCPUUsage() writes to its system argument", system, bad_system);
+    ensure_not_equals("getCPUUsage() writes to its user argument", user, bad_user);
+    ensure_not_equals("getCPUUsage() writes to its system argument", system, bad_system);
 }
 
 
@@ -69,22 +69,22 @@ void procinfo_object_t::test<1>()
 template<> template<>
 void procinfo_object_t::test<2>()
 {
-	LLProcInfo::time_type user(bad_user), system(bad_system);
-	LLProcInfo::time_type user2(bad_user), system2(bad_system);
-
-	set_test_name("getCPUUsage() increases over time");
-
-	LLProcInfo::getCPUUsage(user, system);
-	
-	for (int i(0); i < 100000; ++i)
-	{
-		ms_sleep(0);
-	}
-	
-	LLProcInfo::getCPUUsage(user2, system2);
-
-	ensure_equals("getCPUUsage() user value doesn't decrease over time", user2 >= user, true);
-	ensure_equals("getCPUUsage() system value doesn't decrease over time", system2 >= system, true);
+    LLProcInfo::time_type user(bad_user), system(bad_system);
+    LLProcInfo::time_type user2(bad_user), system2(bad_system);
+
+    set_test_name("getCPUUsage() increases over time");
+
+    LLProcInfo::getCPUUsage(user, system);
+
+    for (int i(0); i < 100000; ++i)
+    {
+        ms_sleep(0);
+    }
+
+    LLProcInfo::getCPUUsage(user2, system2);
+
+    ensure_equals("getCPUUsage() user value doesn't decrease over time", user2 >= user, true);
+    ensure_equals("getCPUUsage() system value doesn't decrease over time", system2 >= system, true);
 }
 
 
diff --git a/indra/llcommon/tests/llrand_test.cpp b/indra/llcommon/tests/llrand_test.cpp
index ac5a33d0ba..a0dd4ef576 100644
--- a/indra/llcommon/tests/llrand_test.cpp
+++ b/indra/llcommon/tests/llrand_test.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llrandom_test.cpp
  * @author Phoenix
  * @date 2007-01-25
@@ -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$
  */
@@ -49,76 +49,76 @@ void ensure_in_range(const std::string_view& name,
 
 namespace tut
 {
-	struct random
-	{
-	};
+    struct random
+    {
+    };
 
-	typedef test_group<random> random_t;
-	typedef random_t::object random_object_t;
-	tut::random_t tut_random("LLSeedRand");
+    typedef test_group<random> random_t;
+    typedef random_t::object random_object_t;
+    tut::random_t tut_random("LLSeedRand");
 
-	template<> template<>
-	void random_object_t::test<1>()
-	{
-		for(S32 ii = 0; ii < 100000; ++ii)
-		{
-			ensure_in_range("frand", ll_frand(), 0.0f, 1.0f);
-		}
-	}
+    template<> template<>
+    void random_object_t::test<1>()
+    {
+        for(S32 ii = 0; ii < 100000; ++ii)
+        {
+            ensure_in_range("frand", ll_frand(), 0.0f, 1.0f);
+        }
+    }
 
-	template<> template<>
-	void random_object_t::test<2>()
-	{
-		for(S32 ii = 0; ii < 100000; ++ii)
-		{
-			ensure_in_range("drand", ll_drand(), 0.0, 1.0);
-		}
-	}
+    template<> template<>
+    void random_object_t::test<2>()
+    {
+        for(S32 ii = 0; ii < 100000; ++ii)
+        {
+            ensure_in_range("drand", ll_drand(), 0.0, 1.0);
+        }
+    }
 
-	template<> template<>
-	void random_object_t::test<3>()
-	{
-		for(S32 ii = 0; ii < 100000; ++ii)
-		{
-			ensure_in_range("frand(2.0f)", ll_frand(2.0f) - 1.0f, -1.0f, 1.0f);
-		}
-	}
+    template<> template<>
+    void random_object_t::test<3>()
+    {
+        for(S32 ii = 0; ii < 100000; ++ii)
+        {
+            ensure_in_range("frand(2.0f)", ll_frand(2.0f) - 1.0f, -1.0f, 1.0f);
+        }
+    }
 
-	template<> template<>
-	void random_object_t::test<4>()
-	{
-		for(S32 ii = 0; ii < 100000; ++ii)
-		{
-			// Negate the result so we don't have to allow a templated low-end
-			// comparison as well.
-			ensure_in_range("-frand(-7.0)", -ll_frand(-7.0), 0.0f, 7.0f);
-		}
-	}
+    template<> template<>
+    void random_object_t::test<4>()
+    {
+        for(S32 ii = 0; ii < 100000; ++ii)
+        {
+            // Negate the result so we don't have to allow a templated low-end
+            // comparison as well.
+            ensure_in_range("-frand(-7.0)", -ll_frand(-7.0), 0.0f, 7.0f);
+        }
+    }
 
-	template<> template<>
-	void random_object_t::test<5>()
-	{
-		for(S32 ii = 0; ii < 100000; ++ii)
-		{
-			ensure_in_range("-drand(-2.0)", -ll_drand(-2.0), 0.0, 2.0);
-		}
-	}
+    template<> template<>
+    void random_object_t::test<5>()
+    {
+        for(S32 ii = 0; ii < 100000; ++ii)
+        {
+            ensure_in_range("-drand(-2.0)", -ll_drand(-2.0), 0.0, 2.0);
+        }
+    }
 
-	template<> template<>
-	void random_object_t::test<6>()
-	{
-		for(S32 ii = 0; ii < 100000; ++ii)
-		{
-			ensure_in_range("rand(100)", ll_rand(100), 0, 100);
-		}
-	}
+    template<> template<>
+    void random_object_t::test<6>()
+    {
+        for(S32 ii = 0; ii < 100000; ++ii)
+        {
+            ensure_in_range("rand(100)", ll_rand(100), 0, 100);
+        }
+    }
 
-	template<> template<>
-	void random_object_t::test<7>()
-	{
-		for(S32 ii = 0; ii < 100000; ++ii)
-		{
-			ensure_in_range("-rand(-127)", -ll_rand(-127), 0, 127);
-		}
-	}
+    template<> template<>
+    void random_object_t::test<7>()
+    {
+        for(S32 ii = 0; ii < 100000; ++ii)
+        {
+            ensure_in_range("-rand(-127)", -ll_rand(-127), 0, 127);
+        }
+    }
 }
diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp
index ac40125f75..56fdc51e82 100644
--- a/indra/llcommon/tests/llsdserialize_test.cpp
+++ b/indra/llcommon/tests/llsdserialize_test.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llsdserialize_test.cpp
  * @date 2006-04
  * @brief LLSDSerialize 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$
  */
@@ -64,313 +64,313 @@ typedef std::function<bool(std::istream& istr, LLSD& data, llssize max_bytes)> P
 
 std::vector<U8> string_to_vector(const std::string& str)
 {
-	return std::vector<U8>(str.begin(), str.end());
+    return std::vector<U8>(str.begin(), str.end());
 }
 
 namespace tut
 {
-	struct sd_xml_data
-	{
-		sd_xml_data()
-		{
-			mFormatter = new LLSDXMLFormatter;
-		}
-		LLSD mSD;
-		LLPointer<LLSDXMLFormatter> mFormatter;
-		void xml_test(const char* name, const std::string& expected)
-		{
-			std::ostringstream ostr;
-			mFormatter->format(mSD, ostr);
-			ensure_equals(name, ostr.str(), expected);
-		}
-	};
-
-	typedef test_group<sd_xml_data> sd_xml_test;
-	typedef sd_xml_test::object sd_xml_object;
-	tut::sd_xml_test sd_xml_stream("LLSDXMLFormatter");
-
-	template<> template<>
-	void sd_xml_object::test<1>()
-	{
-		// random atomic tests
-		std::string expected;
-
-		expected = "<llsd><undef /></llsd>\n";
-		xml_test("undef", expected);
-
-		mSD = 3463;
-		expected = "<llsd><integer>3463</integer></llsd>\n";
-		xml_test("integer", expected);
-
-		mSD = "";
-		expected = "<llsd><string /></llsd>\n";
-		xml_test("empty string", expected);
-
-		mSD = "foobar";
-		expected = "<llsd><string>foobar</string></llsd>\n";
-		xml_test("string", expected);
-
-		mSD = LLUUID::null;
-		expected = "<llsd><uuid /></llsd>\n";
-		xml_test("null uuid", expected);
-
-		mSD = LLUUID("c96f9b1e-f589-4100-9774-d98643ce0bed");
-		expected = "<llsd><uuid>c96f9b1e-f589-4100-9774-d98643ce0bed</uuid></llsd>\n";
-		xml_test("uuid", expected);
-
-		mSD = LLURI("https://secondlife.com/login");
-		expected = "<llsd><uri>https://secondlife.com/login</uri></llsd>\n";
-		xml_test("uri", expected);
-
-		mSD = LLDate("2006-04-24T16:11:33Z");
-		expected = "<llsd><date>2006-04-24T16:11:33Z</date></llsd>\n";
-		xml_test("date", expected);
-
-		// Generated by: echo -n 'hello' | openssl enc -e -base64
-		std::vector<U8> hello;
-		hello.push_back('h');
-		hello.push_back('e');
-		hello.push_back('l');
-		hello.push_back('l');
-		hello.push_back('o');
-		mSD = hello;
-		expected = "<llsd><binary encoding=\"base64\">aGVsbG8=</binary></llsd>\n";
-		xml_test("binary", expected);
-	}
-
-	template<> template<>
-	void sd_xml_object::test<2>()
-	{
-		// tests with boolean values.
-		std::string expected;
-
-		mFormatter->boolalpha(true);
-		mSD = true;
-		expected = "<llsd><boolean>true</boolean></llsd>\n";
-		xml_test("bool alpha true", expected);
-		mSD = false;
-		expected = "<llsd><boolean>false</boolean></llsd>\n";
-		xml_test("bool alpha false", expected);
-
-		mFormatter->boolalpha(false);
-		mSD = true;
-		expected = "<llsd><boolean>1</boolean></llsd>\n";
-		xml_test("bool true", expected);
-		mSD = false;
-		expected = "<llsd><boolean>0</boolean></llsd>\n";
-		xml_test("bool false", expected);
-	}
-
-
-	template<> template<>
-	void sd_xml_object::test<3>()
-	{
-		// tests with real values.
-		std::string expected;
-
-		mFormatter->realFormat("%.2f");
-		mSD = 1.0;
-		expected = "<llsd><real>1.00</real></llsd>\n";
-		xml_test("real 1", expected);
-
-		mSD = -34379.0438;
-		expected = "<llsd><real>-34379.04</real></llsd>\n";
-		xml_test("real reduced precision", expected);
-		mFormatter->realFormat("%.4f");
-		expected = "<llsd><real>-34379.0438</real></llsd>\n";
-		xml_test("higher precision", expected);
-
-		mFormatter->realFormat("%.0f");
-		mSD = 0.0;
-		expected = "<llsd><real>0</real></llsd>\n";
-		xml_test("no decimal 0", expected);
-		mSD = 3287.4387;
-		expected = "<llsd><real>3287</real></llsd>\n";
-		xml_test("no decimal real number", expected);
-	}
-
-	template<> template<>
-	void sd_xml_object::test<4>()
-	{
-		// tests with arrays
-		std::string expected;
-
-		mSD = LLSD::emptyArray();
-		expected = "<llsd><array /></llsd>\n";
-		xml_test("empty array", expected);
-
-		mSD.append(LLSD());
-		expected = "<llsd><array><undef /></array></llsd>\n";
-		xml_test("1 element array", expected);
-
-		mSD.append(1);
-		expected = "<llsd><array><undef /><integer>1</integer></array></llsd>\n";
-		xml_test("2 element array", expected);
-	}
-
-	template<> template<>
-	void sd_xml_object::test<5>()
-	{
-		// tests with arrays
-		std::string expected;
-
-		mSD = LLSD::emptyMap();
-		expected = "<llsd><map /></llsd>\n";
-		xml_test("empty map", expected);
-
-		mSD["foo"] = "bar";
-		expected = "<llsd><map><key>foo</key><string>bar</string></map></llsd>\n";
-		xml_test("1 element map", expected);
-
-		mSD["baz"] = LLSD();
-		expected = "<llsd><map><key>baz</key><undef /><key>foo</key><string>bar</string></map></llsd>\n";
-		xml_test("2 element map", expected);
-	}
-
-	template<> template<>
-	void sd_xml_object::test<6>()
-	{
-		// tests with binary
-		std::string expected;
-
-		// Generated by: echo -n 'hello' | openssl enc -e -base64
-		mSD = string_to_vector("hello");
-		expected = "<llsd><binary encoding=\"base64\">aGVsbG8=</binary></llsd>\n";
-		xml_test("binary", expected);
-
-		mSD = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0");
-		expected = "<llsd><binary encoding=\"base64\">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBlNDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZmZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMyOXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>\n";
-		xml_test("binary", expected);
-	}
-
-	class TestLLSDSerializeData
-	{
-	public:
-		TestLLSDSerializeData();
-		~TestLLSDSerializeData();
-
-		void doRoundTripTests(const std::string&);
-		void checkRoundTrip(const std::string&, const LLSD& v);
-
-		void setFormatterParser(LLPointer<LLSDFormatter> formatter, LLPointer<LLSDParser> parser)
-		{
-			mFormatter = [formatter](const LLSD& data, std::ostream& str)
-			{
-				formatter->format(data, str);
-			};
-			// this lambda must be mutable since otherwise the bound 'parser'
-			// is assumed to point to a const LLSDParser
-			mParser = [parser](std::istream& istr, LLSD& data, llssize max_bytes) mutable
-			{
-				// reset() call is needed since test code re-uses parser object
-				parser->reset();
-				return (parser->parse(istr, data, max_bytes) > 0);
-			};
-		}
-
-		void setParser(bool (*parser)(LLSD&, std::istream&, llssize))
-		{
-			// why does LLSDSerialize::deserialize() reverse the parse() params??
-			mParser = [parser](std::istream& istr, LLSD& data, llssize max_bytes)
-			{
-				return parser(data, istr, max_bytes);
-			};
-		}
-
-		FormatterFunction mFormatter;
-		ParserFunction mParser;
-	};
-
-	TestLLSDSerializeData::TestLLSDSerializeData()
-	{
-	}
-
-	TestLLSDSerializeData::~TestLLSDSerializeData()
-	{
-	}
-
-	void TestLLSDSerializeData::checkRoundTrip(const std::string& msg, const LLSD& v)
-	{
-		std::stringstream stream;
-		mFormatter(v, stream);
-		//LL_INFOS() << "checkRoundTrip: length " << stream.str().length() << LL_ENDL;
-		LLSD w;
-		mParser(stream, w, stream.str().size());
-
-		try
-		{
-			ensure_equals(msg, w, v);
-		}
-		catch (...)
-		{
-			std::cerr << "the serialized string was:" << std::endl;
-			std::cerr << stream.str() << std::endl;
-			throw;
-		}
-	}
-
-	static void fillmap(LLSD& root, U32 width, U32 depth)
-	{
-		if(depth == 0)
-		{
-			root["foo"] = "bar";
-			return;
-		}
-
-		for(U32 i = 0; i < width; ++i)
-		{
-			std::string key = llformat("child %d", i);
-			root[key] = LLSD::emptyMap();
-			fillmap(root[key], width, depth - 1);
-		}
-	}
-
-	void TestLLSDSerializeData::doRoundTripTests(const std::string& msg)
-	{
-		LLSD v;
-		checkRoundTrip(msg + " undefined", v);
-
-		v = true;
-		checkRoundTrip(msg + " true bool", v);
-
-		v = false;
-		checkRoundTrip(msg + " false bool", v);
-
-		v = 1;
-		checkRoundTrip(msg + " positive int", v);
-
-		v = 0;
-		checkRoundTrip(msg + " zero int", v);
-
-		v = -1;
-		checkRoundTrip(msg + " negative int", v);
-
-		v = 1234.5f;
-		checkRoundTrip(msg + " positive float", v);
-
-		v = 0.0f;
-		checkRoundTrip(msg + " zero float", v);
-
-		v = -1234.5f;
-		checkRoundTrip(msg + " negative float", v);
-
-		// FIXME: need a NaN test
-
-		v = LLUUID::null;
-		checkRoundTrip(msg + " null uuid", v);
-
-		LLUUID newUUID;
-		newUUID.generate();
-		v = newUUID;
-		checkRoundTrip(msg + " new uuid", v);
-
-		v = "";
-		checkRoundTrip(msg + " empty string", v);
-
-		v = "some string";
-		checkRoundTrip(msg + " non-empty string", v);
-
-		v =
+    struct sd_xml_data
+    {
+        sd_xml_data()
+        {
+            mFormatter = new LLSDXMLFormatter;
+        }
+        LLSD mSD;
+        LLPointer<LLSDXMLFormatter> mFormatter;
+        void xml_test(const char* name, const std::string& expected)
+        {
+            std::ostringstream ostr;
+            mFormatter->format(mSD, ostr);
+            ensure_equals(name, ostr.str(), expected);
+        }
+    };
+
+    typedef test_group<sd_xml_data> sd_xml_test;
+    typedef sd_xml_test::object sd_xml_object;
+    tut::sd_xml_test sd_xml_stream("LLSDXMLFormatter");
+
+    template<> template<>
+    void sd_xml_object::test<1>()
+    {
+        // random atomic tests
+        std::string expected;
+
+        expected = "<llsd><undef /></llsd>\n";
+        xml_test("undef", expected);
+
+        mSD = 3463;
+        expected = "<llsd><integer>3463</integer></llsd>\n";
+        xml_test("integer", expected);
+
+        mSD = "";
+        expected = "<llsd><string /></llsd>\n";
+        xml_test("empty string", expected);
+
+        mSD = "foobar";
+        expected = "<llsd><string>foobar</string></llsd>\n";
+        xml_test("string", expected);
+
+        mSD = LLUUID::null;
+        expected = "<llsd><uuid /></llsd>\n";
+        xml_test("null uuid", expected);
+
+        mSD = LLUUID("c96f9b1e-f589-4100-9774-d98643ce0bed");
+        expected = "<llsd><uuid>c96f9b1e-f589-4100-9774-d98643ce0bed</uuid></llsd>\n";
+        xml_test("uuid", expected);
+
+        mSD = LLURI("https://secondlife.com/login");
+        expected = "<llsd><uri>https://secondlife.com/login</uri></llsd>\n";
+        xml_test("uri", expected);
+
+        mSD = LLDate("2006-04-24T16:11:33Z");
+        expected = "<llsd><date>2006-04-24T16:11:33Z</date></llsd>\n";
+        xml_test("date", expected);
+
+        // Generated by: echo -n 'hello' | openssl enc -e -base64
+        std::vector<U8> hello;
+        hello.push_back('h');
+        hello.push_back('e');
+        hello.push_back('l');
+        hello.push_back('l');
+        hello.push_back('o');
+        mSD = hello;
+        expected = "<llsd><binary encoding=\"base64\">aGVsbG8=</binary></llsd>\n";
+        xml_test("binary", expected);
+    }
+
+    template<> template<>
+    void sd_xml_object::test<2>()
+    {
+        // tests with boolean values.
+        std::string expected;
+
+        mFormatter->boolalpha(true);
+        mSD = true;
+        expected = "<llsd><boolean>true</boolean></llsd>\n";
+        xml_test("bool alpha true", expected);
+        mSD = false;
+        expected = "<llsd><boolean>false</boolean></llsd>\n";
+        xml_test("bool alpha false", expected);
+
+        mFormatter->boolalpha(false);
+        mSD = true;
+        expected = "<llsd><boolean>1</boolean></llsd>\n";
+        xml_test("bool true", expected);
+        mSD = false;
+        expected = "<llsd><boolean>0</boolean></llsd>\n";
+        xml_test("bool false", expected);
+    }
+
+
+    template<> template<>
+    void sd_xml_object::test<3>()
+    {
+        // tests with real values.
+        std::string expected;
+
+        mFormatter->realFormat("%.2f");
+        mSD = 1.0;
+        expected = "<llsd><real>1.00</real></llsd>\n";
+        xml_test("real 1", expected);
+
+        mSD = -34379.0438;
+        expected = "<llsd><real>-34379.04</real></llsd>\n";
+        xml_test("real reduced precision", expected);
+        mFormatter->realFormat("%.4f");
+        expected = "<llsd><real>-34379.0438</real></llsd>\n";
+        xml_test("higher precision", expected);
+
+        mFormatter->realFormat("%.0f");
+        mSD = 0.0;
+        expected = "<llsd><real>0</real></llsd>\n";
+        xml_test("no decimal 0", expected);
+        mSD = 3287.4387;
+        expected = "<llsd><real>3287</real></llsd>\n";
+        xml_test("no decimal real number", expected);
+    }
+
+    template<> template<>
+    void sd_xml_object::test<4>()
+    {
+        // tests with arrays
+        std::string expected;
+
+        mSD = LLSD::emptyArray();
+        expected = "<llsd><array /></llsd>\n";
+        xml_test("empty array", expected);
+
+        mSD.append(LLSD());
+        expected = "<llsd><array><undef /></array></llsd>\n";
+        xml_test("1 element array", expected);
+
+        mSD.append(1);
+        expected = "<llsd><array><undef /><integer>1</integer></array></llsd>\n";
+        xml_test("2 element array", expected);
+    }
+
+    template<> template<>
+    void sd_xml_object::test<5>()
+    {
+        // tests with arrays
+        std::string expected;
+
+        mSD = LLSD::emptyMap();
+        expected = "<llsd><map /></llsd>\n";
+        xml_test("empty map", expected);
+
+        mSD["foo"] = "bar";
+        expected = "<llsd><map><key>foo</key><string>bar</string></map></llsd>\n";
+        xml_test("1 element map", expected);
+
+        mSD["baz"] = LLSD();
+        expected = "<llsd><map><key>baz</key><undef /><key>foo</key><string>bar</string></map></llsd>\n";
+        xml_test("2 element map", expected);
+    }
+
+    template<> template<>
+    void sd_xml_object::test<6>()
+    {
+        // tests with binary
+        std::string expected;
+
+        // Generated by: echo -n 'hello' | openssl enc -e -base64
+        mSD = string_to_vector("hello");
+        expected = "<llsd><binary encoding=\"base64\">aGVsbG8=</binary></llsd>\n";
+        xml_test("binary", expected);
+
+        mSD = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0");
+        expected = "<llsd><binary encoding=\"base64\">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBlNDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZmZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMyOXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>\n";
+        xml_test("binary", expected);
+    }
+
+    class TestLLSDSerializeData
+    {
+    public:
+        TestLLSDSerializeData();
+        ~TestLLSDSerializeData();
+
+        void doRoundTripTests(const std::string&);
+        void checkRoundTrip(const std::string&, const LLSD& v);
+
+        void setFormatterParser(LLPointer<LLSDFormatter> formatter, LLPointer<LLSDParser> parser)
+        {
+            mFormatter = [formatter](const LLSD& data, std::ostream& str)
+            {
+                formatter->format(data, str);
+            };
+            // this lambda must be mutable since otherwise the bound 'parser'
+            // is assumed to point to a const LLSDParser
+            mParser = [parser](std::istream& istr, LLSD& data, llssize max_bytes) mutable
+            {
+                // reset() call is needed since test code re-uses parser object
+                parser->reset();
+                return (parser->parse(istr, data, max_bytes) > 0);
+            };
+        }
+
+        void setParser(bool (*parser)(LLSD&, std::istream&, llssize))
+        {
+            // why does LLSDSerialize::deserialize() reverse the parse() params??
+            mParser = [parser](std::istream& istr, LLSD& data, llssize max_bytes)
+            {
+                return parser(data, istr, max_bytes);
+            };
+        }
+
+        FormatterFunction mFormatter;
+        ParserFunction mParser;
+    };
+
+    TestLLSDSerializeData::TestLLSDSerializeData()
+    {
+    }
+
+    TestLLSDSerializeData::~TestLLSDSerializeData()
+    {
+    }
+
+    void TestLLSDSerializeData::checkRoundTrip(const std::string& msg, const LLSD& v)
+    {
+        std::stringstream stream;
+        mFormatter(v, stream);
+        //LL_INFOS() << "checkRoundTrip: length " << stream.str().length() << LL_ENDL;
+        LLSD w;
+        mParser(stream, w, stream.str().size());
+
+        try
+        {
+            ensure_equals(msg, w, v);
+        }
+        catch (...)
+        {
+            std::cerr << "the serialized string was:" << std::endl;
+            std::cerr << stream.str() << std::endl;
+            throw;
+        }
+    }
+
+    static void fillmap(LLSD& root, U32 width, U32 depth)
+    {
+        if(depth == 0)
+        {
+            root["foo"] = "bar";
+            return;
+        }
+
+        for(U32 i = 0; i < width; ++i)
+        {
+            std::string key = llformat("child %d", i);
+            root[key] = LLSD::emptyMap();
+            fillmap(root[key], width, depth - 1);
+        }
+    }
+
+    void TestLLSDSerializeData::doRoundTripTests(const std::string& msg)
+    {
+        LLSD v;
+        checkRoundTrip(msg + " undefined", v);
+
+        v = true;
+        checkRoundTrip(msg + " true bool", v);
+
+        v = false;
+        checkRoundTrip(msg + " false bool", v);
+
+        v = 1;
+        checkRoundTrip(msg + " positive int", v);
+
+        v = 0;
+        checkRoundTrip(msg + " zero int", v);
+
+        v = -1;
+        checkRoundTrip(msg + " negative int", v);
+
+        v = 1234.5f;
+        checkRoundTrip(msg + " positive float", v);
+
+        v = 0.0f;
+        checkRoundTrip(msg + " zero float", v);
+
+        v = -1234.5f;
+        checkRoundTrip(msg + " negative float", v);
+
+        // FIXME: need a NaN test
+
+        v = LLUUID::null;
+        checkRoundTrip(msg + " null uuid", v);
+
+        LLUUID newUUID;
+        newUUID.generate();
+        v = newUUID;
+        checkRoundTrip(msg + " new uuid", v);
+
+        v = "";
+        checkRoundTrip(msg + " empty string", v);
+
+        v = "some string";
+        checkRoundTrip(msg + " non-empty string", v);
+
+        v =
 "Second Life is a 3-D virtual world entirely built and owned by its residents. "
 "Since opening to the public in 2003, it has grown explosively and today is "
 "inhabited by nearly 100,000 people from around the globe.\n"
@@ -390,437 +390,437 @@ namespace tut
 "currency exchanges.\n"
 "\n"
 "Welcome to Second Life. We look forward to seeing you in-world!\n"
-		;
-		checkRoundTrip(msg + " long string", v);
-
-		static const U32 block_size = 0x000020;
-		for (U32 block = 0x000000; block <= 0x10ffff; block += block_size)
-		{
-			std::ostringstream out;
-
-			for (U32 c = block; c < block + block_size; ++c)
-			{
-				if (c <= 0x000001f
-					&& c != 0x000009
-					&& c != 0x00000a)
-				{
-					// see XML standard, sections 2.2 and 4.1
-					continue;
-				}
-				if (0x00d800 <= c  &&  c <= 0x00dfff) { continue; }
-				if (0x00fdd0 <= c  &&  c <= 0x00fdef) { continue; }
-				if ((c & 0x00fffe) == 0x00fffe) { continue; }		
-					// see Unicode standard, section 15.8 
-
-				if (c <= 0x00007f)
-				{
-					out << (char)(c & 0x7f);
-				}
-				else if (c <= 0x0007ff)
-				{
-					out << (char)(0xc0 | ((c >> 6) & 0x1f));
-					out << (char)(0x80 | ((c >> 0) & 0x3f));
-				}
-				else if (c <= 0x00ffff)
-				{
-					out << (char)(0xe0 | ((c >> 12) & 0x0f));
-					out << (char)(0x80 | ((c >>  6) & 0x3f));
-					out << (char)(0x80 | ((c >>  0) & 0x3f));
-				}
-				else
-				{
-					out << (char)(0xf0 | ((c >> 18) & 0x07));
-					out << (char)(0x80 | ((c >> 12) & 0x3f));
-					out << (char)(0x80 | ((c >>  6) & 0x3f));
-					out << (char)(0x80 | ((c >>  0) & 0x3f));
-				}
-			}
-
-			v = out.str();
-
-			std::ostringstream blockmsg;
-			blockmsg << msg << " unicode string block 0x" << std::hex << block; 
-			checkRoundTrip(blockmsg.str(), v);
-		}
-
-		LLDate epoch;
-		v = epoch;
-		checkRoundTrip(msg + " epoch date", v);
-
-		LLDate aDay("2002-12-07T05:07:15.00Z");
-		v = aDay;
-		checkRoundTrip(msg + " date", v);
-
-		LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/");
-		v = path;
-		checkRoundTrip(msg + " url", v);
-
-		const char source[] = "it must be a blue moon again";
-		std::vector<U8> data;
-		// note, includes terminating '\0'
-		copy(&source[0], &source[sizeof(source)], back_inserter(data));
-
-		v = data;
-		checkRoundTrip(msg + " binary", v);
-
-		v = LLSD::emptyMap();
-		checkRoundTrip(msg + " empty map", v);
-
-		v = LLSD::emptyMap();
-		v["name"] = "luke";		//v.insert("name", "luke");
-		v["age"] = 3;			//v.insert("age", 3);
-		checkRoundTrip(msg + " map", v);
-
-		v.clear();
-		v["a"]["1"] = true;
-		v["b"]["0"] = false;
-		checkRoundTrip(msg + " nested maps", v);
-
-		v = LLSD::emptyArray();
-		checkRoundTrip(msg + " empty array", v);
-
-		v = LLSD::emptyArray();
-		v.append("ali");
-		v.append(28);
-		checkRoundTrip(msg + " array", v);
-
-		v.clear();
-		v[0][0] = true;
-		v[1][0] = false;
-		checkRoundTrip(msg + " nested arrays", v);
-
-		v = LLSD::emptyMap();
-		fillmap(v, 10, 3); // 10^6 maps
-		checkRoundTrip(msg + " many nested maps", v);
-	}
-
-	typedef tut::test_group<TestLLSDSerializeData> TestLLSDSerializeGroup;
-	typedef TestLLSDSerializeGroup::object TestLLSDSerializeObject;
-	TestLLSDSerializeGroup gTestLLSDSerializeGroup("llsd serialization");
-
-	template<> template<> 
-	void TestLLSDSerializeObject::test<1>()
-	{
-		setFormatterParser(new LLSDNotationFormatter(false, "", LLSDFormatter::OPTIONS_PRETTY_BINARY),
-						   new LLSDNotationParser());
-		doRoundTripTests("pretty binary notation serialization");
-	}
-
-	template<> template<> 
-	void TestLLSDSerializeObject::test<2>()
-	{
-		setFormatterParser(new LLSDNotationFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
-						   new LLSDNotationParser());
-		doRoundTripTests("raw binary notation serialization");
-	}
-
-	template<> template<> 
-	void TestLLSDSerializeObject::test<3>()
-	{
-		setFormatterParser(new LLSDXMLFormatter(), new LLSDXMLParser());
-		doRoundTripTests("xml serialization");
-	}
-
-	template<> template<> 
-	void TestLLSDSerializeObject::test<4>()
-	{
-		setFormatterParser(new LLSDBinaryFormatter(), new LLSDBinaryParser());
-		doRoundTripTests("binary serialization");
-	}
-
-	template<> template<>
-	void TestLLSDSerializeObject::test<5>()
-	{
-		mFormatter = [](const LLSD& sd, std::ostream& str)
-		{
-			LLSDSerialize::serialize(sd, str, LLSDSerialize::LLSD_BINARY);
-		};
-		setParser(LLSDSerialize::deserialize);
-		doRoundTripTests("serialize(LLSD_BINARY)");
-	};
-
-	template<> template<>
-	void TestLLSDSerializeObject::test<6>()
-	{
-		mFormatter = [](const LLSD& sd, std::ostream& str)
-		{
-			LLSDSerialize::serialize(sd, str, LLSDSerialize::LLSD_XML);
-		};
-		setParser(LLSDSerialize::deserialize);
-		doRoundTripTests("serialize(LLSD_XML)");
-	};
-
-	template<> template<>
-	void TestLLSDSerializeObject::test<7>()
-	{
-		mFormatter = [](const LLSD& sd, std::ostream& str)
-		{
-			LLSDSerialize::serialize(sd, str, LLSDSerialize::LLSD_NOTATION);
-		};
-		setParser(LLSDSerialize::deserialize);
-		// In this test, serialize(LLSD_NOTATION) emits a header recognized by
-		// deserialize().
-		doRoundTripTests("serialize(LLSD_NOTATION)");
-	};
-
-	template<> template<>
-	void TestLLSDSerializeObject::test<8>()
-	{
-		setFormatterParser(new LLSDNotationFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
-						   new LLSDNotationParser());
-		setParser(LLSDSerialize::deserialize);
-		// This is an interesting test because LLSDNotationFormatter does not
-		// emit an llsd/notation header.
-		doRoundTripTests("LLSDNotationFormatter -> deserialize");
-	};
-
-	template<> template<>
-	void TestLLSDSerializeObject::test<9>()
-	{
-		setFormatterParser(new LLSDXMLFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
-						   new LLSDXMLParser());
-		setParser(LLSDSerialize::deserialize);
-		// This is an interesting test because LLSDXMLFormatter does not
-		// emit an LLSD/XML header.
-		doRoundTripTests("LLSDXMLFormatter -> deserialize");
-	};
+        ;
+        checkRoundTrip(msg + " long string", v);
+
+        static const U32 block_size = 0x000020;
+        for (U32 block = 0x000000; block <= 0x10ffff; block += block_size)
+        {
+            std::ostringstream out;
+
+            for (U32 c = block; c < block + block_size; ++c)
+            {
+                if (c <= 0x000001f
+                    && c != 0x000009
+                    && c != 0x00000a)
+                {
+                    // see XML standard, sections 2.2 and 4.1
+                    continue;
+                }
+                if (0x00d800 <= c  &&  c <= 0x00dfff) { continue; }
+                if (0x00fdd0 <= c  &&  c <= 0x00fdef) { continue; }
+                if ((c & 0x00fffe) == 0x00fffe) { continue; }
+                    // see Unicode standard, section 15.8
+
+                if (c <= 0x00007f)
+                {
+                    out << (char)(c & 0x7f);
+                }
+                else if (c <= 0x0007ff)
+                {
+                    out << (char)(0xc0 | ((c >> 6) & 0x1f));
+                    out << (char)(0x80 | ((c >> 0) & 0x3f));
+                }
+                else if (c <= 0x00ffff)
+                {
+                    out << (char)(0xe0 | ((c >> 12) & 0x0f));
+                    out << (char)(0x80 | ((c >>  6) & 0x3f));
+                    out << (char)(0x80 | ((c >>  0) & 0x3f));
+                }
+                else
+                {
+                    out << (char)(0xf0 | ((c >> 18) & 0x07));
+                    out << (char)(0x80 | ((c >> 12) & 0x3f));
+                    out << (char)(0x80 | ((c >>  6) & 0x3f));
+                    out << (char)(0x80 | ((c >>  0) & 0x3f));
+                }
+            }
+
+            v = out.str();
+
+            std::ostringstream blockmsg;
+            blockmsg << msg << " unicode string block 0x" << std::hex << block;
+            checkRoundTrip(blockmsg.str(), v);
+        }
+
+        LLDate epoch;
+        v = epoch;
+        checkRoundTrip(msg + " epoch date", v);
+
+        LLDate aDay("2002-12-07T05:07:15.00Z");
+        v = aDay;
+        checkRoundTrip(msg + " date", v);
+
+        LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/");
+        v = path;
+        checkRoundTrip(msg + " url", v);
+
+        const char source[] = "it must be a blue moon again";
+        std::vector<U8> data;
+        // note, includes terminating '\0'
+        copy(&source[0], &source[sizeof(source)], back_inserter(data));
+
+        v = data;
+        checkRoundTrip(msg + " binary", v);
+
+        v = LLSD::emptyMap();
+        checkRoundTrip(msg + " empty map", v);
+
+        v = LLSD::emptyMap();
+        v["name"] = "luke";     //v.insert("name", "luke");
+        v["age"] = 3;           //v.insert("age", 3);
+        checkRoundTrip(msg + " map", v);
+
+        v.clear();
+        v["a"]["1"] = true;
+        v["b"]["0"] = false;
+        checkRoundTrip(msg + " nested maps", v);
+
+        v = LLSD::emptyArray();
+        checkRoundTrip(msg + " empty array", v);
+
+        v = LLSD::emptyArray();
+        v.append("ali");
+        v.append(28);
+        checkRoundTrip(msg + " array", v);
+
+        v.clear();
+        v[0][0] = true;
+        v[1][0] = false;
+        checkRoundTrip(msg + " nested arrays", v);
+
+        v = LLSD::emptyMap();
+        fillmap(v, 10, 3); // 10^6 maps
+        checkRoundTrip(msg + " many nested maps", v);
+    }
+
+    typedef tut::test_group<TestLLSDSerializeData> TestLLSDSerializeGroup;
+    typedef TestLLSDSerializeGroup::object TestLLSDSerializeObject;
+    TestLLSDSerializeGroup gTestLLSDSerializeGroup("llsd serialization");
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<1>()
+    {
+        setFormatterParser(new LLSDNotationFormatter(false, "", LLSDFormatter::OPTIONS_PRETTY_BINARY),
+                           new LLSDNotationParser());
+        doRoundTripTests("pretty binary notation serialization");
+    }
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<2>()
+    {
+        setFormatterParser(new LLSDNotationFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
+                           new LLSDNotationParser());
+        doRoundTripTests("raw binary notation serialization");
+    }
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<3>()
+    {
+        setFormatterParser(new LLSDXMLFormatter(), new LLSDXMLParser());
+        doRoundTripTests("xml serialization");
+    }
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<4>()
+    {
+        setFormatterParser(new LLSDBinaryFormatter(), new LLSDBinaryParser());
+        doRoundTripTests("binary serialization");
+    }
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<5>()
+    {
+        mFormatter = [](const LLSD& sd, std::ostream& str)
+        {
+            LLSDSerialize::serialize(sd, str, LLSDSerialize::LLSD_BINARY);
+        };
+        setParser(LLSDSerialize::deserialize);
+        doRoundTripTests("serialize(LLSD_BINARY)");
+    };
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<6>()
+    {
+        mFormatter = [](const LLSD& sd, std::ostream& str)
+        {
+            LLSDSerialize::serialize(sd, str, LLSDSerialize::LLSD_XML);
+        };
+        setParser(LLSDSerialize::deserialize);
+        doRoundTripTests("serialize(LLSD_XML)");
+    };
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<7>()
+    {
+        mFormatter = [](const LLSD& sd, std::ostream& str)
+        {
+            LLSDSerialize::serialize(sd, str, LLSDSerialize::LLSD_NOTATION);
+        };
+        setParser(LLSDSerialize::deserialize);
+        // In this test, serialize(LLSD_NOTATION) emits a header recognized by
+        // deserialize().
+        doRoundTripTests("serialize(LLSD_NOTATION)");
+    };
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<8>()
+    {
+        setFormatterParser(new LLSDNotationFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
+                           new LLSDNotationParser());
+        setParser(LLSDSerialize::deserialize);
+        // This is an interesting test because LLSDNotationFormatter does not
+        // emit an llsd/notation header.
+        doRoundTripTests("LLSDNotationFormatter -> deserialize");
+    };
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<9>()
+    {
+        setFormatterParser(new LLSDXMLFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
+                           new LLSDXMLParser());
+        setParser(LLSDSerialize::deserialize);
+        // This is an interesting test because LLSDXMLFormatter does not
+        // emit an LLSD/XML header.
+        doRoundTripTests("LLSDXMLFormatter -> deserialize");
+    };
 
 /*==========================================================================*|
-	// We do not expect this test to succeed. Without a header, neither
-	// notation LLSD nor binary LLSD reliably start with a distinct character,
-	// the way XML LLSD starts with '<'. By convention, we default to notation
-	// rather than binary.
-	template<> template<>
-	void TestLLSDSerializeObject::test<10>()
-	{
-		setFormatterParser(new LLSDBinaryFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
-						   new LLSDBinaryParser());
-		setParser(LLSDSerialize::deserialize);
-		// This is an interesting test because LLSDBinaryFormatter does not
-		// emit an LLSD/Binary header.
-		doRoundTripTests("LLSDBinaryFormatter -> deserialize");
-	};
+    // We do not expect this test to succeed. Without a header, neither
+    // notation LLSD nor binary LLSD reliably start with a distinct character,
+    // the way XML LLSD starts with '<'. By convention, we default to notation
+    // rather than binary.
+    template<> template<>
+    void TestLLSDSerializeObject::test<10>()
+    {
+        setFormatterParser(new LLSDBinaryFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
+                           new LLSDBinaryParser());
+        setParser(LLSDSerialize::deserialize);
+        // This is an interesting test because LLSDBinaryFormatter does not
+        // emit an LLSD/Binary header.
+        doRoundTripTests("LLSDBinaryFormatter -> deserialize");
+    };
 |*==========================================================================*/
 
-	/**
-	 * @class TestLLSDParsing
-	 * @brief Base class for of a parse tester.
-	 */
-	template <class parser_t>
-	class TestLLSDParsing
-	{
-	public:
-		TestLLSDParsing()
-		{
-			mParser = new parser_t;
-		}
-
-		void ensureParse(
-			const std::string& msg,
-			const std::string& in,
-			const LLSD& expected_value,
-			S32 expected_count,
-			S32 depth_limit = -1)
-		{
-			std::stringstream input;
-			input.str(in);
-
-			LLSD parsed_result;
-			mParser->reset();	// reset() call is needed since test code re-uses mParser
-			S32 parsed_count = mParser->parse(input, parsed_result, in.size(), depth_limit);
-			ensure_equals(msg.c_str(), parsed_result, expected_value);
-
-			// This count check is really only useful for expected
-			// parse failures, since the ensures equal will already
-			// require equality.
-			std::string count_msg(msg);
-			count_msg += " (count)";
-			ensure_equals(count_msg, parsed_count, expected_count);
-		}
-
-		LLPointer<parser_t> mParser;
-	};
-
-
-	/**
-	 * @class TestLLSDXMLParsing
-	 * @brief Concrete instance of a parse tester.
-	 */
-	class TestLLSDXMLParsing : public TestLLSDParsing<LLSDXMLParser>
-	{
-	public:
-		TestLLSDXMLParsing() {}
-	};
-
-	typedef tut::test_group<TestLLSDXMLParsing> TestLLSDXMLParsingGroup;
-	typedef TestLLSDXMLParsingGroup::object TestLLSDXMLParsingObject;
-	TestLLSDXMLParsingGroup gTestLLSDXMLParsingGroup("llsd XML parsing");
-
-	template<> template<> 
-	void TestLLSDXMLParsingObject::test<1>()
-	{
-		// test handling of xml not recognized as llsd results in an
-		// LLSD Undefined
-		ensureParse(
-			"malformed xml",
-			"<llsd><string>ha ha</string>",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"not llsd",
-			"<html><body><p>ha ha</p></body></html>",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"value without llsd",
-			"<string>ha ha</string>",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"key without llsd",
-			"<key>ha ha</key>",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-
-	template<> template<> 
-	void TestLLSDXMLParsingObject::test<2>()
-	{
-		// test handling of unrecognized or unparseable llsd values
-		LLSD v;
-		v["amy"] = 23;
-		v["bob"] = LLSD();
-		v["cam"] = 1.23;
-
-		ensureParse(
-			"unknown data type",
-			"<llsd><map>"
-				"<key>amy</key><integer>23</integer>"
-				"<key>bob</key><bigint>99999999999999999</bigint>"
-				"<key>cam</key><real>1.23</real>"
-			"</map></llsd>",
-			v,
-			v.size() + 1);
-	}
-
-	template<> template<> 
-	void TestLLSDXMLParsingObject::test<3>()
-	{
-		// test handling of nested bad data
-
-		LLSD v;
-		v["amy"] = 23;
-		v["cam"] = 1.23;
-
-		ensureParse(
-			"map with html",
-			"<llsd><map>"
-				"<key>amy</key><integer>23</integer>"
-				"<html><body>ha ha</body></html>"
-				"<key>cam</key><real>1.23</real>"
-			"</map></llsd>",
-			v,
-			v.size() + 1);
-
-		v.clear();
-		v["amy"] = 23;
-		v["cam"] = 1.23;
-		ensureParse(
-			"map with value for key",
-			"<llsd><map>"
-				"<key>amy</key><integer>23</integer>"
-				"<string>ha ha</string>"
-				"<key>cam</key><real>1.23</real>"
-			"</map></llsd>",
-			v,
-			v.size() + 1);
-
-		v.clear();
-		v["amy"] = 23;
-		v["bob"] = LLSD::emptyMap();
-		v["cam"] = 1.23;
-		ensureParse(
-			"map with map of html",
-			"<llsd><map>"
-				"<key>amy</key><integer>23</integer>"
-				"<key>bob</key>"
-				"<map>"
-					"<html><body>ha ha</body></html>"
-				"</map>"
-				"<key>cam</key><real>1.23</real>"
-			"</map></llsd>",
-			v,
-			v.size() + 1);
-
-		v.clear();
-		v[0] = 23;
-		v[1] = LLSD();
-		v[2] = 1.23;
-
-		ensureParse(
-			"array value of html",
-			"<llsd><array>"
-				"<integer>23</integer>"
-				"<html><body>ha ha</body></html>"
-				"<real>1.23</real>"
-			"</array></llsd>",
-			v,
-			v.size() + 1);
-
-		v.clear();
-		v[0] = 23;
-		v[1] = LLSD::emptyMap();
-		v[2] = 1.23;
-		ensureParse(
-			"array with map of html",
-			"<llsd><array>"
-				"<integer>23</integer>"
-				"<map>"
-					"<html><body>ha ha</body></html>"
-				"</map>"
-				"<real>1.23</real>"
-			"</array></llsd>",
-			v,
-			v.size() + 1);
-	}
-
-	template<> template<> 
-	void TestLLSDXMLParsingObject::test<4>()
-	{
-		// test handling of binary object in XML
-		std::string xml;
-		LLSD expected;
-
-		// Generated by: echo -n 'hello' | openssl enc -e -base64
-		expected = string_to_vector("hello");
-		xml = "<llsd><binary encoding=\"base64\">aGVsbG8=</binary></llsd>\n";
-		ensureParse(
-			"the word 'hello' packed in binary encoded base64",
-			xml,
-			expected,
-			1);
-
-		expected = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0");
-		xml = "<llsd><binary encoding=\"base64\">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBlNDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZmZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMyOXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>\n";
-		ensureParse(
-			"a common binary blob for object -> agent offline inv transfer",
-			xml,
-			expected,
-			1);
-
-		expected = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0");
-		xml = "<llsd><binary encoding=\"base64\">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBl\n";
-		xml += "NDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5\n";
-		xml += "LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZm\n";
-		xml += "ZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMy\n";
-		xml += "OXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>\n";
-		ensureParse(
-			"a common binary blob for object -> agent offline inv transfer",
-			xml,
-			expected,
-			1);
-	}
+    /**
+     * @class TestLLSDParsing
+     * @brief Base class for of a parse tester.
+     */
+    template <class parser_t>
+    class TestLLSDParsing
+    {
+    public:
+        TestLLSDParsing()
+        {
+            mParser = new parser_t;
+        }
+
+        void ensureParse(
+            const std::string& msg,
+            const std::string& in,
+            const LLSD& expected_value,
+            S32 expected_count,
+            S32 depth_limit = -1)
+        {
+            std::stringstream input;
+            input.str(in);
+
+            LLSD parsed_result;
+            mParser->reset();   // reset() call is needed since test code re-uses mParser
+            S32 parsed_count = mParser->parse(input, parsed_result, in.size(), depth_limit);
+            ensure_equals(msg.c_str(), parsed_result, expected_value);
+
+            // This count check is really only useful for expected
+            // parse failures, since the ensures equal will already
+            // require equality.
+            std::string count_msg(msg);
+            count_msg += " (count)";
+            ensure_equals(count_msg, parsed_count, expected_count);
+        }
+
+        LLPointer<parser_t> mParser;
+    };
+
+
+    /**
+     * @class TestLLSDXMLParsing
+     * @brief Concrete instance of a parse tester.
+     */
+    class TestLLSDXMLParsing : public TestLLSDParsing<LLSDXMLParser>
+    {
+    public:
+        TestLLSDXMLParsing() {}
+    };
+
+    typedef tut::test_group<TestLLSDXMLParsing> TestLLSDXMLParsingGroup;
+    typedef TestLLSDXMLParsingGroup::object TestLLSDXMLParsingObject;
+    TestLLSDXMLParsingGroup gTestLLSDXMLParsingGroup("llsd XML parsing");
+
+    template<> template<>
+    void TestLLSDXMLParsingObject::test<1>()
+    {
+        // test handling of xml not recognized as llsd results in an
+        // LLSD Undefined
+        ensureParse(
+            "malformed xml",
+            "<llsd><string>ha ha</string>",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "not llsd",
+            "<html><body><p>ha ha</p></body></html>",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "value without llsd",
+            "<string>ha ha</string>",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "key without llsd",
+            "<key>ha ha</key>",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+
+    template<> template<>
+    void TestLLSDXMLParsingObject::test<2>()
+    {
+        // test handling of unrecognized or unparseable llsd values
+        LLSD v;
+        v["amy"] = 23;
+        v["bob"] = LLSD();
+        v["cam"] = 1.23;
+
+        ensureParse(
+            "unknown data type",
+            "<llsd><map>"
+                "<key>amy</key><integer>23</integer>"
+                "<key>bob</key><bigint>99999999999999999</bigint>"
+                "<key>cam</key><real>1.23</real>"
+            "</map></llsd>",
+            v,
+            v.size() + 1);
+    }
+
+    template<> template<>
+    void TestLLSDXMLParsingObject::test<3>()
+    {
+        // test handling of nested bad data
+
+        LLSD v;
+        v["amy"] = 23;
+        v["cam"] = 1.23;
+
+        ensureParse(
+            "map with html",
+            "<llsd><map>"
+                "<key>amy</key><integer>23</integer>"
+                "<html><body>ha ha</body></html>"
+                "<key>cam</key><real>1.23</real>"
+            "</map></llsd>",
+            v,
+            v.size() + 1);
+
+        v.clear();
+        v["amy"] = 23;
+        v["cam"] = 1.23;
+        ensureParse(
+            "map with value for key",
+            "<llsd><map>"
+                "<key>amy</key><integer>23</integer>"
+                "<string>ha ha</string>"
+                "<key>cam</key><real>1.23</real>"
+            "</map></llsd>",
+            v,
+            v.size() + 1);
+
+        v.clear();
+        v["amy"] = 23;
+        v["bob"] = LLSD::emptyMap();
+        v["cam"] = 1.23;
+        ensureParse(
+            "map with map of html",
+            "<llsd><map>"
+                "<key>amy</key><integer>23</integer>"
+                "<key>bob</key>"
+                "<map>"
+                    "<html><body>ha ha</body></html>"
+                "</map>"
+                "<key>cam</key><real>1.23</real>"
+            "</map></llsd>",
+            v,
+            v.size() + 1);
+
+        v.clear();
+        v[0] = 23;
+        v[1] = LLSD();
+        v[2] = 1.23;
+
+        ensureParse(
+            "array value of html",
+            "<llsd><array>"
+                "<integer>23</integer>"
+                "<html><body>ha ha</body></html>"
+                "<real>1.23</real>"
+            "</array></llsd>",
+            v,
+            v.size() + 1);
+
+        v.clear();
+        v[0] = 23;
+        v[1] = LLSD::emptyMap();
+        v[2] = 1.23;
+        ensureParse(
+            "array with map of html",
+            "<llsd><array>"
+                "<integer>23</integer>"
+                "<map>"
+                    "<html><body>ha ha</body></html>"
+                "</map>"
+                "<real>1.23</real>"
+            "</array></llsd>",
+            v,
+            v.size() + 1);
+    }
+
+    template<> template<>
+    void TestLLSDXMLParsingObject::test<4>()
+    {
+        // test handling of binary object in XML
+        std::string xml;
+        LLSD expected;
+
+        // Generated by: echo -n 'hello' | openssl enc -e -base64
+        expected = string_to_vector("hello");
+        xml = "<llsd><binary encoding=\"base64\">aGVsbG8=</binary></llsd>\n";
+        ensureParse(
+            "the word 'hello' packed in binary encoded base64",
+            xml,
+            expected,
+            1);
+
+        expected = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0");
+        xml = "<llsd><binary encoding=\"base64\">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBlNDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZmZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMyOXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>\n";
+        ensureParse(
+            "a common binary blob for object -> agent offline inv transfer",
+            xml,
+            expected,
+            1);
+
+        expected = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0");
+        xml = "<llsd><binary encoding=\"base64\">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBl\n";
+        xml += "NDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5\n";
+        xml += "LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZm\n";
+        xml += "ZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMy\n";
+        xml += "OXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>\n";
+        ensureParse(
+            "a common binary blob for object -> agent offline inv transfer",
+            xml,
+            expected,
+            1);
+    }
 
     template<> template<>
     void TestLLSDXMLParsingObject::test<5>()
@@ -858,272 +858,272 @@ namespace tut
     }
 
 
-	/*
-	TODO:
-		test XML parsing
-			binary with unrecognized encoding
-			nested LLSD tags
-			multiple values inside an LLSD
-	*/
-
-
-	/**
-	 * @class TestLLSDNotationParsing
-	 * @brief Concrete instance of a parse tester.
-	 */
-	class TestLLSDNotationParsing : public TestLLSDParsing<LLSDNotationParser>
-	{
-	public:
-		TestLLSDNotationParsing() {}
-	};
-
-	typedef tut::test_group<TestLLSDNotationParsing> TestLLSDNotationParsingGroup;
-	typedef TestLLSDNotationParsingGroup::object TestLLSDNotationParsingObject;
-	TestLLSDNotationParsingGroup gTestLLSDNotationParsingGroup(
-		"llsd notation parsing");
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<1>()
-	{
-		// test handling of xml not recognized as llsd results in an
-		// LLSD Undefined
-		ensureParse(
-			"malformed notation map",
-			"{'ha ha'",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"malformed notation array",
-			"['ha ha'",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"malformed notation string",
-			"'ha ha",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"bad notation noise",
-			"g48ejlnfr",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<2>()
-	{
-		ensureParse("valid undef", "!", LLSD(), 1);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<3>()
-	{
-		LLSD val = false;
-		ensureParse("valid boolean false 0", "false", val, 1);
-		ensureParse("valid boolean false 1", "f", val, 1);
-		ensureParse("valid boolean false 2", "0", val, 1);
-		ensureParse("valid boolean false 3", "F", val, 1);
-		ensureParse("valid boolean false 4", "FALSE", val, 1);
-		val = true;
-		ensureParse("valid boolean true 0", "true", val, 1);
-		ensureParse("valid boolean true 1", "t", val, 1);
-		ensureParse("valid boolean true 2", "1", val, 1);
-		ensureParse("valid boolean true 3", "T", val, 1);
-		ensureParse("valid boolean true 4", "TRUE", val, 1);
-
-		val.clear();
-		ensureParse("invalid true", "TR", val, LLSDParser::PARSE_FAILURE);
-		ensureParse("invalid false", "FAL", val, LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<4>()
-	{
-		LLSD val = 123;
-		ensureParse("valid integer", "i123", val, 1);
-		val.clear();
-		ensureParse("invalid integer", "421", val, LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<5>()
-	{
-		LLSD val = 456.7;
-		ensureParse("valid real", "r456.7", val, 1);
-		val.clear();
-		ensureParse("invalid real", "456.7", val, LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<6>()
-	{
-		LLUUID id;
-		LLSD val = id;
-		ensureParse(
-			"unparseable uuid",
-			"u123",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		id.generate();
-		val = id;
-		std::string uuid_str("u");
-		uuid_str += id.asString();
-		ensureParse("valid uuid", uuid_str.c_str(), val, 1);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<7>()
-	{
-		LLSD val = std::string("foolish");
-		ensureParse("valid string 1", "\"foolish\"", val, 1);
-		val = std::string("g'day");
-		ensureParse("valid string 2", "\"g'day\"", val, 1);
-		val = std::string("have a \"nice\" day");
-		ensureParse("valid string 3", "'have a \"nice\" day'", val, 1);
-		val = std::string("whatever");
-		ensureParse("valid string 4", "s(8)\"whatever\"", val, 1);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<8>()
-	{
-		ensureParse(
-			"invalid string 1",
-			"s(7)\"whatever\"",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"invalid string 2",
-			"s(9)\"whatever\"",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<9>()
-	{
-		LLSD val = LLURI("http://www.google.com");
-		ensureParse("valid uri", "l\"http://www.google.com\"", val, 1);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<10>()
-	{
-		LLSD val = LLDate("2007-12-28T09:22:53.10Z");
-		ensureParse("valid date", "d\"2007-12-28T09:22:53.10Z\"", val, 1);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<11>()
-	{
-		std::vector<U8> vec;
-		vec.push_back((U8)'a'); vec.push_back((U8)'b'); vec.push_back((U8)'c');
-		vec.push_back((U8)'3'); vec.push_back((U8)'2'); vec.push_back((U8)'1');
-		LLSD val = vec;
-		ensureParse("valid binary b64", "b64\"YWJjMzIx\"", val, 1);
-		ensureParse("valid bainry b16", "b16\"616263333231\"", val, 1);
-		ensureParse("valid bainry raw", "b(6)\"abc321\"", val, 1);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<12>()
-	{
-		ensureParse(
-			"invalid -- binary length specified too long",
-			"b(7)\"abc321\"",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"invalid -- binary length specified way too long",
-			"b(1000000)\"abc321\"",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<13>()
-	{
-		LLSD val;
-		val["amy"] = 23;
-		val["bob"] = LLSD();
-		val["cam"] = 1.23;
-		ensureParse("simple map", "{'amy':i23,'bob':!,'cam':r1.23}", val, 4);
-
-		val["bob"] = LLSD::emptyMap();
-		val["bob"]["vehicle"] = std::string("bicycle");
-		ensureParse(
-			"nested map",
-			"{'amy':i23,'bob':{'vehicle':'bicycle'},'cam':r1.23}",
-			val,
-			5);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<14>()
-	{
-		LLSD val;
-		val.append(23);
-		val.append(LLSD());
-		val.append(1.23);
-		ensureParse("simple array", "[i23,!,r1.23]", val, 4);
-		val[1] = LLSD::emptyArray();
-		val[1].append("bicycle");
-		ensureParse("nested array", "[i23,['bicycle'],r1.23]", val, 5);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<15>()
-	{
-		LLSD val;
-		val["amy"] = 23;
-		val["bob"]["dogs"] = LLSD::emptyArray();
-		val["bob"]["dogs"].append(LLSD::emptyMap());
-		val["bob"]["dogs"][0]["name"] = std::string("groove");
-		val["bob"]["dogs"][0]["breed"] = std::string("samoyed");
-		val["bob"]["dogs"].append(LLSD::emptyMap());
-		val["bob"]["dogs"][1]["name"] = std::string("greyley");
-		val["bob"]["dogs"][1]["breed"] = std::string("chow/husky");
-		val["cam"] = 1.23;
-		ensureParse(
-			"nested notation",
-			"{'amy':i23,"
-			" 'bob':{'dogs':["
-			         "{'name':'groove', 'breed':'samoyed'},"
-			         "{'name':'greyley', 'breed':'chow/husky'}]},"
-			" 'cam':r1.23}",
-			val,
-			11);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<16>()
-	{
-		// text to make sure that incorrect sizes bail because 
-		std::string bad_str("s(5)\"hi\"");
-		ensureParse(
-			"size longer than bytes left",
-			bad_str,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<17>()
-	{
-		// text to make sure that incorrect sizes bail because 
-		std::string bad_bin("b(5)\"hi\"");
-		ensureParse(
-			"size longer than bytes left",
-			bad_bin,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
+    /*
+    TODO:
+        test XML parsing
+            binary with unrecognized encoding
+            nested LLSD tags
+            multiple values inside an LLSD
+    */
+
+
+    /**
+     * @class TestLLSDNotationParsing
+     * @brief Concrete instance of a parse tester.
+     */
+    class TestLLSDNotationParsing : public TestLLSDParsing<LLSDNotationParser>
+    {
+    public:
+        TestLLSDNotationParsing() {}
+    };
+
+    typedef tut::test_group<TestLLSDNotationParsing> TestLLSDNotationParsingGroup;
+    typedef TestLLSDNotationParsingGroup::object TestLLSDNotationParsingObject;
+    TestLLSDNotationParsingGroup gTestLLSDNotationParsingGroup(
+        "llsd notation parsing");
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<1>()
+    {
+        // test handling of xml not recognized as llsd results in an
+        // LLSD Undefined
+        ensureParse(
+            "malformed notation map",
+            "{'ha ha'",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "malformed notation array",
+            "['ha ha'",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "malformed notation string",
+            "'ha ha",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "bad notation noise",
+            "g48ejlnfr",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<2>()
+    {
+        ensureParse("valid undef", "!", LLSD(), 1);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<3>()
+    {
+        LLSD val = false;
+        ensureParse("valid boolean false 0", "false", val, 1);
+        ensureParse("valid boolean false 1", "f", val, 1);
+        ensureParse("valid boolean false 2", "0", val, 1);
+        ensureParse("valid boolean false 3", "F", val, 1);
+        ensureParse("valid boolean false 4", "FALSE", val, 1);
+        val = true;
+        ensureParse("valid boolean true 0", "true", val, 1);
+        ensureParse("valid boolean true 1", "t", val, 1);
+        ensureParse("valid boolean true 2", "1", val, 1);
+        ensureParse("valid boolean true 3", "T", val, 1);
+        ensureParse("valid boolean true 4", "TRUE", val, 1);
+
+        val.clear();
+        ensureParse("invalid true", "TR", val, LLSDParser::PARSE_FAILURE);
+        ensureParse("invalid false", "FAL", val, LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<4>()
+    {
+        LLSD val = 123;
+        ensureParse("valid integer", "i123", val, 1);
+        val.clear();
+        ensureParse("invalid integer", "421", val, LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<5>()
+    {
+        LLSD val = 456.7;
+        ensureParse("valid real", "r456.7", val, 1);
+        val.clear();
+        ensureParse("invalid real", "456.7", val, LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<6>()
+    {
+        LLUUID id;
+        LLSD val = id;
+        ensureParse(
+            "unparseable uuid",
+            "u123",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        id.generate();
+        val = id;
+        std::string uuid_str("u");
+        uuid_str += id.asString();
+        ensureParse("valid uuid", uuid_str.c_str(), val, 1);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<7>()
+    {
+        LLSD val = std::string("foolish");
+        ensureParse("valid string 1", "\"foolish\"", val, 1);
+        val = std::string("g'day");
+        ensureParse("valid string 2", "\"g'day\"", val, 1);
+        val = std::string("have a \"nice\" day");
+        ensureParse("valid string 3", "'have a \"nice\" day'", val, 1);
+        val = std::string("whatever");
+        ensureParse("valid string 4", "s(8)\"whatever\"", val, 1);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<8>()
+    {
+        ensureParse(
+            "invalid string 1",
+            "s(7)\"whatever\"",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "invalid string 2",
+            "s(9)\"whatever\"",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<9>()
+    {
+        LLSD val = LLURI("http://www.google.com");
+        ensureParse("valid uri", "l\"http://www.google.com\"", val, 1);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<10>()
+    {
+        LLSD val = LLDate("2007-12-28T09:22:53.10Z");
+        ensureParse("valid date", "d\"2007-12-28T09:22:53.10Z\"", val, 1);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<11>()
+    {
+        std::vector<U8> vec;
+        vec.push_back((U8)'a'); vec.push_back((U8)'b'); vec.push_back((U8)'c');
+        vec.push_back((U8)'3'); vec.push_back((U8)'2'); vec.push_back((U8)'1');
+        LLSD val = vec;
+        ensureParse("valid binary b64", "b64\"YWJjMzIx\"", val, 1);
+        ensureParse("valid bainry b16", "b16\"616263333231\"", val, 1);
+        ensureParse("valid bainry raw", "b(6)\"abc321\"", val, 1);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<12>()
+    {
+        ensureParse(
+            "invalid -- binary length specified too long",
+            "b(7)\"abc321\"",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "invalid -- binary length specified way too long",
+            "b(1000000)\"abc321\"",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<13>()
+    {
+        LLSD val;
+        val["amy"] = 23;
+        val["bob"] = LLSD();
+        val["cam"] = 1.23;
+        ensureParse("simple map", "{'amy':i23,'bob':!,'cam':r1.23}", val, 4);
+
+        val["bob"] = LLSD::emptyMap();
+        val["bob"]["vehicle"] = std::string("bicycle");
+        ensureParse(
+            "nested map",
+            "{'amy':i23,'bob':{'vehicle':'bicycle'},'cam':r1.23}",
+            val,
+            5);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<14>()
+    {
+        LLSD val;
+        val.append(23);
+        val.append(LLSD());
+        val.append(1.23);
+        ensureParse("simple array", "[i23,!,r1.23]", val, 4);
+        val[1] = LLSD::emptyArray();
+        val[1].append("bicycle");
+        ensureParse("nested array", "[i23,['bicycle'],r1.23]", val, 5);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<15>()
+    {
+        LLSD val;
+        val["amy"] = 23;
+        val["bob"]["dogs"] = LLSD::emptyArray();
+        val["bob"]["dogs"].append(LLSD::emptyMap());
+        val["bob"]["dogs"][0]["name"] = std::string("groove");
+        val["bob"]["dogs"][0]["breed"] = std::string("samoyed");
+        val["bob"]["dogs"].append(LLSD::emptyMap());
+        val["bob"]["dogs"][1]["name"] = std::string("greyley");
+        val["bob"]["dogs"][1]["breed"] = std::string("chow/husky");
+        val["cam"] = 1.23;
+        ensureParse(
+            "nested notation",
+            "{'amy':i23,"
+            " 'bob':{'dogs':["
+                     "{'name':'groove', 'breed':'samoyed'},"
+                     "{'name':'greyley', 'breed':'chow/husky'}]},"
+            " 'cam':r1.23}",
+            val,
+            11);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<16>()
+    {
+        // text to make sure that incorrect sizes bail because
+        std::string bad_str("s(5)\"hi\"");
+        ensureParse(
+            "size longer than bytes left",
+            bad_str,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<17>()
+    {
+        // text to make sure that incorrect sizes bail because
+        std::string bad_bin("b(5)\"hi\"");
+        ensureParse(
+            "size longer than bytes left",
+            bad_bin,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
 
     template<> template<>
     void TestLLSDNotationParsingObject::test<18>()
     {
-        LLSD level_1 = LLSD::emptyMap();		level_1["level_2"] = 99;
-        LLSD level_0 = LLSD::emptyMap();		level_0["level_1"] = level_1;
+        LLSD level_1 = LLSD::emptyMap();        level_1["level_2"] = 99;
+        LLSD level_0 = LLSD::emptyMap();        level_0["level_1"] = level_1;
 
         LLSD deep = LLSD::emptyMap();
         deep["level_0"] = level_0;
@@ -1168,7 +1168,7 @@ namespace tut
     template<> template<>
     void TestLLSDNotationParsingObject::test<20>()
     {
-        LLSD end = LLSD::emptyMap();		  end["end"] = (S32)99;
+        LLSD end = LLSD::emptyMap();          end["end"] = (S32)99;
 
         LLSD level_49 = LLSD::emptyMap();     level_49["level_49"] = end;
         LLSD level_48 = LLSD::emptyMap();     level_48["level_48"] = level_49;
@@ -1259,536 +1259,536 @@ namespace tut
             9);
     }
 
-	/**
-	 * @class TestLLSDBinaryParsing
-	 * @brief Concrete instance of a parse tester.
-	 */
-	class TestLLSDBinaryParsing : public TestLLSDParsing<LLSDBinaryParser>
-	{
-	public:
-		TestLLSDBinaryParsing() {}
-	};
-
-	typedef tut::test_group<TestLLSDBinaryParsing> TestLLSDBinaryParsingGroup;
-	typedef TestLLSDBinaryParsingGroup::object TestLLSDBinaryParsingObject;
-	TestLLSDBinaryParsingGroup gTestLLSDBinaryParsingGroup(
-		"llsd binary parsing");
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<1>()
-	{
-		std::vector<U8> vec;
-		vec.resize(6);
-		vec[0] = 'a'; vec[1] = 'b'; vec[2] = 'c';
-		vec[3] = '3'; vec[4] = '2'; vec[5] = '1';
-		std::string string_expected((char*)&vec[0], vec.size());
-		LLSD value = string_expected;
-
-		vec.resize(11);
-		vec[0] = 's'; // for string
-		vec[5] = 'a'; vec[6] = 'b'; vec[7] = 'c';
-		vec[8] = '3'; vec[9] = '2'; vec[10] = '1';
-
-		uint32_t size = htonl(6);
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_good((char*)&vec[0], vec.size());
-		ensureParse("correct string parse", str_good, value, 1);
-
-		size = htonl(7);
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_1((char*)&vec[0], vec.size());
-		ensureParse(
-			"incorrect size string parse",
-			str_bad_1,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		size = htonl(100000);
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_2((char*)&vec[0], vec.size());
-		ensureParse(
-			"incorrect size string parse",
-			str_bad_2,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<2>()
-	{
-		std::vector<U8> vec;
-		vec.resize(6);
-		vec[0] = 'a'; vec[1] = 'b'; vec[2] = 'c';
-		vec[3] = '3'; vec[4] = '2'; vec[5] = '1';
-		LLSD value = vec;
-
-		vec.resize(11);
-		vec[0] = 'b';  // for binary
-		vec[5] = 'a'; vec[6] = 'b'; vec[7] = 'c';
-		vec[8] = '3'; vec[9] = '2'; vec[10] = '1';
-
-		uint32_t size = htonl(6);
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_good((char*)&vec[0], vec.size());
-		ensureParse("correct binary parse", str_good, value, 1);
-
-		size = htonl(7);
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_1((char*)&vec[0], vec.size());
-		ensureParse(
-			"incorrect size binary parse 1",
-			str_bad_1,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		size = htonl(100000);
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_2((char*)&vec[0], vec.size());
-		ensureParse(
-			"incorrect size binary parse 2",
-			str_bad_2,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<3>()
-	{
-		// test handling of xml not recognized as llsd results in an
-		// LLSD Undefined
-		ensureParse(
-			"malformed binary map",
-			"{'ha ha'",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"malformed binary array",
-			"['ha ha'",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"malformed binary string",
-			"'ha ha",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"bad noise",
-			"g48ejlnfr",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<4>()
-	{
-		ensureParse("valid undef", "!", LLSD(), 1);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<5>()
-	{
-		LLSD val = false;
-		ensureParse("valid boolean false 2", "0", val, 1);
-		val = true;
-		ensureParse("valid boolean true 2", "1", val, 1);
-
-		val.clear();
-		ensureParse("invalid true", "t", val, LLSDParser::PARSE_FAILURE);
-		ensureParse("invalid false", "f", val, LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<6>()
-	{
-		std::vector<U8> vec;
-		vec.push_back('{');
-		vec.resize(vec.size() + 4);
-		uint32_t size = htonl(1);
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		vec.push_back('k');
-		int key_size_loc = vec.size();
-		size = htonl(1); // 1 too short
-		vec.resize(vec.size() + 4);
-		memcpy(&vec[key_size_loc], &size, sizeof(uint32_t));
-		vec.push_back('a'); vec.push_back('m'); vec.push_back('y');
-		vec.push_back('i');
-		int integer_loc = vec.size();
-		vec.resize(vec.size() + 4);
-		uint32_t val_int = htonl(23);
-		memcpy(&vec[integer_loc], &val_int, sizeof(uint32_t));
-		std::string str_bad_1((char*)&vec[0], vec.size());
-		ensureParse(
-			"invalid key size",
-			str_bad_1,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		// check with correct size, but unterminated map (missing '}')
-		size = htonl(3); // correct size
-		memcpy(&vec[key_size_loc], &size, sizeof(uint32_t));
-		std::string str_bad_2((char*)&vec[0], vec.size());
-		ensureParse(
-			"valid key size, unterminated map",
-			str_bad_2,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		// check w/ correct size and correct map termination
-		LLSD val;
-		val["amy"] = 23;
-		vec.push_back('}');
-		std::string str_good((char*)&vec[0], vec.size());
-		ensureParse(
-			"valid map",
-			str_good,
-			val,
-			2);
-
-		// check w/ incorrect sizes and correct map termination
-		size = htonl(0); // 1 too few (for the map entry)
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_3((char*)&vec[0], vec.size());
-		ensureParse(
-			"invalid map too long",
-			str_bad_3,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		size = htonl(2); // 1 too many
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_4((char*)&vec[0], vec.size());
-		ensureParse(
-			"invalid map too short",
-			str_bad_4,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<7>()
-	{
-		std::vector<U8> vec;
-		vec.push_back('[');
-		vec.resize(vec.size() + 4);
-		uint32_t size = htonl(1); // 1 too short
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		vec.push_back('"'); vec.push_back('a'); vec.push_back('m');
-		vec.push_back('y'); vec.push_back('"'); vec.push_back('i');
-		int integer_loc = vec.size();
-		vec.resize(vec.size() + 4);
-		uint32_t val_int = htonl(23);
-		memcpy(&vec[integer_loc], &val_int, sizeof(uint32_t));
-
-		std::string str_bad_1((char*)&vec[0], vec.size());
-		ensureParse(
-			"invalid array size",
-			str_bad_1,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		// check with correct size, but unterminated map (missing ']')
-		size = htonl(2); // correct size
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_2((char*)&vec[0], vec.size());
-		ensureParse(
-			"unterminated array",
-			str_bad_2,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		// check w/ correct size and correct map termination
-		LLSD val;
-		val.append("amy");
-		val.append(23);
-		vec.push_back(']');
-		std::string str_good((char*)&vec[0], vec.size());
-		ensureParse(
-			"valid array",
-			str_good,
-			val,
-			3);
-
-		// check with too many elements
-		size = htonl(3); // 1 too long
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_3((char*)&vec[0], vec.size());
-		ensureParse(
-			"array too short",
-			str_bad_3,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<8>()
-	{
-		std::vector<U8> vec;
-		vec.push_back('{');
-		vec.resize(vec.size() + 4);
-		memset(&vec[1], 0, 4);
-		vec.push_back('}');
-		std::string str_good((char*)&vec[0], vec.size());
-		LLSD val = LLSD::emptyMap();
-		ensureParse(
-			"empty map",
-			str_good,
-			val,
-			1);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<9>()
-	{
-		std::vector<U8> vec;
-		vec.push_back('[');
-		vec.resize(vec.size() + 4);
-		memset(&vec[1], 0, 4);
-		vec.push_back(']');
-		std::string str_good((char*)&vec[0], vec.size());
-		LLSD val = LLSD::emptyArray();
-		ensureParse(
-			"empty array",
-			str_good,
-			val,
-			1);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<10>()
-	{
-		std::vector<U8> vec;
-		vec.push_back('l');
-		vec.resize(vec.size() + 4);
-		uint32_t size = htonl(14); // 1 too long
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		vec.push_back('h'); vec.push_back('t'); vec.push_back('t');
-		vec.push_back('p'); vec.push_back(':'); vec.push_back('/');
-		vec.push_back('/'); vec.push_back('s'); vec.push_back('l');
-		vec.push_back('.'); vec.push_back('c'); vec.push_back('o');
-		vec.push_back('m');
-		std::string str_bad((char*)&vec[0], vec.size());
-		ensureParse(
-			"invalid uri length size",
-			str_bad,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		LLSD val;
-		val = LLURI("http://sl.com");
-		size = htonl(13); // correct length
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_good((char*)&vec[0], vec.size());
-		ensureParse(
-			"valid key size",
-			str_good,
-			val,
-			1);
-	}
+    /**
+     * @class TestLLSDBinaryParsing
+     * @brief Concrete instance of a parse tester.
+     */
+    class TestLLSDBinaryParsing : public TestLLSDParsing<LLSDBinaryParser>
+    {
+    public:
+        TestLLSDBinaryParsing() {}
+    };
+
+    typedef tut::test_group<TestLLSDBinaryParsing> TestLLSDBinaryParsingGroup;
+    typedef TestLLSDBinaryParsingGroup::object TestLLSDBinaryParsingObject;
+    TestLLSDBinaryParsingGroup gTestLLSDBinaryParsingGroup(
+        "llsd binary parsing");
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<1>()
+    {
+        std::vector<U8> vec;
+        vec.resize(6);
+        vec[0] = 'a'; vec[1] = 'b'; vec[2] = 'c';
+        vec[3] = '3'; vec[4] = '2'; vec[5] = '1';
+        std::string string_expected((char*)&vec[0], vec.size());
+        LLSD value = string_expected;
+
+        vec.resize(11);
+        vec[0] = 's'; // for string
+        vec[5] = 'a'; vec[6] = 'b'; vec[7] = 'c';
+        vec[8] = '3'; vec[9] = '2'; vec[10] = '1';
+
+        uint32_t size = htonl(6);
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_good((char*)&vec[0], vec.size());
+        ensureParse("correct string parse", str_good, value, 1);
+
+        size = htonl(7);
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_1((char*)&vec[0], vec.size());
+        ensureParse(
+            "incorrect size string parse",
+            str_bad_1,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        size = htonl(100000);
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_2((char*)&vec[0], vec.size());
+        ensureParse(
+            "incorrect size string parse",
+            str_bad_2,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<2>()
+    {
+        std::vector<U8> vec;
+        vec.resize(6);
+        vec[0] = 'a'; vec[1] = 'b'; vec[2] = 'c';
+        vec[3] = '3'; vec[4] = '2'; vec[5] = '1';
+        LLSD value = vec;
+
+        vec.resize(11);
+        vec[0] = 'b';  // for binary
+        vec[5] = 'a'; vec[6] = 'b'; vec[7] = 'c';
+        vec[8] = '3'; vec[9] = '2'; vec[10] = '1';
+
+        uint32_t size = htonl(6);
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_good((char*)&vec[0], vec.size());
+        ensureParse("correct binary parse", str_good, value, 1);
+
+        size = htonl(7);
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_1((char*)&vec[0], vec.size());
+        ensureParse(
+            "incorrect size binary parse 1",
+            str_bad_1,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        size = htonl(100000);
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_2((char*)&vec[0], vec.size());
+        ensureParse(
+            "incorrect size binary parse 2",
+            str_bad_2,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<3>()
+    {
+        // test handling of xml not recognized as llsd results in an
+        // LLSD Undefined
+        ensureParse(
+            "malformed binary map",
+            "{'ha ha'",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "malformed binary array",
+            "['ha ha'",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "malformed binary string",
+            "'ha ha",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "bad noise",
+            "g48ejlnfr",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<4>()
+    {
+        ensureParse("valid undef", "!", LLSD(), 1);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<5>()
+    {
+        LLSD val = false;
+        ensureParse("valid boolean false 2", "0", val, 1);
+        val = true;
+        ensureParse("valid boolean true 2", "1", val, 1);
+
+        val.clear();
+        ensureParse("invalid true", "t", val, LLSDParser::PARSE_FAILURE);
+        ensureParse("invalid false", "f", val, LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<6>()
+    {
+        std::vector<U8> vec;
+        vec.push_back('{');
+        vec.resize(vec.size() + 4);
+        uint32_t size = htonl(1);
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        vec.push_back('k');
+        int key_size_loc = vec.size();
+        size = htonl(1); // 1 too short
+        vec.resize(vec.size() + 4);
+        memcpy(&vec[key_size_loc], &size, sizeof(uint32_t));
+        vec.push_back('a'); vec.push_back('m'); vec.push_back('y');
+        vec.push_back('i');
+        int integer_loc = vec.size();
+        vec.resize(vec.size() + 4);
+        uint32_t val_int = htonl(23);
+        memcpy(&vec[integer_loc], &val_int, sizeof(uint32_t));
+        std::string str_bad_1((char*)&vec[0], vec.size());
+        ensureParse(
+            "invalid key size",
+            str_bad_1,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        // check with correct size, but unterminated map (missing '}')
+        size = htonl(3); // correct size
+        memcpy(&vec[key_size_loc], &size, sizeof(uint32_t));
+        std::string str_bad_2((char*)&vec[0], vec.size());
+        ensureParse(
+            "valid key size, unterminated map",
+            str_bad_2,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        // check w/ correct size and correct map termination
+        LLSD val;
+        val["amy"] = 23;
+        vec.push_back('}');
+        std::string str_good((char*)&vec[0], vec.size());
+        ensureParse(
+            "valid map",
+            str_good,
+            val,
+            2);
+
+        // check w/ incorrect sizes and correct map termination
+        size = htonl(0); // 1 too few (for the map entry)
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_3((char*)&vec[0], vec.size());
+        ensureParse(
+            "invalid map too long",
+            str_bad_3,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        size = htonl(2); // 1 too many
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_4((char*)&vec[0], vec.size());
+        ensureParse(
+            "invalid map too short",
+            str_bad_4,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<7>()
+    {
+        std::vector<U8> vec;
+        vec.push_back('[');
+        vec.resize(vec.size() + 4);
+        uint32_t size = htonl(1); // 1 too short
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        vec.push_back('"'); vec.push_back('a'); vec.push_back('m');
+        vec.push_back('y'); vec.push_back('"'); vec.push_back('i');
+        int integer_loc = vec.size();
+        vec.resize(vec.size() + 4);
+        uint32_t val_int = htonl(23);
+        memcpy(&vec[integer_loc], &val_int, sizeof(uint32_t));
+
+        std::string str_bad_1((char*)&vec[0], vec.size());
+        ensureParse(
+            "invalid array size",
+            str_bad_1,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        // check with correct size, but unterminated map (missing ']')
+        size = htonl(2); // correct size
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_2((char*)&vec[0], vec.size());
+        ensureParse(
+            "unterminated array",
+            str_bad_2,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        // check w/ correct size and correct map termination
+        LLSD val;
+        val.append("amy");
+        val.append(23);
+        vec.push_back(']');
+        std::string str_good((char*)&vec[0], vec.size());
+        ensureParse(
+            "valid array",
+            str_good,
+            val,
+            3);
+
+        // check with too many elements
+        size = htonl(3); // 1 too long
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_3((char*)&vec[0], vec.size());
+        ensureParse(
+            "array too short",
+            str_bad_3,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<8>()
+    {
+        std::vector<U8> vec;
+        vec.push_back('{');
+        vec.resize(vec.size() + 4);
+        memset(&vec[1], 0, 4);
+        vec.push_back('}');
+        std::string str_good((char*)&vec[0], vec.size());
+        LLSD val = LLSD::emptyMap();
+        ensureParse(
+            "empty map",
+            str_good,
+            val,
+            1);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<9>()
+    {
+        std::vector<U8> vec;
+        vec.push_back('[');
+        vec.resize(vec.size() + 4);
+        memset(&vec[1], 0, 4);
+        vec.push_back(']');
+        std::string str_good((char*)&vec[0], vec.size());
+        LLSD val = LLSD::emptyArray();
+        ensureParse(
+            "empty array",
+            str_good,
+            val,
+            1);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<10>()
+    {
+        std::vector<U8> vec;
+        vec.push_back('l');
+        vec.resize(vec.size() + 4);
+        uint32_t size = htonl(14); // 1 too long
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        vec.push_back('h'); vec.push_back('t'); vec.push_back('t');
+        vec.push_back('p'); vec.push_back(':'); vec.push_back('/');
+        vec.push_back('/'); vec.push_back('s'); vec.push_back('l');
+        vec.push_back('.'); vec.push_back('c'); vec.push_back('o');
+        vec.push_back('m');
+        std::string str_bad((char*)&vec[0], vec.size());
+        ensureParse(
+            "invalid uri length size",
+            str_bad,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        LLSD val;
+        val = LLURI("http://sl.com");
+        size = htonl(13); // correct length
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_good((char*)&vec[0], vec.size());
+        ensureParse(
+            "valid key size",
+            str_good,
+            val,
+            1);
+    }
 
 /*
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<11>()
-	{
-	}
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<11>()
+    {
+    }
 */
 
    /**
-	 * @class TestLLSDCrossCompatible
-	 * @brief Miscellaneous serialization and parsing tests
-	 */
-	class TestLLSDCrossCompatible
-	{
-	public:
-		TestLLSDCrossCompatible() {}
-
-		void ensureBinaryAndNotation(
-			const std::string& msg,
-			const LLSD& input)
-		{
-			// to binary, and back again
-			std::stringstream str1;
-			S32 count1 = LLSDSerialize::toBinary(input, str1);
-			LLSD actual_value_bin;
-			S32 count2 = LLSDSerialize::fromBinary(
-				actual_value_bin,
-				str1,
-				LLSDSerialize::SIZE_UNLIMITED);
-			ensure_equals(
-				"ensureBinaryAndNotation binary count",
-				count2,
-				count1);
-
-			// to notation and back again
-			std::stringstream str2;
-			S32 count3 = LLSDSerialize::toNotation(actual_value_bin, str2);
-			ensure_equals(
-				"ensureBinaryAndNotation notation count1",
-				count3,
-				count2);
-			LLSD actual_value_notation;
-			S32 count4 = LLSDSerialize::fromNotation(
-				actual_value_notation,
-				str2,
-				LLSDSerialize::SIZE_UNLIMITED);
-			ensure_equals(
-				"ensureBinaryAndNotation notation count2",
-				count4,
-				count3);
-			ensure_equals(
-				(msg + " (binaryandnotation)").c_str(),
-				actual_value_notation,
-				input);
-		}
-
-		void ensureBinaryAndXML(
-			const std::string& msg,
-			const LLSD& input)
-		{
-			// to binary, and back again
-			std::stringstream str1;
-			S32 count1 = LLSDSerialize::toBinary(input, str1);
-			LLSD actual_value_bin;
-			S32 count2 = LLSDSerialize::fromBinary(
-				actual_value_bin,
-				str1,
-				LLSDSerialize::SIZE_UNLIMITED);
-			ensure_equals(
-				"ensureBinaryAndXML binary count",
-				count2,
-				count1);
-
-			// to xml and back again
-			std::stringstream str2;
-			S32 count3 = LLSDSerialize::toXML(actual_value_bin, str2);
-			ensure_equals(
-				"ensureBinaryAndXML xml count1",
-				count3,
-				count2);
-			LLSD actual_value_xml;
-			S32 count4 = LLSDSerialize::fromXML(actual_value_xml, str2);
-			ensure_equals(
-				"ensureBinaryAndXML xml count2",
-				count4,
-				count3);
-			ensure_equals((msg + " (binaryandxml)").c_str(), actual_value_xml, input);
-		}
-	};
-
-	typedef tut::test_group<TestLLSDCrossCompatible> TestLLSDCompatibleGroup;
-	typedef TestLLSDCompatibleGroup::object TestLLSDCompatibleObject;
-	TestLLSDCompatibleGroup gTestLLSDCompatibleGroup(
-		"llsd serialize compatible");
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<1>()
-	{
-		LLSD test;
-		ensureBinaryAndNotation("undef", test);
-		ensureBinaryAndXML("undef", test);
-		test = true;
-		ensureBinaryAndNotation("boolean true", test);
-		ensureBinaryAndXML("boolean true", test);
-		test = false;
-		ensureBinaryAndNotation("boolean false", test);
-		ensureBinaryAndXML("boolean false", test);
-		test = 0;
-		ensureBinaryAndNotation("integer zero", test);
-		ensureBinaryAndXML("integer zero", test);
-		test = 1;
-		ensureBinaryAndNotation("integer positive", test);
-		ensureBinaryAndXML("integer positive", test);
-		test = -234567;
-		ensureBinaryAndNotation("integer negative", test);
-		ensureBinaryAndXML("integer negative", test);
-		test = 0.0;
-		ensureBinaryAndNotation("real zero", test);
-		ensureBinaryAndXML("real zero", test);
-		test = 1.0;
-		ensureBinaryAndNotation("real positive", test);
-		ensureBinaryAndXML("real positive", test);
-		test = -1.0;
-		ensureBinaryAndNotation("real negative", test);
-		ensureBinaryAndXML("real negative", test);
-	}
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<2>()
-	{
-		LLSD test;
-		test = "foobar";
-		ensureBinaryAndNotation("string", test);
-		ensureBinaryAndXML("string", test);
-	}
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<3>()
-	{
-		LLSD test;
-		LLUUID id;
-		id.generate();
-		test = id;
-		ensureBinaryAndNotation("uuid", test);
-		ensureBinaryAndXML("uuid", test);
-	}
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<4>()
-	{
-		LLSD test;
-		test = LLDate(12345.0);
-		ensureBinaryAndNotation("date", test);
-		ensureBinaryAndXML("date", test);
-	}
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<5>()
-	{
-		LLSD test;
-		test = LLURI("http://www.secondlife.com/");
-		ensureBinaryAndNotation("uri", test);
-		ensureBinaryAndXML("uri", test);
-	}
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<6>()
-	{
-		LLSD test;
-		typedef std::vector<U8> buf_t;
-		buf_t val;
-		for(int ii = 0; ii < 100; ++ii)
-		{
-			srand(ii);		/* Flawfinder: ignore */
-			S32 size = rand() % 100 + 10;
-			std::generate_n(
-				std::back_insert_iterator<buf_t>(val),
-				size,
-				rand);
-		}
-		test = val;
-		ensureBinaryAndNotation("binary", test);
-		ensureBinaryAndXML("binary", test);
-	}
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<7>()
-	{
-		LLSD test;
-		test = LLSD::emptyArray();
-		test.append(1);
-		test.append("hello");
-		ensureBinaryAndNotation("array", test);
-		ensureBinaryAndXML("array", test);
-	}
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<8>()
-	{
-		LLSD test;
-		test = LLSD::emptyArray();
-		test["foo"] = "bar";
-		test["baz"] = 100;
-		ensureBinaryAndNotation("map", test);
-		ensureBinaryAndXML("map", test);
-	}
+     * @class TestLLSDCrossCompatible
+     * @brief Miscellaneous serialization and parsing tests
+     */
+    class TestLLSDCrossCompatible
+    {
+    public:
+        TestLLSDCrossCompatible() {}
+
+        void ensureBinaryAndNotation(
+            const std::string& msg,
+            const LLSD& input)
+        {
+            // to binary, and back again
+            std::stringstream str1;
+            S32 count1 = LLSDSerialize::toBinary(input, str1);
+            LLSD actual_value_bin;
+            S32 count2 = LLSDSerialize::fromBinary(
+                actual_value_bin,
+                str1,
+                LLSDSerialize::SIZE_UNLIMITED);
+            ensure_equals(
+                "ensureBinaryAndNotation binary count",
+                count2,
+                count1);
+
+            // to notation and back again
+            std::stringstream str2;
+            S32 count3 = LLSDSerialize::toNotation(actual_value_bin, str2);
+            ensure_equals(
+                "ensureBinaryAndNotation notation count1",
+                count3,
+                count2);
+            LLSD actual_value_notation;
+            S32 count4 = LLSDSerialize::fromNotation(
+                actual_value_notation,
+                str2,
+                LLSDSerialize::SIZE_UNLIMITED);
+            ensure_equals(
+                "ensureBinaryAndNotation notation count2",
+                count4,
+                count3);
+            ensure_equals(
+                (msg + " (binaryandnotation)").c_str(),
+                actual_value_notation,
+                input);
+        }
+
+        void ensureBinaryAndXML(
+            const std::string& msg,
+            const LLSD& input)
+        {
+            // to binary, and back again
+            std::stringstream str1;
+            S32 count1 = LLSDSerialize::toBinary(input, str1);
+            LLSD actual_value_bin;
+            S32 count2 = LLSDSerialize::fromBinary(
+                actual_value_bin,
+                str1,
+                LLSDSerialize::SIZE_UNLIMITED);
+            ensure_equals(
+                "ensureBinaryAndXML binary count",
+                count2,
+                count1);
+
+            // to xml and back again
+            std::stringstream str2;
+            S32 count3 = LLSDSerialize::toXML(actual_value_bin, str2);
+            ensure_equals(
+                "ensureBinaryAndXML xml count1",
+                count3,
+                count2);
+            LLSD actual_value_xml;
+            S32 count4 = LLSDSerialize::fromXML(actual_value_xml, str2);
+            ensure_equals(
+                "ensureBinaryAndXML xml count2",
+                count4,
+                count3);
+            ensure_equals((msg + " (binaryandxml)").c_str(), actual_value_xml, input);
+        }
+    };
+
+    typedef tut::test_group<TestLLSDCrossCompatible> TestLLSDCompatibleGroup;
+    typedef TestLLSDCompatibleGroup::object TestLLSDCompatibleObject;
+    TestLLSDCompatibleGroup gTestLLSDCompatibleGroup(
+        "llsd serialize compatible");
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<1>()
+    {
+        LLSD test;
+        ensureBinaryAndNotation("undef", test);
+        ensureBinaryAndXML("undef", test);
+        test = true;
+        ensureBinaryAndNotation("boolean true", test);
+        ensureBinaryAndXML("boolean true", test);
+        test = false;
+        ensureBinaryAndNotation("boolean false", test);
+        ensureBinaryAndXML("boolean false", test);
+        test = 0;
+        ensureBinaryAndNotation("integer zero", test);
+        ensureBinaryAndXML("integer zero", test);
+        test = 1;
+        ensureBinaryAndNotation("integer positive", test);
+        ensureBinaryAndXML("integer positive", test);
+        test = -234567;
+        ensureBinaryAndNotation("integer negative", test);
+        ensureBinaryAndXML("integer negative", test);
+        test = 0.0;
+        ensureBinaryAndNotation("real zero", test);
+        ensureBinaryAndXML("real zero", test);
+        test = 1.0;
+        ensureBinaryAndNotation("real positive", test);
+        ensureBinaryAndXML("real positive", test);
+        test = -1.0;
+        ensureBinaryAndNotation("real negative", test);
+        ensureBinaryAndXML("real negative", test);
+    }
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<2>()
+    {
+        LLSD test;
+        test = "foobar";
+        ensureBinaryAndNotation("string", test);
+        ensureBinaryAndXML("string", test);
+    }
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<3>()
+    {
+        LLSD test;
+        LLUUID id;
+        id.generate();
+        test = id;
+        ensureBinaryAndNotation("uuid", test);
+        ensureBinaryAndXML("uuid", test);
+    }
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<4>()
+    {
+        LLSD test;
+        test = LLDate(12345.0);
+        ensureBinaryAndNotation("date", test);
+        ensureBinaryAndXML("date", test);
+    }
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<5>()
+    {
+        LLSD test;
+        test = LLURI("http://www.secondlife.com/");
+        ensureBinaryAndNotation("uri", test);
+        ensureBinaryAndXML("uri", test);
+    }
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<6>()
+    {
+        LLSD test;
+        typedef std::vector<U8> buf_t;
+        buf_t val;
+        for(int ii = 0; ii < 100; ++ii)
+        {
+            srand(ii);      /* Flawfinder: ignore */
+            S32 size = rand() % 100 + 10;
+            std::generate_n(
+                std::back_insert_iterator<buf_t>(val),
+                size,
+                rand);
+        }
+        test = val;
+        ensureBinaryAndNotation("binary", test);
+        ensureBinaryAndXML("binary", test);
+    }
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<7>()
+    {
+        LLSD test;
+        test = LLSD::emptyArray();
+        test.append(1);
+        test.append("hello");
+        ensureBinaryAndNotation("array", test);
+        ensureBinaryAndXML("array", test);
+    }
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<8>()
+    {
+        LLSD test;
+        test = LLSD::emptyArray();
+        test["foo"] = "bar";
+        test["baz"] = 100;
+        ensureBinaryAndNotation("map", test);
+        ensureBinaryAndXML("map", test);
+    }
 
     // helper for TestPythonCompatible
     static std::string import_llsd("import os.path\n"
@@ -2130,7 +2130,7 @@ namespace tut
                                         item.asReal(), 3.14, 7); // 7 bits ~= 0.01
             ensure("Failed to read LLSD::String from Python",
                    itemFromStream(inf, item, parse));
-            ensure_equals(item.asString(), 
+            ensure_equals(item.asString(),
                           "This string\n"
                           "has several\n"
                           "lines.");
diff --git a/indra/llcommon/tests/llsingleton_test.cpp b/indra/llcommon/tests/llsingleton_test.cpp
index 6f8aaaa0cb..adf5804272 100644
--- a/indra/llcommon/tests/llsingleton_test.cpp
+++ b/indra/llcommon/tests/llsingleton_test.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llsingleton_test.cpp
  * @date 2011-08-11
  * @brief Unit test for the LLSingleton class
diff --git a/indra/llcommon/tests/llstreamqueue_test.cpp b/indra/llcommon/tests/llstreamqueue_test.cpp
index 050ad5c5bf..82b451119e 100644
--- a/indra/llcommon/tests/llstreamqueue_test.cpp
+++ b/indra/llcommon/tests/llstreamqueue_test.cpp
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2012-01-05
  * @brief  Test for llstreamqueue.
- * 
+ *
  * $LicenseInfo:firstyear=2012&license=viewerlgpl$
  * Copyright (c) 2012, Linden Research, Inc.
  * $/LicenseInfo$
@@ -15,9 +15,6 @@
 #include "llstreamqueue.h"
 // STL headers
 #include <vector>
-// std headers
-// external library headers
-#include <boost/foreach.hpp>
 // other Linden headers
 #include "../test/lltut.h"
 #include "stringize.h"
@@ -133,7 +130,7 @@ namespace tut
         std::streamsize leave(5);   // len("craft") above
         std::streamsize skip(total - leave);
         std::streamsize written(0);
-        BOOST_FOREACH(const std::string& block, blocks)
+        for (const std::string& block : blocks)
         {
             written += strq.write(&block[0], block.length());
             ensure_equals("size() after write()", strq.size(), written);
@@ -152,7 +149,7 @@ namespace tut
     {
         set_test_name("concatenate blocks");
         std::string blocks[] = { "abcd", "efghij", "klmnopqrs" };
-        BOOST_FOREACH(const std::string& block, blocks)
+        for (const std::string& block : blocks)
         {
             strq.write(&block[0], block.length());
         }
@@ -170,7 +167,7 @@ namespace tut
     {
         set_test_name("split blocks");
         std::string blocks[] = { "abcdefghijklm", "nopqrstuvwxyz" };
-        BOOST_FOREACH(const std::string& block, blocks)
+        for (const std::string& block : blocks)
         {
             strq.write(&block[0], block.length());
         }
diff --git a/indra/llcommon/tests/llstring_test.cpp b/indra/llcommon/tests/llstring_test.cpp
index a7aa347222..3fadfa5334 100644
--- a/indra/llcommon/tests/llstring_test.cpp
+++ b/indra/llcommon/tests/llstring_test.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llstring_test.cpp
  * @author Adroit, Steve Linden, Tofu Linden
  * @date 2006-12-24
@@ -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,835 +37,835 @@ using boost::assign::list_of;
 
 namespace tut
 {
-	struct string_index
-	{
-	};
-	typedef test_group<string_index> string_index_t;
-	typedef string_index_t::object string_index_object_t;
-	tut::string_index_t tut_string_index("LLString");
-
-	template<> template<>
-	void string_index_object_t::test<1>()
-	{
-		std::string llstr1;
-		ensure("Empty std::string", (llstr1.size() == 0) && llstr1.empty());
-
-		std::string llstr2("Hello");
-		ensure("std::string = Hello", (!strcmp(llstr2.c_str(), "Hello")) && (llstr2.size() == 5) && !llstr2.empty());
-
-		std::string llstr3(llstr2);
-		ensure("std::string = std::string(std::string)", (!strcmp(llstr3.c_str(), "Hello")) && (llstr3.size() == 5) && !llstr3.empty());
-
-		std::string str("Hello World");
-		std::string llstr4(str, 6);
-		ensure("std::string = std::string(s, size_type pos, size_type n = npos)", (!strcmp(llstr4.c_str(), "World")) && (llstr4.size() == 5) && !llstr4.empty());
-
-		std::string llstr5(str, str.size());
-		ensure("std::string = std::string(s, size_type pos, size_type n = npos)", (llstr5.size() == 0) && llstr5.empty());
-
-		std::string llstr6(5, 'A');
-		ensure("std::string = std::string(count, c)", (!strcmp(llstr6.c_str(), "AAAAA")) && (llstr6.size() == 5) && !llstr6.empty());
-
-		std::string llstr7("Hello World", 5);
-		ensure("std::string(s, n)", (!strcmp(llstr7.c_str(), "Hello")) && (llstr7.size() == 5) && !llstr7.empty());
-
-		std::string llstr8("Hello World", 6, 5);
-		ensure("std::string(s, n, count)", (!strcmp(llstr8.c_str(), "World")) && (llstr8.size() == 5) && !llstr8.empty());
-
-		std::string llstr9("Hello World", sizeof("Hello World")-1, 5); // go past end
-		ensure("std::string(s, n, count) goes past end", (llstr9.size() == 0) && llstr9.empty());
-	}
-
-	template<> template<>
-	void string_index_object_t::test<3>()
-	{
-		std::string str("Len=5");
-		ensure("isValidIndex failed", LLStringUtil::isValidIndex(str, 0) == TRUE &&
-									  LLStringUtil::isValidIndex(str, 5) == TRUE &&
-									  LLStringUtil::isValidIndex(str, 6) == FALSE);
-
-		std::string str1;
-		ensure("isValidIndex failed fo rempty string", LLStringUtil::isValidIndex(str1, 0) == FALSE);
-	}
-
-	template<> template<>
-	void string_index_object_t::test<4>()
-	{
-		std::string str_val("               Testing the extra whitespaces   ");
-		LLStringUtil::trimHead(str_val);
-		ensure_equals("1: trimHead failed", str_val, "Testing the extra whitespaces   ");
-
-		std::string str_val1("\n\t\r\n  Testing the extra whitespaces   ");
-		LLStringUtil::trimHead(str_val1);
-		ensure_equals("2: trimHead failed", str_val1, "Testing the extra whitespaces   ");
-	}
-
-	template<> template<>
-	void string_index_object_t::test<5>()
-	{
-		std::string str_val("  Testing the   extra     whitespaces         ");
-		LLStringUtil::trimTail(str_val);
-		ensure_equals("1: trimTail failed", str_val, "  Testing the   extra     whitespaces");
-
-		std::string str_val1("\n  Testing the extra whitespaces  \n\t\r\n   ");
-		LLStringUtil::trimTail(str_val1);
-		ensure_equals("2: trimTail failed", str_val1, "\n  Testing the extra whitespaces");
-	}
-
-
-	template<> template<>
-	void string_index_object_t::test<6>()
-	{
-		std::string str_val("  \t \r Testing the   extra     \r\n whitespaces     \n \t    ");
-		LLStringUtil::trim(str_val);
-		ensure_equals("1: trim failed", str_val, "Testing the   extra     \r\n whitespaces");
-	}
-
-	template<> template<>
-	void string_index_object_t::test<7>()
-	{
-		std::string str("Second LindenLabs");
-		LLStringUtil::truncate(str, 6);
-		ensure_equals("1: truncate", str, "Second");
-
-		// further truncate more than the length
-		LLStringUtil::truncate(str, 0);
-		ensure_equals("2: truncate", str, "");
-	}
-
-	template<> template<>
-	void string_index_object_t::test<8>()
-	{
-		std::string str_val("SecondLife Source");
-		LLStringUtil::toUpper(str_val);
-		ensure_equals("toUpper failed", str_val, "SECONDLIFE SOURCE");
-	}
-
-	template<> template<>
-	void string_index_object_t::test<9>()
-	{
-		std::string str_val("SecondLife Source");
-		LLStringUtil::toLower(str_val);
-		ensure_equals("toLower failed", str_val, "secondlife source");
-	}
-
-	template<> template<>
-	void string_index_object_t::test<10>()
-	{
-		std::string str_val("Second");
-		ensure("1. isHead failed", LLStringUtil::isHead(str_val, "SecondLife Source") == TRUE);
-		ensure("2. isHead failed", LLStringUtil::isHead(str_val, " SecondLife Source") == FALSE);
-		std::string str_val2("");
-		ensure("3. isHead failed", LLStringUtil::isHead(str_val2, "") == FALSE);
-	}
-
-	template<> template<>
-	void string_index_object_t::test<11>()
-	{
-		std::string str_val("Hello.\n\n Lindenlabs. \n This is \na simple test.\n");
-		std::string orig_str_val(str_val);
-		LLStringUtil::addCRLF(str_val);
-		ensure_equals("addCRLF failed", str_val, "Hello.\r\n\r\n Lindenlabs. \r\n This is \r\na simple test.\r\n");
-		LLStringUtil::removeCRLF(str_val);
-		ensure_equals("removeCRLF failed", str_val, orig_str_val);
-	}
-
-	template<> template<>
-	void string_index_object_t::test<12>()
-	{
-		std::string str_val("Hello.\n\n\t \t Lindenlabs. \t\t");
-		std::string orig_str_val(str_val);
-		LLStringUtil::replaceTabsWithSpaces(str_val, 1);
-		ensure_equals("replaceTabsWithSpaces failed", str_val, "Hello.\n\n    Lindenlabs.   ");
-		LLStringUtil::replaceTabsWithSpaces(orig_str_val, 0);
-		ensure_equals("replaceTabsWithSpaces failed for 0", orig_str_val, "Hello.\n\n  Lindenlabs. ");
-
-		str_val = "\t\t\t\t";
-		LLStringUtil::replaceTabsWithSpaces(str_val, 0);
-		ensure_equals("replaceTabsWithSpaces failed for all tabs", str_val, "");
-	}
-
-	template<> template<>
-	void string_index_object_t::test<13>()
-	{
-		std::string str_val("Hello.\n\n\t\t\r\nLindenlabsX.");
-		LLStringUtil::replaceNonstandardASCII(str_val, 'X');
-		ensure_equals("replaceNonstandardASCII failed", str_val, "Hello.\n\nXXX\nLindenlabsX.");
-	}
-
-	template<> template<>
-	void string_index_object_t::test<14>()
-	{
-		std::string str_val("Hello.\n\t\r\nABCDEFGHIABABAB");
-		LLStringUtil::replaceChar(str_val, 'A', 'X');
-		ensure_equals("1: replaceChar failed", str_val, "Hello.\n\t\r\nXBCDEFGHIXBXBXB");
-		std::string str_val1("Hello.\n\t\r\nABCDEFGHIABABAB");
-	}
-
-	template<> template<>
-	void string_index_object_t::test<15>()
-	{
-		std::string str_val("Hello.\n\r\t");
-		ensure("containsNonprintable failed", LLStringUtil::containsNonprintable(str_val) == TRUE);
-
-		str_val = "ABC ";
-		ensure("containsNonprintable failed", LLStringUtil::containsNonprintable(str_val) == FALSE);
-	}
-
-	template<> template<>
-	void string_index_object_t::test<16>()
-	{
-		std::string str_val("Hello.\n\r\t Again!");
-		LLStringUtil::stripNonprintable(str_val);
-		ensure_equals("stripNonprintable failed", str_val, "Hello. Again!");
-
-		str_val = "\r\n\t\t";
-		LLStringUtil::stripNonprintable(str_val);
-		ensure_equals("stripNonprintable resulting in empty string failed", str_val, "");
-
-		str_val = "";
-		LLStringUtil::stripNonprintable(str_val);
-		ensure_equals("stripNonprintable of empty string resulting in empty string failed", str_val, "");
-	}
-
-	template<> template<>
-	void string_index_object_t::test<17>()
-	{
-		BOOL value;
-		std::string str_val("1");
-		ensure("convertToBOOL 1 failed", LLStringUtil::convertToBOOL(str_val, value) && value);
-		str_val = "T";
-		ensure("convertToBOOL T failed", LLStringUtil::convertToBOOL(str_val, value) && value);
-		str_val = "t";
-		ensure("convertToBOOL t failed", LLStringUtil::convertToBOOL(str_val, value) && value);
-		str_val = "TRUE";
-		ensure("convertToBOOL TRUE failed", LLStringUtil::convertToBOOL(str_val, value) && value);
-		str_val = "True";
-		ensure("convertToBOOL True failed", LLStringUtil::convertToBOOL(str_val, value) && value);
-		str_val = "true";
-		ensure("convertToBOOL true failed", LLStringUtil::convertToBOOL(str_val, value) && value);
-
-		str_val = "0";
-		ensure("convertToBOOL 0 failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
-		str_val = "F";
-		ensure("convertToBOOL F failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
-		str_val = "f";
-		ensure("convertToBOOL f failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
-		str_val = "FALSE";
-		ensure("convertToBOOL FASLE failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
-		str_val = "False";
-		ensure("convertToBOOL False failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
-		str_val = "false";
-		ensure("convertToBOOL false failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
-
-		str_val = "Tblah";
-		ensure("convertToBOOL false failed", !LLStringUtil::convertToBOOL(str_val, value));
-	}
-
-	template<> template<>
-	void string_index_object_t::test<18>()
-	{
-		U8 value;
-		std::string str_val("255");
-		ensure("1: convertToU8 failed", LLStringUtil::convertToU8(str_val, value) && value == 255);
-
-		str_val = "0";
-		ensure("2: convertToU8 failed", LLStringUtil::convertToU8(str_val, value) && value == 0);
-
-		str_val = "-1";
-		ensure("3: convertToU8 failed", !LLStringUtil::convertToU8(str_val, value));
-
-		str_val = "256"; // bigger than MAX_U8
-		ensure("4: convertToU8 failed", !LLStringUtil::convertToU8(str_val, value));
-	}
-
-	template<> template<>
-	void string_index_object_t::test<19>()
-	{
-		S8 value;
-		std::string str_val("127");
-		ensure("1: convertToS8 failed", LLStringUtil::convertToS8(str_val, value) && value == 127);
-
-		str_val = "0";
-		ensure("2: convertToS8 failed", LLStringUtil::convertToS8(str_val, value) && value == 0);
-
-		str_val = "-128";
-		ensure("3: convertToS8 failed", LLStringUtil::convertToS8(str_val, value) && value == -128);
-
-		str_val = "128"; // bigger than MAX_S8
-		ensure("4: convertToS8 failed", !LLStringUtil::convertToS8(str_val, value));
-
-		str_val = "-129"; 
-		ensure("5: convertToS8 failed", !LLStringUtil::convertToS8(str_val, value));
-	}
-
-	template<> template<>
-	void string_index_object_t::test<20>()
-	{
-		S16 value;
-		std::string str_val("32767"); 
-		ensure("1: convertToS16 failed", LLStringUtil::convertToS16(str_val, value) && value == 32767);
-
-		str_val = "0";
-		ensure("2: convertToS16 failed", LLStringUtil::convertToS16(str_val, value) && value == 0);
-
-		str_val = "-32768";
-		ensure("3: convertToS16 failed", LLStringUtil::convertToS16(str_val, value) && value == -32768);
-
-		str_val = "32768"; 
-		ensure("4: convertToS16 failed", !LLStringUtil::convertToS16(str_val, value));
-
-		str_val = "-32769";
-		ensure("5: convertToS16 failed", !LLStringUtil::convertToS16(str_val, value));
-	}
-
-	template<> template<>
-	void string_index_object_t::test<21>()
-	{
-		U16 value;
-		std::string str_val("65535"); //0xFFFF
-		ensure("1: convertToU16 failed", LLStringUtil::convertToU16(str_val, value) && value == 65535);
-
-		str_val = "0";
-		ensure("2: convertToU16 failed", LLStringUtil::convertToU16(str_val, value) && value == 0);
-
-		str_val = "-1"; 
-		ensure("3: convertToU16 failed", !LLStringUtil::convertToU16(str_val, value));
-
-		str_val = "65536"; 
-		ensure("4: convertToU16 failed", !LLStringUtil::convertToU16(str_val, value));
-	}
-
-	template<> template<>
-	void string_index_object_t::test<22>()
-	{
-		U32 value;
-		std::string str_val("4294967295"); //0xFFFFFFFF
-		ensure("1: convertToU32 failed", LLStringUtil::convertToU32(str_val, value) && value == 4294967295UL);
-
-		str_val = "0";
-		ensure("2: convertToU32 failed", LLStringUtil::convertToU32(str_val, value) && value == 0);
-
-		str_val = "4294967296"; 
-		ensure("3: convertToU32 failed", !LLStringUtil::convertToU32(str_val, value));
-	}
-
-	template<> template<>
-	void string_index_object_t::test<23>()
-	{
-		S32 value;
-		std::string str_val("2147483647"); //0x7FFFFFFF
-		ensure("1: convertToS32 failed", LLStringUtil::convertToS32(str_val, value) && value == 2147483647);
-
-		str_val = "0";
-		ensure("2: convertToS32 failed", LLStringUtil::convertToS32(str_val, value) && value == 0);
-
-		// Avoid "unary minus operator applied to unsigned type" warning on VC++. JC
-		S32 min_val = -2147483647 - 1;
-		str_val = "-2147483648"; 
-		ensure("3: convertToS32 failed", LLStringUtil::convertToS32(str_val, value)  && value == min_val);
-
-		str_val = "2147483648"; 
-		ensure("4: convertToS32 failed", !LLStringUtil::convertToS32(str_val, value));
-
-		str_val = "-2147483649"; 
-		ensure("5: convertToS32 failed", !LLStringUtil::convertToS32(str_val, value));
-	}
-
-	template<> template<>
-	void string_index_object_t::test<24>()
-	{
-		F32 value;
-		std::string str_val("2147483647"); //0x7FFFFFFF
-		ensure("1: convertToF32 failed", LLStringUtil::convertToF32(str_val, value) && value == 2147483647);
-
-		str_val = "0";
-		ensure("2: convertToF32 failed", LLStringUtil::convertToF32(str_val, value) && value == 0);
-
-		/* Need to find max/min F32 values
-		str_val = "-2147483648"; 
-		ensure("3: convertToF32 failed", LLStringUtil::convertToF32(str_val, value)  && value == -2147483648);
-
-		str_val = "2147483648"; 
-		ensure("4: convertToF32 failed", !LLStringUtil::convertToF32(str_val, value));
-
-		str_val = "-2147483649"; 
-		ensure("5: convertToF32 failed", !LLStringUtil::convertToF32(str_val, value));
-		*/
-	}
-
-	template<> template<>
-	void string_index_object_t::test<25>()
-	{
-		F64 value;
-		std::string str_val("9223372036854775807"); //0x7FFFFFFFFFFFFFFF
-		ensure("1: convertToF64 failed", LLStringUtil::convertToF64(str_val, value) && value == 9223372036854775807LL);
-
-		str_val = "0";
-		ensure("2: convertToF64 failed", LLStringUtil::convertToF64(str_val, value) && value == 0.0F);
-
-		/* Need to find max/min F64 values
-		str_val = "-2147483648"; 
-		ensure("3: convertToF32 failed", LLStringUtil::convertToF32(str_val, value)  && value == -2147483648);
-
-		str_val = "2147483648"; 
-		ensure("4: convertToF32 failed", !LLStringUtil::convertToF32(str_val, value));
-
-		str_val = "-2147483649"; 
-		ensure("5: convertToF32 failed", !LLStringUtil::convertToF32(str_val, value));
-		*/
-	}
-
-	template<> template<>
-	void string_index_object_t::test<26>()
-	{
-		const char* str1 = NULL;
-		const char* str2 = NULL;
-
-		ensure("1: compareStrings failed", LLStringUtil::compareStrings(str1, str2) == 0);
-		str2 = "A";
-		ensure("2: compareStrings failed", LLStringUtil::compareStrings(str1, str2) > 0);
-		ensure("3: compareStrings failed", LLStringUtil::compareStrings(str2, str1) < 0);
-		
-		str1 = "A is smaller than B";
-		str2 = "B is greater than A";
-		ensure("4: compareStrings failed", LLStringUtil::compareStrings(str1, str2) < 0);
-
-		str2 = "A is smaller than B";
-		ensure("5: compareStrings failed", LLStringUtil::compareStrings(str1, str2) == 0);
-	}
-
-	template<> template<>
-	void string_index_object_t::test<27>()
-	{
-		const char* str1 = NULL;
-		const char* str2 = NULL;
-
-		ensure("1: compareInsensitive failed", LLStringUtil::compareInsensitive(str1, str2) == 0);
-		str2 = "A";
-		ensure("2: compareInsensitive failed", LLStringUtil::compareInsensitive(str1, str2) > 0);
-		ensure("3: compareInsensitive failed", LLStringUtil::compareInsensitive(str2, str1) < 0);
-		
-		str1 = "A is equal to a";
-		str2 = "a is EQUAL to A";
-		ensure("4: compareInsensitive failed", LLStringUtil::compareInsensitive(str1, str2) == 0);
-	}
-
-	template<> template<>
-	void string_index_object_t::test<28>()
-	{
-		std::string lhs_str("PROgraM12files");
-		std::string rhs_str("PROgram12Files");
-		ensure("compareDict 1 failed", LLStringUtil::compareDict(lhs_str, rhs_str) < 0);
-		ensure("precedesDict 1 failed", LLStringUtil::precedesDict(lhs_str, rhs_str) == TRUE);
-		
-		lhs_str = "PROgram12Files";
-		rhs_str = "PROgram12Files";
-		ensure("compareDict 2 failed", LLStringUtil::compareDict(lhs_str, rhs_str) == 0);
-		ensure("precedesDict 2 failed", LLStringUtil::precedesDict(lhs_str, rhs_str) == FALSE);
-
-		lhs_str = "PROgram12Files";
-		rhs_str = "PROgRAM12FILES";
-		ensure("compareDict 3 failed", LLStringUtil::compareDict(lhs_str, rhs_str) > 0);
-		ensure("precedesDict 3 failed", LLStringUtil::precedesDict(lhs_str, rhs_str) == FALSE);
-	}
-
-	template<> template<>
-	void string_index_object_t::test<29>()
-	{
-		char str1[] = "First String...";
-		char str2[100];
-
-		LLStringUtil::copy(str2, str1, 100);
-		ensure("LLStringUtil::copy with enough dest length failed", strcmp(str2, str1) == 0);
-		LLStringUtil::copy(str2, str1, sizeof("First"));
-		ensure("LLStringUtil::copy with less dest length failed", strcmp(str2, "First") == 0);
-	}
-
-	template<> template<>
-	void string_index_object_t::test<30>()
-	{
-		std::string str1 = "This is the sentence...";
-		std::string str2 = "This is the ";
-		std::string str3 = "first ";
-		std::string str4 = "This is the first sentence...";
-		std::string str5 = "This is the sentence...first ";
-		std::string dest;
-
-		dest = str1;
-		LLStringUtil::copyInto(dest, str3, str2.length());
-		ensure("LLStringUtil::copyInto insert failed", dest == str4);
-
-		dest = str1;
-		LLStringUtil::copyInto(dest, str3, dest.length());
-		ensure("LLStringUtil::copyInto append failed", dest == str5);
-	}
-
-	template<> template<>
-	void string_index_object_t::test<31>()
-	{
-		std::string stripped;
-
-		// Plain US ASCII text, including spaces and punctuation,
-		// should not be altered.
-		std::string simple_text = "Hello, world!";
-		stripped = LLStringFn::strip_invalid_xml(simple_text);
-		ensure("Simple text passed unchanged", stripped == simple_text);
-
-		// Control characters should be removed
-		// except for 0x09, 0x0a, 0x0d
-		std::string control_chars;
-		for (char c = 0x01; c < 0x20; c++)
-		{
-			control_chars.push_back(c);
-		}
-		std::string allowed_control_chars;
-		allowed_control_chars.push_back( (char)0x09 );
-		allowed_control_chars.push_back( (char)0x0a );
-		allowed_control_chars.push_back( (char)0x0d );
-
-		stripped = LLStringFn::strip_invalid_xml(control_chars);
-		ensure("Only tab, LF, CR control characters allowed",
-			stripped == allowed_control_chars);
-
-		// UTF-8 should be passed intact, including high byte
-		// characters.  Try Francais (with C squiggle cedilla)
-		std::string french = "Fran";
-		french.push_back( (char)0xC3 );
-		french.push_back( (char)0xA7 );
-		french += "ais";
-		stripped = LLStringFn::strip_invalid_xml( french );
-		ensure("UTF-8 high byte text is allowed", french == stripped );
-	}
-
-	template<> template<>
-	void string_index_object_t::test<32>()
-	{
-		// Test LLStringUtil::format() string interpolation
-		LLStringUtil::format_map_t fmt_map;
-		std::string s;
-		int subcount;
-
-		fmt_map["[TRICK1]"] = "[A]";
-		fmt_map["[A]"] = "a";
-		fmt_map["[B]"] = "b";
-		fmt_map["[AAA]"] = "aaa";
-		fmt_map["[BBB]"] = "bbb";
-		fmt_map["[TRICK2]"] = "[A]";
-		fmt_map["[EXPLOIT]"] = "!!!!!!!!!!!![EXPLOIT]!!!!!!!!!!!!";
-		fmt_map["[KEYLONGER]"] = "short";
-		fmt_map["[KEYSHORTER]"] = "Am I not a long string?";
-		fmt_map["?"] = "?";
-		fmt_map["[DELETE]"] = "";
-		fmt_map["[]"] = "[]"; // doesn't do a substitution, but shouldn't crash either
-
-		for (LLStringUtil::format_map_t::const_iterator iter = fmt_map.begin(); iter != fmt_map.end(); ++iter)
-		{
-			// Test when source string is entirely one key
-			std::string s1 = (std::string)iter->first;
-			std::string s2 = (std::string)iter->second;
-			subcount = LLStringUtil::format(s1, fmt_map);
-			ensure_equals("LLStringUtil::format: Raw interpolation result", s1, s2);
-			if (s1 == "?" || s1 == "[]") // no interp expected
-			{
-				ensure_equals("LLStringUtil::format: Raw interpolation result count", 0, subcount);
-			}
-			else
-			{
-				ensure_equals("LLStringUtil::format: Raw interpolation result count", 1, subcount);
-			}
-		}
-
-		for (LLStringUtil::format_map_t::const_iterator iter = fmt_map.begin(); iter != fmt_map.end(); ++iter)
-		{
-			// Test when source string is one key, duplicated
-			std::string s1 = (std::string)iter->first;
-			std::string s2 = (std::string)iter->second;
-			s = s1 + s1 + s1 + s1;
-			subcount = LLStringUtil::format(s, fmt_map);
-			ensure_equals("LLStringUtil::format: Rawx4 interpolation result", s, s2 + s2 + s2 + s2);
-			if (s1 == "?" || s1 == "[]") // no interp expected
-			{
-				ensure_equals("LLStringUtil::format: Rawx4 interpolation result count", 0, subcount);
-			}
-			else
-			{
-				ensure_equals("LLStringUtil::format: Rawx4 interpolation result count", 4, subcount);
-			}
-		}
-
-		// Test when source string has no keys
-		std::string srcs = "!!!!!!!!!!!!!!!!";
-		s = srcs;
-		subcount = LLStringUtil::format(s, fmt_map);
-		ensure_equals("LLStringUtil::format: No key test result", s, srcs);
-		ensure_equals("LLStringUtil::format: No key test result count", 0, subcount);
-
-		// Test when source string has no keys and is empty
-		std::string srcs3;
-		s = srcs3;
-		subcount = LLStringUtil::format(s, fmt_map);
-		ensure("LLStringUtil::format: No key test3 result", s.empty());
-		ensure_equals("LLStringUtil::format: No key test3 result count", 0, subcount);
-
-		// Test a substitution where a key is substituted with blankness
-		std::string srcs2 = "[DELETE]";
-		s = srcs2;
-		subcount = LLStringUtil::format(s, fmt_map);
-		ensure("LLStringUtil::format: Delete key test2 result", s.empty());
-		ensure_equals("LLStringUtil::format: Delete key test2 result count", 1, subcount);
-
-		// Test an assorted substitution
-		std::string srcs4 = "[TRICK1][A][B][AAA][BBB][TRICK2][KEYLONGER][KEYSHORTER]?[DELETE]";
-		s = srcs4;
-		subcount = LLStringUtil::format(s, fmt_map);
-		ensure_equals("LLStringUtil::format: Assorted Test1 result", s, "[A]abaaabbb[A]shortAm I not a long string??");
-		ensure_equals("LLStringUtil::format: Assorted Test1 result count", 9, subcount);
-
-		// Test an assorted substitution
-		std::string srcs5 = "[DELETE]?[KEYSHORTER][KEYLONGER][TRICK2][BBB][AAA][B][A][TRICK1]";
-		s = srcs5;
-		subcount = LLStringUtil::format(s, fmt_map);
-		ensure_equals("LLStringUtil::format: Assorted Test2 result", s, "?Am I not a long string?short[A]bbbaaaba[A]");
-		ensure_equals("LLStringUtil::format: Assorted Test2 result count", 9, subcount);
-		
-		// Test on nested brackets
-		std::string srcs6 = "[[TRICK1]][[A]][[B]][[AAA]][[BBB]][[TRICK2]][[KEYLONGER]][[KEYSHORTER]]?[[DELETE]]";
-		s = srcs6;
-		subcount = LLStringUtil::format(s, fmt_map);
-		ensure_equals("LLStringUtil::format: Assorted Test2 result", s, "[[A]][a][b][aaa][bbb][[A]][short][Am I not a long string?]?[]");
-		ensure_equals("LLStringUtil::format: Assorted Test2 result count", 9, subcount);
-
-
-		// Test an assorted substitution
-		std::string srcs8 = "foo[DELETE]bar?";
-		s = srcs8;
-		subcount = LLStringUtil::format(s, fmt_map);
-		ensure_equals("LLStringUtil::format: Assorted Test3 result", s, "foobar?");
-		ensure_equals("LLStringUtil::format: Assorted Test3 result count", 1, subcount);		
-	}
-
-	template<> template<>
-	void string_index_object_t::test<33>()
-	{
-		// Test LLStringUtil::format() string interpolation
-		LLStringUtil::format_map_t blank_fmt_map;
-		std::string s;
-		int subcount;
-
-		// Test substituting out of a blank format_map
-		std::string srcs6 = "12345";
-		s = srcs6;
-		subcount = LLStringUtil::format(s, blank_fmt_map);
-		ensure_equals("LLStringUtil::format: Blankfmt Test1 result", s, "12345");
-		ensure_equals("LLStringUtil::format: Blankfmt Test1 result count", 0, subcount);
-		
-		// Test substituting a blank string out of a blank format_map
-		std::string srcs7;
-		s = srcs7;
-		subcount = LLStringUtil::format(s, blank_fmt_map);
-		ensure("LLStringUtil::format: Blankfmt Test2 result", s.empty());
-		ensure_equals("LLStringUtil::format: Blankfmt Test2 result count", 0, subcount);
-	}
-
-	template<> template<>
-	void string_index_object_t::test<34>()
-	{
-		// Test that incorrect LLStringUtil::format() use does not explode.
-		LLStringUtil::format_map_t nasty_fmt_map;
-		std::string s;
-		int subcount;
-
-		nasty_fmt_map[""] = "never used"; // see, this is nasty.
-
-		// Test substituting out of a nasty format_map
-		std::string srcs6 = "12345";
-		s = srcs6;
-		subcount = LLStringUtil::format(s, nasty_fmt_map);
-		ensure_equals("LLStringUtil::format: Nastyfmt Test1 result", s, "12345");
-		ensure_equals("LLStringUtil::format: Nastyfmt Test1 result count", 0, subcount);
-		
-		// Test substituting a blank string out of a nasty format_map
-		std::string srcs7;
-		s = srcs7;
-		subcount = LLStringUtil::format(s, nasty_fmt_map);
-		ensure("LLStringUtil::format: Nastyfmt Test2 result", s.empty());
-		ensure_equals("LLStringUtil::format: Nastyfmt Test2 result count", 0, subcount);
-	}
-
-	template<> template<>
-	void string_index_object_t::test<35>()
-	{
-		// Make sure startsWith works
-		std::string string("anybody in there?");
-		std::string substr("anybody");
-		ensure("startsWith works.", LLStringUtil::startsWith(string, substr));
-	}
-
-	template<> template<>
-	void string_index_object_t::test<36>()
-	{
-		// Make sure startsWith correctly fails
-		std::string string("anybody in there?");
-		std::string substr("there");
-		ensure("startsWith fails.", !LLStringUtil::startsWith(string, substr));
-	}
-
-	template<> template<>
-	void string_index_object_t::test<37>()
-	{
-		// startsWith fails on empty strings
-		std::string value("anybody in there?");
-		std::string empty;
-		ensure("empty string.", !LLStringUtil::startsWith(value, empty));
-		ensure("empty substr.", !LLStringUtil::startsWith(empty, value));
-		ensure("empty everything.", !LLStringUtil::startsWith(empty, empty));
-	}
-
-	template<> template<>
-	void string_index_object_t::test<38>()
-	{
-		// Make sure endsWith works correctly
-		std::string string("anybody in there?");
-		std::string substr("there?");
-		ensure("endsWith works.", LLStringUtil::endsWith(string, substr));
-	}
-
-	template<> template<>
-	void string_index_object_t::test<39>()
-	{
-		// Make sure endsWith correctly fails
-		std::string string("anybody in there?");
-		std::string substr("anybody");
-		ensure("endsWith fails.", !LLStringUtil::endsWith(string, substr));
-		substr = "there";
-		ensure("endsWith fails.", !LLStringUtil::endsWith(string, substr));
-		substr = "ther?";
-		ensure("endsWith fails.", !LLStringUtil::endsWith(string, substr));
-	}
-
-	template<> template<>
-	void string_index_object_t::test<40>()
-	{
-		// endsWith fails on empty strings
-		std::string value("anybody in there?");
-		std::string empty;
-		ensure("empty string.", !LLStringUtil::endsWith(value, empty));
-		ensure("empty substr.", !LLStringUtil::endsWith(empty, value));
-		ensure("empty everything.", !LLStringUtil::endsWith(empty, empty));
-	}
-
-	template<> template<>
-	void string_index_object_t::test<41>()
-	{
-		set_test_name("getTokens(\"delims\")");
-		ensure_equals("empty string", LLStringUtil::getTokens("", " "), StringVec());
-		ensure_equals("only delims",
-					  LLStringUtil::getTokens("   \r\n   ", " \r\n"), StringVec());
-		ensure_equals("sequence of delims",
-					  LLStringUtil::getTokens(",,, one ,,,", ","), list_of("one"));
-		// nat considers this a dubious implementation side effect, but I'd
-		// hate to change it now...
-		ensure_equals("noncontiguous tokens",
-					  LLStringUtil::getTokens(", ,, , one ,,,", ","), list_of("")("")("one"));
-		ensure_equals("space-padded tokens",
-					  LLStringUtil::getTokens(",    one  ,  two  ,", ","), list_of("one")("two"));
-		ensure_equals("no delims", LLStringUtil::getTokens("one", ","), list_of("one"));
-	}
-
-	// Shorthand for verifying that getTokens() behaves the same when you
-	// don't pass a string of escape characters, when you pass an empty string
-	// (different overloads), and when you pass a string of characters that
-	// aren't actually present.
-	void ensure_getTokens(const std::string& desc,
-						  const std::string& string,
-						  const std::string& drop_delims,
-						  const std::string& keep_delims,
-						  const std::string& quotes,
-						  const std::vector<std::string>& expect)
-	{
-		ensure_equals(desc + " - no esc",
-					  LLStringUtil::getTokens(string, drop_delims, keep_delims, quotes),
-					  expect);
-		ensure_equals(desc + " - empty esc",
-					  LLStringUtil::getTokens(string, drop_delims, keep_delims, quotes, ""),
-					  expect);
-		ensure_equals(desc + " - unused esc",
-					  LLStringUtil::getTokens(string, drop_delims, keep_delims, quotes, "!"),
-					  expect);
-	}
-
-	void ensure_getTokens(const std::string& desc,
-						  const std::string& string,
-						  const std::string& drop_delims,
-						  const std::string& keep_delims,
-						  const std::vector<std::string>& expect)
-	{
-		ensure_getTokens(desc, string, drop_delims, keep_delims, "", expect);
-	}
-
-	template<> template<>
-	void string_index_object_t::test<42>()
-	{
-		set_test_name("getTokens(\"delims\", etc.)");
-		// Signatures to test in this method:
-		// getTokens(string, drop_delims, keep_delims [, quotes [, escapes]])
-		// If you omit keep_delims, you get the older function (test above).
-
-		// cases like the getTokens(string, delims) tests above
-		ensure_getTokens("empty string", "", " ", "", StringVec());
-		ensure_getTokens("only delims",
-						 "   \r\n   ", " \r\n", "", StringVec());
-		ensure_getTokens("sequence of delims",
-						 ",,, one ,,,", ", ", "", list_of("one"));
-		// Note contrast with the case in the previous method
-		ensure_getTokens("noncontiguous tokens",
-						 ", ,, , one ,,,", ", ", "", list_of("one"));
-		ensure_getTokens("space-padded tokens",
-						 ",    one  ,  two  ,", ", ", "",
+    struct string_index
+    {
+    };
+    typedef test_group<string_index> string_index_t;
+    typedef string_index_t::object string_index_object_t;
+    tut::string_index_t tut_string_index("LLString");
+
+    template<> template<>
+    void string_index_object_t::test<1>()
+    {
+        std::string llstr1;
+        ensure("Empty std::string", (llstr1.size() == 0) && llstr1.empty());
+
+        std::string llstr2("Hello");
+        ensure("std::string = Hello", (!strcmp(llstr2.c_str(), "Hello")) && (llstr2.size() == 5) && !llstr2.empty());
+
+        std::string llstr3(llstr2);
+        ensure("std::string = std::string(std::string)", (!strcmp(llstr3.c_str(), "Hello")) && (llstr3.size() == 5) && !llstr3.empty());
+
+        std::string str("Hello World");
+        std::string llstr4(str, 6);
+        ensure("std::string = std::string(s, size_type pos, size_type n = npos)", (!strcmp(llstr4.c_str(), "World")) && (llstr4.size() == 5) && !llstr4.empty());
+
+        std::string llstr5(str, str.size());
+        ensure("std::string = std::string(s, size_type pos, size_type n = npos)", (llstr5.size() == 0) && llstr5.empty());
+
+        std::string llstr6(5, 'A');
+        ensure("std::string = std::string(count, c)", (!strcmp(llstr6.c_str(), "AAAAA")) && (llstr6.size() == 5) && !llstr6.empty());
+
+        std::string llstr7("Hello World", 5);
+        ensure("std::string(s, n)", (!strcmp(llstr7.c_str(), "Hello")) && (llstr7.size() == 5) && !llstr7.empty());
+
+        std::string llstr8("Hello World", 6, 5);
+        ensure("std::string(s, n, count)", (!strcmp(llstr8.c_str(), "World")) && (llstr8.size() == 5) && !llstr8.empty());
+
+        std::string llstr9("Hello World", sizeof("Hello World")-1, 5); // go past end
+        ensure("std::string(s, n, count) goes past end", (llstr9.size() == 0) && llstr9.empty());
+    }
+
+    template<> template<>
+    void string_index_object_t::test<3>()
+    {
+        std::string str("Len=5");
+        ensure("isValidIndex failed", LLStringUtil::isValidIndex(str, 0) == TRUE &&
+                                      LLStringUtil::isValidIndex(str, 5) == TRUE &&
+                                      LLStringUtil::isValidIndex(str, 6) == FALSE);
+
+        std::string str1;
+        ensure("isValidIndex failed fo rempty string", LLStringUtil::isValidIndex(str1, 0) == FALSE);
+    }
+
+    template<> template<>
+    void string_index_object_t::test<4>()
+    {
+        std::string str_val("               Testing the extra whitespaces   ");
+        LLStringUtil::trimHead(str_val);
+        ensure_equals("1: trimHead failed", str_val, "Testing the extra whitespaces   ");
+
+        std::string str_val1("\n\t\r\n  Testing the extra whitespaces   ");
+        LLStringUtil::trimHead(str_val1);
+        ensure_equals("2: trimHead failed", str_val1, "Testing the extra whitespaces   ");
+    }
+
+    template<> template<>
+    void string_index_object_t::test<5>()
+    {
+        std::string str_val("  Testing the   extra     whitespaces         ");
+        LLStringUtil::trimTail(str_val);
+        ensure_equals("1: trimTail failed", str_val, "  Testing the   extra     whitespaces");
+
+        std::string str_val1("\n  Testing the extra whitespaces  \n\t\r\n   ");
+        LLStringUtil::trimTail(str_val1);
+        ensure_equals("2: trimTail failed", str_val1, "\n  Testing the extra whitespaces");
+    }
+
+
+    template<> template<>
+    void string_index_object_t::test<6>()
+    {
+        std::string str_val("  \t \r Testing the   extra     \r\n whitespaces     \n \t    ");
+        LLStringUtil::trim(str_val);
+        ensure_equals("1: trim failed", str_val, "Testing the   extra     \r\n whitespaces");
+    }
+
+    template<> template<>
+    void string_index_object_t::test<7>()
+    {
+        std::string str("Second LindenLabs");
+        LLStringUtil::truncate(str, 6);
+        ensure_equals("1: truncate", str, "Second");
+
+        // further truncate more than the length
+        LLStringUtil::truncate(str, 0);
+        ensure_equals("2: truncate", str, "");
+    }
+
+    template<> template<>
+    void string_index_object_t::test<8>()
+    {
+        std::string str_val("SecondLife Source");
+        LLStringUtil::toUpper(str_val);
+        ensure_equals("toUpper failed", str_val, "SECONDLIFE SOURCE");
+    }
+
+    template<> template<>
+    void string_index_object_t::test<9>()
+    {
+        std::string str_val("SecondLife Source");
+        LLStringUtil::toLower(str_val);
+        ensure_equals("toLower failed", str_val, "secondlife source");
+    }
+
+    template<> template<>
+    void string_index_object_t::test<10>()
+    {
+        std::string str_val("Second");
+        ensure("1. isHead failed", LLStringUtil::isHead(str_val, "SecondLife Source") == TRUE);
+        ensure("2. isHead failed", LLStringUtil::isHead(str_val, " SecondLife Source") == FALSE);
+        std::string str_val2("");
+        ensure("3. isHead failed", LLStringUtil::isHead(str_val2, "") == FALSE);
+    }
+
+    template<> template<>
+    void string_index_object_t::test<11>()
+    {
+        std::string str_val("Hello.\n\n Lindenlabs. \n This is \na simple test.\n");
+        std::string orig_str_val(str_val);
+        LLStringUtil::addCRLF(str_val);
+        ensure_equals("addCRLF failed", str_val, "Hello.\r\n\r\n Lindenlabs. \r\n This is \r\na simple test.\r\n");
+        LLStringUtil::removeCRLF(str_val);
+        ensure_equals("removeCRLF failed", str_val, orig_str_val);
+    }
+
+    template<> template<>
+    void string_index_object_t::test<12>()
+    {
+        std::string str_val("Hello.\n\n\t \t Lindenlabs. \t\t");
+        std::string orig_str_val(str_val);
+        LLStringUtil::replaceTabsWithSpaces(str_val, 1);
+        ensure_equals("replaceTabsWithSpaces failed", str_val, "Hello.\n\n    Lindenlabs.   ");
+        LLStringUtil::replaceTabsWithSpaces(orig_str_val, 0);
+        ensure_equals("replaceTabsWithSpaces failed for 0", orig_str_val, "Hello.\n\n  Lindenlabs. ");
+
+        str_val = "\t\t\t\t";
+        LLStringUtil::replaceTabsWithSpaces(str_val, 0);
+        ensure_equals("replaceTabsWithSpaces failed for all tabs", str_val, "");
+    }
+
+    template<> template<>
+    void string_index_object_t::test<13>()
+    {
+        std::string str_val("Hello.\n\n\t\t\r\nLindenlabsX.");
+        LLStringUtil::replaceNonstandardASCII(str_val, 'X');
+        ensure_equals("replaceNonstandardASCII failed", str_val, "Hello.\n\nXXX\nLindenlabsX.");
+    }
+
+    template<> template<>
+    void string_index_object_t::test<14>()
+    {
+        std::string str_val("Hello.\n\t\r\nABCDEFGHIABABAB");
+        LLStringUtil::replaceChar(str_val, 'A', 'X');
+        ensure_equals("1: replaceChar failed", str_val, "Hello.\n\t\r\nXBCDEFGHIXBXBXB");
+        std::string str_val1("Hello.\n\t\r\nABCDEFGHIABABAB");
+    }
+
+    template<> template<>
+    void string_index_object_t::test<15>()
+    {
+        std::string str_val("Hello.\n\r\t");
+        ensure("containsNonprintable failed", LLStringUtil::containsNonprintable(str_val) == TRUE);
+
+        str_val = "ABC ";
+        ensure("containsNonprintable failed", LLStringUtil::containsNonprintable(str_val) == FALSE);
+    }
+
+    template<> template<>
+    void string_index_object_t::test<16>()
+    {
+        std::string str_val("Hello.\n\r\t Again!");
+        LLStringUtil::stripNonprintable(str_val);
+        ensure_equals("stripNonprintable failed", str_val, "Hello. Again!");
+
+        str_val = "\r\n\t\t";
+        LLStringUtil::stripNonprintable(str_val);
+        ensure_equals("stripNonprintable resulting in empty string failed", str_val, "");
+
+        str_val = "";
+        LLStringUtil::stripNonprintable(str_val);
+        ensure_equals("stripNonprintable of empty string resulting in empty string failed", str_val, "");
+    }
+
+    template<> template<>
+    void string_index_object_t::test<17>()
+    {
+        BOOL value;
+        std::string str_val("1");
+        ensure("convertToBOOL 1 failed", LLStringUtil::convertToBOOL(str_val, value) && value);
+        str_val = "T";
+        ensure("convertToBOOL T failed", LLStringUtil::convertToBOOL(str_val, value) && value);
+        str_val = "t";
+        ensure("convertToBOOL t failed", LLStringUtil::convertToBOOL(str_val, value) && value);
+        str_val = "TRUE";
+        ensure("convertToBOOL TRUE failed", LLStringUtil::convertToBOOL(str_val, value) && value);
+        str_val = "True";
+        ensure("convertToBOOL True failed", LLStringUtil::convertToBOOL(str_val, value) && value);
+        str_val = "true";
+        ensure("convertToBOOL true failed", LLStringUtil::convertToBOOL(str_val, value) && value);
+
+        str_val = "0";
+        ensure("convertToBOOL 0 failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
+        str_val = "F";
+        ensure("convertToBOOL F failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
+        str_val = "f";
+        ensure("convertToBOOL f failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
+        str_val = "FALSE";
+        ensure("convertToBOOL FASLE failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
+        str_val = "False";
+        ensure("convertToBOOL False failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
+        str_val = "false";
+        ensure("convertToBOOL false failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
+
+        str_val = "Tblah";
+        ensure("convertToBOOL false failed", !LLStringUtil::convertToBOOL(str_val, value));
+    }
+
+    template<> template<>
+    void string_index_object_t::test<18>()
+    {
+        U8 value;
+        std::string str_val("255");
+        ensure("1: convertToU8 failed", LLStringUtil::convertToU8(str_val, value) && value == 255);
+
+        str_val = "0";
+        ensure("2: convertToU8 failed", LLStringUtil::convertToU8(str_val, value) && value == 0);
+
+        str_val = "-1";
+        ensure("3: convertToU8 failed", !LLStringUtil::convertToU8(str_val, value));
+
+        str_val = "256"; // bigger than MAX_U8
+        ensure("4: convertToU8 failed", !LLStringUtil::convertToU8(str_val, value));
+    }
+
+    template<> template<>
+    void string_index_object_t::test<19>()
+    {
+        S8 value;
+        std::string str_val("127");
+        ensure("1: convertToS8 failed", LLStringUtil::convertToS8(str_val, value) && value == 127);
+
+        str_val = "0";
+        ensure("2: convertToS8 failed", LLStringUtil::convertToS8(str_val, value) && value == 0);
+
+        str_val = "-128";
+        ensure("3: convertToS8 failed", LLStringUtil::convertToS8(str_val, value) && value == -128);
+
+        str_val = "128"; // bigger than MAX_S8
+        ensure("4: convertToS8 failed", !LLStringUtil::convertToS8(str_val, value));
+
+        str_val = "-129";
+        ensure("5: convertToS8 failed", !LLStringUtil::convertToS8(str_val, value));
+    }
+
+    template<> template<>
+    void string_index_object_t::test<20>()
+    {
+        S16 value;
+        std::string str_val("32767");
+        ensure("1: convertToS16 failed", LLStringUtil::convertToS16(str_val, value) && value == 32767);
+
+        str_val = "0";
+        ensure("2: convertToS16 failed", LLStringUtil::convertToS16(str_val, value) && value == 0);
+
+        str_val = "-32768";
+        ensure("3: convertToS16 failed", LLStringUtil::convertToS16(str_val, value) && value == -32768);
+
+        str_val = "32768";
+        ensure("4: convertToS16 failed", !LLStringUtil::convertToS16(str_val, value));
+
+        str_val = "-32769";
+        ensure("5: convertToS16 failed", !LLStringUtil::convertToS16(str_val, value));
+    }
+
+    template<> template<>
+    void string_index_object_t::test<21>()
+    {
+        U16 value;
+        std::string str_val("65535"); //0xFFFF
+        ensure("1: convertToU16 failed", LLStringUtil::convertToU16(str_val, value) && value == 65535);
+
+        str_val = "0";
+        ensure("2: convertToU16 failed", LLStringUtil::convertToU16(str_val, value) && value == 0);
+
+        str_val = "-1";
+        ensure("3: convertToU16 failed", !LLStringUtil::convertToU16(str_val, value));
+
+        str_val = "65536";
+        ensure("4: convertToU16 failed", !LLStringUtil::convertToU16(str_val, value));
+    }
+
+    template<> template<>
+    void string_index_object_t::test<22>()
+    {
+        U32 value;
+        std::string str_val("4294967295"); //0xFFFFFFFF
+        ensure("1: convertToU32 failed", LLStringUtil::convertToU32(str_val, value) && value == 4294967295UL);
+
+        str_val = "0";
+        ensure("2: convertToU32 failed", LLStringUtil::convertToU32(str_val, value) && value == 0);
+
+        str_val = "4294967296";
+        ensure("3: convertToU32 failed", !LLStringUtil::convertToU32(str_val, value));
+    }
+
+    template<> template<>
+    void string_index_object_t::test<23>()
+    {
+        S32 value;
+        std::string str_val("2147483647"); //0x7FFFFFFF
+        ensure("1: convertToS32 failed", LLStringUtil::convertToS32(str_val, value) && value == 2147483647);
+
+        str_val = "0";
+        ensure("2: convertToS32 failed", LLStringUtil::convertToS32(str_val, value) && value == 0);
+
+        // Avoid "unary minus operator applied to unsigned type" warning on VC++. JC
+        S32 min_val = -2147483647 - 1;
+        str_val = "-2147483648";
+        ensure("3: convertToS32 failed", LLStringUtil::convertToS32(str_val, value)  && value == min_val);
+
+        str_val = "2147483648";
+        ensure("4: convertToS32 failed", !LLStringUtil::convertToS32(str_val, value));
+
+        str_val = "-2147483649";
+        ensure("5: convertToS32 failed", !LLStringUtil::convertToS32(str_val, value));
+    }
+
+    template<> template<>
+    void string_index_object_t::test<24>()
+    {
+        F32 value;
+        std::string str_val("2147483647"); //0x7FFFFFFF
+        ensure("1: convertToF32 failed", LLStringUtil::convertToF32(str_val, value) && value == 2147483647);
+
+        str_val = "0";
+        ensure("2: convertToF32 failed", LLStringUtil::convertToF32(str_val, value) && value == 0);
+
+        /* Need to find max/min F32 values
+        str_val = "-2147483648";
+        ensure("3: convertToF32 failed", LLStringUtil::convertToF32(str_val, value)  && value == -2147483648);
+
+        str_val = "2147483648";
+        ensure("4: convertToF32 failed", !LLStringUtil::convertToF32(str_val, value));
+
+        str_val = "-2147483649";
+        ensure("5: convertToF32 failed", !LLStringUtil::convertToF32(str_val, value));
+        */
+    }
+
+    template<> template<>
+    void string_index_object_t::test<25>()
+    {
+        F64 value;
+        std::string str_val("9223372036854775807"); //0x7FFFFFFFFFFFFFFF
+        ensure("1: convertToF64 failed", LLStringUtil::convertToF64(str_val, value) && value == 9223372036854775807LL);
+
+        str_val = "0";
+        ensure("2: convertToF64 failed", LLStringUtil::convertToF64(str_val, value) && value == 0.0F);
+
+        /* Need to find max/min F64 values
+        str_val = "-2147483648";
+        ensure("3: convertToF32 failed", LLStringUtil::convertToF32(str_val, value)  && value == -2147483648);
+
+        str_val = "2147483648";
+        ensure("4: convertToF32 failed", !LLStringUtil::convertToF32(str_val, value));
+
+        str_val = "-2147483649";
+        ensure("5: convertToF32 failed", !LLStringUtil::convertToF32(str_val, value));
+        */
+    }
+
+    template<> template<>
+    void string_index_object_t::test<26>()
+    {
+        const char* str1 = NULL;
+        const char* str2 = NULL;
+
+        ensure("1: compareStrings failed", LLStringUtil::compareStrings(str1, str2) == 0);
+        str2 = "A";
+        ensure("2: compareStrings failed", LLStringUtil::compareStrings(str1, str2) > 0);
+        ensure("3: compareStrings failed", LLStringUtil::compareStrings(str2, str1) < 0);
+
+        str1 = "A is smaller than B";
+        str2 = "B is greater than A";
+        ensure("4: compareStrings failed", LLStringUtil::compareStrings(str1, str2) < 0);
+
+        str2 = "A is smaller than B";
+        ensure("5: compareStrings failed", LLStringUtil::compareStrings(str1, str2) == 0);
+    }
+
+    template<> template<>
+    void string_index_object_t::test<27>()
+    {
+        const char* str1 = NULL;
+        const char* str2 = NULL;
+
+        ensure("1: compareInsensitive failed", LLStringUtil::compareInsensitive(str1, str2) == 0);
+        str2 = "A";
+        ensure("2: compareInsensitive failed", LLStringUtil::compareInsensitive(str1, str2) > 0);
+        ensure("3: compareInsensitive failed", LLStringUtil::compareInsensitive(str2, str1) < 0);
+
+        str1 = "A is equal to a";
+        str2 = "a is EQUAL to A";
+        ensure("4: compareInsensitive failed", LLStringUtil::compareInsensitive(str1, str2) == 0);
+    }
+
+    template<> template<>
+    void string_index_object_t::test<28>()
+    {
+        std::string lhs_str("PROgraM12files");
+        std::string rhs_str("PROgram12Files");
+        ensure("compareDict 1 failed", LLStringUtil::compareDict(lhs_str, rhs_str) < 0);
+        ensure("precedesDict 1 failed", LLStringUtil::precedesDict(lhs_str, rhs_str) == TRUE);
+
+        lhs_str = "PROgram12Files";
+        rhs_str = "PROgram12Files";
+        ensure("compareDict 2 failed", LLStringUtil::compareDict(lhs_str, rhs_str) == 0);
+        ensure("precedesDict 2 failed", LLStringUtil::precedesDict(lhs_str, rhs_str) == FALSE);
+
+        lhs_str = "PROgram12Files";
+        rhs_str = "PROgRAM12FILES";
+        ensure("compareDict 3 failed", LLStringUtil::compareDict(lhs_str, rhs_str) > 0);
+        ensure("precedesDict 3 failed", LLStringUtil::precedesDict(lhs_str, rhs_str) == FALSE);
+    }
+
+    template<> template<>
+    void string_index_object_t::test<29>()
+    {
+        char str1[] = "First String...";
+        char str2[100];
+
+        LLStringUtil::copy(str2, str1, 100);
+        ensure("LLStringUtil::copy with enough dest length failed", strcmp(str2, str1) == 0);
+        LLStringUtil::copy(str2, str1, sizeof("First"));
+        ensure("LLStringUtil::copy with less dest length failed", strcmp(str2, "First") == 0);
+    }
+
+    template<> template<>
+    void string_index_object_t::test<30>()
+    {
+        std::string str1 = "This is the sentence...";
+        std::string str2 = "This is the ";
+        std::string str3 = "first ";
+        std::string str4 = "This is the first sentence...";
+        std::string str5 = "This is the sentence...first ";
+        std::string dest;
+
+        dest = str1;
+        LLStringUtil::copyInto(dest, str3, str2.length());
+        ensure("LLStringUtil::copyInto insert failed", dest == str4);
+
+        dest = str1;
+        LLStringUtil::copyInto(dest, str3, dest.length());
+        ensure("LLStringUtil::copyInto append failed", dest == str5);
+    }
+
+    template<> template<>
+    void string_index_object_t::test<31>()
+    {
+        std::string stripped;
+
+        // Plain US ASCII text, including spaces and punctuation,
+        // should not be altered.
+        std::string simple_text = "Hello, world!";
+        stripped = LLStringFn::strip_invalid_xml(simple_text);
+        ensure("Simple text passed unchanged", stripped == simple_text);
+
+        // Control characters should be removed
+        // except for 0x09, 0x0a, 0x0d
+        std::string control_chars;
+        for (char c = 0x01; c < 0x20; c++)
+        {
+            control_chars.push_back(c);
+        }
+        std::string allowed_control_chars;
+        allowed_control_chars.push_back( (char)0x09 );
+        allowed_control_chars.push_back( (char)0x0a );
+        allowed_control_chars.push_back( (char)0x0d );
+
+        stripped = LLStringFn::strip_invalid_xml(control_chars);
+        ensure("Only tab, LF, CR control characters allowed",
+            stripped == allowed_control_chars);
+
+        // UTF-8 should be passed intact, including high byte
+        // characters.  Try Francais (with C squiggle cedilla)
+        std::string french = "Fran";
+        french.push_back( (char)0xC3 );
+        french.push_back( (char)0xA7 );
+        french += "ais";
+        stripped = LLStringFn::strip_invalid_xml( french );
+        ensure("UTF-8 high byte text is allowed", french == stripped );
+    }
+
+    template<> template<>
+    void string_index_object_t::test<32>()
+    {
+        // Test LLStringUtil::format() string interpolation
+        LLStringUtil::format_map_t fmt_map;
+        std::string s;
+        int subcount;
+
+        fmt_map["[TRICK1]"] = "[A]";
+        fmt_map["[A]"] = "a";
+        fmt_map["[B]"] = "b";
+        fmt_map["[AAA]"] = "aaa";
+        fmt_map["[BBB]"] = "bbb";
+        fmt_map["[TRICK2]"] = "[A]";
+        fmt_map["[EXPLOIT]"] = "!!!!!!!!!!!![EXPLOIT]!!!!!!!!!!!!";
+        fmt_map["[KEYLONGER]"] = "short";
+        fmt_map["[KEYSHORTER]"] = "Am I not a long string?";
+        fmt_map["?"] = "?";
+        fmt_map["[DELETE]"] = "";
+        fmt_map["[]"] = "[]"; // doesn't do a substitution, but shouldn't crash either
+
+        for (LLStringUtil::format_map_t::const_iterator iter = fmt_map.begin(); iter != fmt_map.end(); ++iter)
+        {
+            // Test when source string is entirely one key
+            std::string s1 = (std::string)iter->first;
+            std::string s2 = (std::string)iter->second;
+            subcount = LLStringUtil::format(s1, fmt_map);
+            ensure_equals("LLStringUtil::format: Raw interpolation result", s1, s2);
+            if (s1 == "?" || s1 == "[]") // no interp expected
+            {
+                ensure_equals("LLStringUtil::format: Raw interpolation result count", 0, subcount);
+            }
+            else
+            {
+                ensure_equals("LLStringUtil::format: Raw interpolation result count", 1, subcount);
+            }
+        }
+
+        for (LLStringUtil::format_map_t::const_iterator iter = fmt_map.begin(); iter != fmt_map.end(); ++iter)
+        {
+            // Test when source string is one key, duplicated
+            std::string s1 = (std::string)iter->first;
+            std::string s2 = (std::string)iter->second;
+            s = s1 + s1 + s1 + s1;
+            subcount = LLStringUtil::format(s, fmt_map);
+            ensure_equals("LLStringUtil::format: Rawx4 interpolation result", s, s2 + s2 + s2 + s2);
+            if (s1 == "?" || s1 == "[]") // no interp expected
+            {
+                ensure_equals("LLStringUtil::format: Rawx4 interpolation result count", 0, subcount);
+            }
+            else
+            {
+                ensure_equals("LLStringUtil::format: Rawx4 interpolation result count", 4, subcount);
+            }
+        }
+
+        // Test when source string has no keys
+        std::string srcs = "!!!!!!!!!!!!!!!!";
+        s = srcs;
+        subcount = LLStringUtil::format(s, fmt_map);
+        ensure_equals("LLStringUtil::format: No key test result", s, srcs);
+        ensure_equals("LLStringUtil::format: No key test result count", 0, subcount);
+
+        // Test when source string has no keys and is empty
+        std::string srcs3;
+        s = srcs3;
+        subcount = LLStringUtil::format(s, fmt_map);
+        ensure("LLStringUtil::format: No key test3 result", s.empty());
+        ensure_equals("LLStringUtil::format: No key test3 result count", 0, subcount);
+
+        // Test a substitution where a key is substituted with blankness
+        std::string srcs2 = "[DELETE]";
+        s = srcs2;
+        subcount = LLStringUtil::format(s, fmt_map);
+        ensure("LLStringUtil::format: Delete key test2 result", s.empty());
+        ensure_equals("LLStringUtil::format: Delete key test2 result count", 1, subcount);
+
+        // Test an assorted substitution
+        std::string srcs4 = "[TRICK1][A][B][AAA][BBB][TRICK2][KEYLONGER][KEYSHORTER]?[DELETE]";
+        s = srcs4;
+        subcount = LLStringUtil::format(s, fmt_map);
+        ensure_equals("LLStringUtil::format: Assorted Test1 result", s, "[A]abaaabbb[A]shortAm I not a long string??");
+        ensure_equals("LLStringUtil::format: Assorted Test1 result count", 9, subcount);
+
+        // Test an assorted substitution
+        std::string srcs5 = "[DELETE]?[KEYSHORTER][KEYLONGER][TRICK2][BBB][AAA][B][A][TRICK1]";
+        s = srcs5;
+        subcount = LLStringUtil::format(s, fmt_map);
+        ensure_equals("LLStringUtil::format: Assorted Test2 result", s, "?Am I not a long string?short[A]bbbaaaba[A]");
+        ensure_equals("LLStringUtil::format: Assorted Test2 result count", 9, subcount);
+
+        // Test on nested brackets
+        std::string srcs6 = "[[TRICK1]][[A]][[B]][[AAA]][[BBB]][[TRICK2]][[KEYLONGER]][[KEYSHORTER]]?[[DELETE]]";
+        s = srcs6;
+        subcount = LLStringUtil::format(s, fmt_map);
+        ensure_equals("LLStringUtil::format: Assorted Test2 result", s, "[[A]][a][b][aaa][bbb][[A]][short][Am I not a long string?]?[]");
+        ensure_equals("LLStringUtil::format: Assorted Test2 result count", 9, subcount);
+
+
+        // Test an assorted substitution
+        std::string srcs8 = "foo[DELETE]bar?";
+        s = srcs8;
+        subcount = LLStringUtil::format(s, fmt_map);
+        ensure_equals("LLStringUtil::format: Assorted Test3 result", s, "foobar?");
+        ensure_equals("LLStringUtil::format: Assorted Test3 result count", 1, subcount);
+    }
+
+    template<> template<>
+    void string_index_object_t::test<33>()
+    {
+        // Test LLStringUtil::format() string interpolation
+        LLStringUtil::format_map_t blank_fmt_map;
+        std::string s;
+        int subcount;
+
+        // Test substituting out of a blank format_map
+        std::string srcs6 = "12345";
+        s = srcs6;
+        subcount = LLStringUtil::format(s, blank_fmt_map);
+        ensure_equals("LLStringUtil::format: Blankfmt Test1 result", s, "12345");
+        ensure_equals("LLStringUtil::format: Blankfmt Test1 result count", 0, subcount);
+
+        // Test substituting a blank string out of a blank format_map
+        std::string srcs7;
+        s = srcs7;
+        subcount = LLStringUtil::format(s, blank_fmt_map);
+        ensure("LLStringUtil::format: Blankfmt Test2 result", s.empty());
+        ensure_equals("LLStringUtil::format: Blankfmt Test2 result count", 0, subcount);
+    }
+
+    template<> template<>
+    void string_index_object_t::test<34>()
+    {
+        // Test that incorrect LLStringUtil::format() use does not explode.
+        LLStringUtil::format_map_t nasty_fmt_map;
+        std::string s;
+        int subcount;
+
+        nasty_fmt_map[""] = "never used"; // see, this is nasty.
+
+        // Test substituting out of a nasty format_map
+        std::string srcs6 = "12345";
+        s = srcs6;
+        subcount = LLStringUtil::format(s, nasty_fmt_map);
+        ensure_equals("LLStringUtil::format: Nastyfmt Test1 result", s, "12345");
+        ensure_equals("LLStringUtil::format: Nastyfmt Test1 result count", 0, subcount);
+
+        // Test substituting a blank string out of a nasty format_map
+        std::string srcs7;
+        s = srcs7;
+        subcount = LLStringUtil::format(s, nasty_fmt_map);
+        ensure("LLStringUtil::format: Nastyfmt Test2 result", s.empty());
+        ensure_equals("LLStringUtil::format: Nastyfmt Test2 result count", 0, subcount);
+    }
+
+    template<> template<>
+    void string_index_object_t::test<35>()
+    {
+        // Make sure startsWith works
+        std::string string("anybody in there?");
+        std::string substr("anybody");
+        ensure("startsWith works.", LLStringUtil::startsWith(string, substr));
+    }
+
+    template<> template<>
+    void string_index_object_t::test<36>()
+    {
+        // Make sure startsWith correctly fails
+        std::string string("anybody in there?");
+        std::string substr("there");
+        ensure("startsWith fails.", !LLStringUtil::startsWith(string, substr));
+    }
+
+    template<> template<>
+    void string_index_object_t::test<37>()
+    {
+        // startsWith fails on empty strings
+        std::string value("anybody in there?");
+        std::string empty;
+        ensure("empty string.", !LLStringUtil::startsWith(value, empty));
+        ensure("empty substr.", !LLStringUtil::startsWith(empty, value));
+        ensure("empty everything.", !LLStringUtil::startsWith(empty, empty));
+    }
+
+    template<> template<>
+    void string_index_object_t::test<38>()
+    {
+        // Make sure endsWith works correctly
+        std::string string("anybody in there?");
+        std::string substr("there?");
+        ensure("endsWith works.", LLStringUtil::endsWith(string, substr));
+    }
+
+    template<> template<>
+    void string_index_object_t::test<39>()
+    {
+        // Make sure endsWith correctly fails
+        std::string string("anybody in there?");
+        std::string substr("anybody");
+        ensure("endsWith fails.", !LLStringUtil::endsWith(string, substr));
+        substr = "there";
+        ensure("endsWith fails.", !LLStringUtil::endsWith(string, substr));
+        substr = "ther?";
+        ensure("endsWith fails.", !LLStringUtil::endsWith(string, substr));
+    }
+
+    template<> template<>
+    void string_index_object_t::test<40>()
+    {
+        // endsWith fails on empty strings
+        std::string value("anybody in there?");
+        std::string empty;
+        ensure("empty string.", !LLStringUtil::endsWith(value, empty));
+        ensure("empty substr.", !LLStringUtil::endsWith(empty, value));
+        ensure("empty everything.", !LLStringUtil::endsWith(empty, empty));
+    }
+
+    template<> template<>
+    void string_index_object_t::test<41>()
+    {
+        set_test_name("getTokens(\"delims\")");
+        ensure_equals("empty string", LLStringUtil::getTokens("", " "), StringVec());
+        ensure_equals("only delims",
+                      LLStringUtil::getTokens("   \r\n   ", " \r\n"), StringVec());
+        ensure_equals("sequence of delims",
+                      LLStringUtil::getTokens(",,, one ,,,", ","), list_of("one"));
+        // nat considers this a dubious implementation side effect, but I'd
+        // hate to change it now...
+        ensure_equals("noncontiguous tokens",
+                      LLStringUtil::getTokens(", ,, , one ,,,", ","), list_of("")("")("one"));
+        ensure_equals("space-padded tokens",
+                      LLStringUtil::getTokens(",    one  ,  two  ,", ","), list_of("one")("two"));
+        ensure_equals("no delims", LLStringUtil::getTokens("one", ","), list_of("one"));
+    }
+
+    // Shorthand for verifying that getTokens() behaves the same when you
+    // don't pass a string of escape characters, when you pass an empty string
+    // (different overloads), and when you pass a string of characters that
+    // aren't actually present.
+    void ensure_getTokens(const std::string& desc,
+                          const std::string& string,
+                          const std::string& drop_delims,
+                          const std::string& keep_delims,
+                          const std::string& quotes,
+                          const std::vector<std::string>& expect)
+    {
+        ensure_equals(desc + " - no esc",
+                      LLStringUtil::getTokens(string, drop_delims, keep_delims, quotes),
+                      expect);
+        ensure_equals(desc + " - empty esc",
+                      LLStringUtil::getTokens(string, drop_delims, keep_delims, quotes, ""),
+                      expect);
+        ensure_equals(desc + " - unused esc",
+                      LLStringUtil::getTokens(string, drop_delims, keep_delims, quotes, "!"),
+                      expect);
+    }
+
+    void ensure_getTokens(const std::string& desc,
+                          const std::string& string,
+                          const std::string& drop_delims,
+                          const std::string& keep_delims,
+                          const std::vector<std::string>& expect)
+    {
+        ensure_getTokens(desc, string, drop_delims, keep_delims, "", expect);
+    }
+
+    template<> template<>
+    void string_index_object_t::test<42>()
+    {
+        set_test_name("getTokens(\"delims\", etc.)");
+        // Signatures to test in this method:
+        // getTokens(string, drop_delims, keep_delims [, quotes [, escapes]])
+        // If you omit keep_delims, you get the older function (test above).
+
+        // cases like the getTokens(string, delims) tests above
+        ensure_getTokens("empty string", "", " ", "", StringVec());
+        ensure_getTokens("only delims",
+                         "   \r\n   ", " \r\n", "", StringVec());
+        ensure_getTokens("sequence of delims",
+                         ",,, one ,,,", ", ", "", list_of("one"));
+        // Note contrast with the case in the previous method
+        ensure_getTokens("noncontiguous tokens",
+                         ", ,, , one ,,,", ", ", "", list_of("one"));
+        ensure_getTokens("space-padded tokens",
+                         ",    one  ,  two  ,", ", ", "",
                          list_of("one")("two"));
-		ensure_getTokens("no delims", "one", ",", "", list_of("one"));
-
-		// drop_delims vs. keep_delims
-		ensure_getTokens("arithmetic",
-						 " ab+def  / xx*  yy ", " ", "+-*/",
-						 list_of("ab")("+")("def")("/")("xx")("*")("yy"));
-
-		// quotes
-		ensure_getTokens("no quotes",
-						 "She said, \"Don't go.\"", " ", ",", "",
-						 list_of("She")("said")(",")("\"Don't")("go.\""));
-		ensure_getTokens("quotes",
-						 "She said, \"Don't go.\"", " ", ",", "\"",
-						 list_of("She")("said")(",")("Don't go."));
-		ensure_getTokens("quotes and delims",
-						 "run c:/'Documents and Settings'/someone", " ", "", "'",
-						 list_of("run")("c:/Documents and Settings/someone"));
-		ensure_getTokens("unmatched quote",
-						 "baby don't leave", " ", "", "'",
-						 list_of("baby")("don't")("leave"));
-		ensure_getTokens("adjacent quoted",
-						 "abc'def \"ghi'\"jkl' mno\"pqr", " ", "", "\"'",
-						 list_of("abcdef \"ghijkl' mnopqr"));
-		ensure_getTokens("quoted empty string",
-						 "--set SomeVar ''", " ", "", "'",
-						 list_of("--set")("SomeVar")(""));
-
-		// escapes
-		// Don't use backslash as an escape for these tests -- you'll go nuts
-		// between the C++ string scanner and getTokens() escapes. Test with
-		// something else!
-		ensure_equals("escaped delims",
-					  LLStringUtil::getTokens("^ a - dog^-gone^ phrase", " ", "-", "", "^"),
-					  list_of(" a")("-")("dog-gone phrase"));
-		ensure_equals("escaped quotes",
-					  LLStringUtil::getTokens("say: 'this isn^'t w^orking'.", " ", "", "'", "^"),
-					  list_of("say:")("this isn't working."));
-		ensure_equals("escaped escape",
-					  LLStringUtil::getTokens("want x^^2", " ", "", "", "^"),
-					  list_of("want")("x^2"));
-		ensure_equals("escape at end",
-					  LLStringUtil::getTokens("it's^ up there^", " ", "", "'", "^"),
-					  list_of("it's up")("there^"));
+        ensure_getTokens("no delims", "one", ",", "", list_of("one"));
+
+        // drop_delims vs. keep_delims
+        ensure_getTokens("arithmetic",
+                         " ab+def  / xx*  yy ", " ", "+-*/",
+                         list_of("ab")("+")("def")("/")("xx")("*")("yy"));
+
+        // quotes
+        ensure_getTokens("no quotes",
+                         "She said, \"Don't go.\"", " ", ",", "",
+                         list_of("She")("said")(",")("\"Don't")("go.\""));
+        ensure_getTokens("quotes",
+                         "She said, \"Don't go.\"", " ", ",", "\"",
+                         list_of("She")("said")(",")("Don't go."));
+        ensure_getTokens("quotes and delims",
+                         "run c:/'Documents and Settings'/someone", " ", "", "'",
+                         list_of("run")("c:/Documents and Settings/someone"));
+        ensure_getTokens("unmatched quote",
+                         "baby don't leave", " ", "", "'",
+                         list_of("baby")("don't")("leave"));
+        ensure_getTokens("adjacent quoted",
+                         "abc'def \"ghi'\"jkl' mno\"pqr", " ", "", "\"'",
+                         list_of("abcdef \"ghijkl' mnopqr"));
+        ensure_getTokens("quoted empty string",
+                         "--set SomeVar ''", " ", "", "'",
+                         list_of("--set")("SomeVar")(""));
+
+        // escapes
+        // Don't use backslash as an escape for these tests -- you'll go nuts
+        // between the C++ string scanner and getTokens() escapes. Test with
+        // something else!
+        ensure_equals("escaped delims",
+                      LLStringUtil::getTokens("^ a - dog^-gone^ phrase", " ", "-", "", "^"),
+                      list_of(" a")("-")("dog-gone phrase"));
+        ensure_equals("escaped quotes",
+                      LLStringUtil::getTokens("say: 'this isn^'t w^orking'.", " ", "", "'", "^"),
+                      list_of("say:")("this isn't working."));
+        ensure_equals("escaped escape",
+                      LLStringUtil::getTokens("want x^^2", " ", "", "", "^"),
+                      list_of("want")("x^2"));
+        ensure_equals("escape at end",
+                      LLStringUtil::getTokens("it's^ up there^", " ", "", "'", "^"),
+                      list_of("it's up")("there^"));
     }
 }
diff --git a/indra/llcommon/tests/lltrace_test.cpp b/indra/llcommon/tests/lltrace_test.cpp
index 0a9d85ad00..8851f87b91 100644
--- a/indra/llcommon/tests/lltrace_test.cpp
+++ b/indra/llcommon/tests/lltrace_test.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llsingleton_test.cpp
  * @date 2011-08-11
  * @brief Unit test for the LLSingleton class
@@ -34,14 +34,14 @@
 
 namespace LLUnits
 {
-	// using powers of 2 to allow strict floating point equality
-	LL_DECLARE_BASE_UNIT(Ounces, "oz");
-	LL_DECLARE_DERIVED_UNIT(TallCup, "", Ounces, / 12);
-	LL_DECLARE_DERIVED_UNIT(GrandeCup, "", Ounces, / 16);
-	LL_DECLARE_DERIVED_UNIT(VentiCup, "", Ounces, / 20);
-
-	LL_DECLARE_BASE_UNIT(Grams, "g");
-	LL_DECLARE_DERIVED_UNIT(Milligrams, "mg", Grams, * 1000);
+    // using powers of 2 to allow strict floating point equality
+    LL_DECLARE_BASE_UNIT(Ounces, "oz");
+    LL_DECLARE_DERIVED_UNIT(TallCup, "", Ounces, / 12);
+    LL_DECLARE_DERIVED_UNIT(GrandeCup, "", Ounces, / 16);
+    LL_DECLARE_DERIVED_UNIT(VentiCup, "", Ounces, / 20);
+
+    LL_DECLARE_BASE_UNIT(Grams, "g");
+    LL_DECLARE_DERIVED_UNIT(Milligrams, "mg", Grams, * 1000);
 }
 
 LL_DECLARE_UNIT_TYPEDEFS(LLUnits, Ounces);
@@ -54,89 +54,89 @@ LL_DECLARE_UNIT_TYPEDEFS(LLUnits, Milligrams);
 
 namespace tut
 {
-	using namespace LLTrace;
-	struct trace
-	{
-		ThreadRecorder mRecorder;
-	};
-
-	typedef test_group<trace> trace_t;
-	typedef trace_t::object trace_object_t;
-	tut::trace_t tut_singleton("LLTrace");
-
-	static CountStatHandle<S32> sCupsOfCoffeeConsumed("coffeeconsumed", "Delicious cup of dark roast.");
-	static SampleStatHandle<F32Milligrams> sCaffeineLevelStat("caffeinelevel", "Coffee buzz quotient");
-	static EventStatHandle<S32Ounces> sOuncesPerCup("cupsize", "Large, huge, or ginormous");
-
-	static F32 sCaffeineLevel(0.f);
-	const F32Milligrams sCaffeinePerOz(18.f);
-
-	void drink_coffee(S32 num_cups, S32Ounces cup_size)
-	{
-		add(sCupsOfCoffeeConsumed, num_cups);
-		for (S32 i = 0; i < num_cups; i++)
-		{
-			record(sOuncesPerCup, cup_size);
-		}
-
-		sCaffeineLevel += F32Ounces(num_cups * cup_size).value() * sCaffeinePerOz.value();
-		sample(sCaffeineLevelStat, sCaffeineLevel);
-	}
-
-	// basic data collection
-	template<> template<>
-	void trace_object_t::test<1>()
-	{
-		sample(sCaffeineLevelStat, sCaffeineLevel);
-
-		Recording all_day;
-		Recording at_work;
-		Recording after_3pm;
-
-		all_day.start();
-		{
-			// warm up with one grande cup
-			drink_coffee(1, S32TallCup(1));
-
-			// go to work
-			at_work.start();
-			{
-				// drink 3 tall cups, 1 after 3 pm
-				drink_coffee(2, S32GrandeCup(1));
-				after_3pm.start();
-				drink_coffee(1, S32GrandeCup(1));
-			}
-			at_work.stop();
-			drink_coffee(1, S32VentiCup(1));
-		}
-		// don't need to stop recordings to get accurate values out of them
-		//after_3pm.stop();
-		//all_day.stop();
-
-		ensure("count stats are counted when recording is active", 
-			at_work.getSum(sCupsOfCoffeeConsumed) == 3 
-				&& all_day.getSum(sCupsOfCoffeeConsumed) == 5
-				&& after_3pm.getSum(sCupsOfCoffeeConsumed) == 2);
-		ensure("measurement sums are counted when recording is active", 
-			at_work.getSum(sOuncesPerCup) == S32Ounces(48) 
-				&& all_day.getSum(sOuncesPerCup) == S32Ounces(80)
-				&& after_3pm.getSum(sOuncesPerCup) == S32Ounces(36));
-		ensure("measurement min is specific to when recording is active", 
-			at_work.getMin(sOuncesPerCup) == S32GrandeCup(1) 
-				&& all_day.getMin(sOuncesPerCup) == S32TallCup(1)
-				&& after_3pm.getMin(sOuncesPerCup) == S32GrandeCup(1));
-		ensure("measurement max is specific to when recording is active", 
-			at_work.getMax(sOuncesPerCup) == S32GrandeCup(1) 
-				&& all_day.getMax(sOuncesPerCup) == S32VentiCup(1)
-				&& after_3pm.getMax(sOuncesPerCup) == S32VentiCup(1));
-		ensure("sample min is specific to when recording is active", 
-			at_work.getMin(sCaffeineLevelStat) == sCaffeinePerOz * ((S32Ounces)S32TallCup(1)).value()
-				&& all_day.getMin(sCaffeineLevelStat) == F32Milligrams(0.f)
-				&& after_3pm.getMin(sCaffeineLevelStat) == sCaffeinePerOz * ((S32Ounces)S32TallCup(1) + (S32Ounces)S32GrandeCup(2)).value());
-		ensure("sample max is specific to when recording is active", 
-			at_work.getMax(sCaffeineLevelStat) == sCaffeinePerOz * ((S32Ounces)S32TallCup(1) + (S32Ounces)S32GrandeCup(3)).value()
-				&& all_day.getMax(sCaffeineLevelStat) == sCaffeinePerOz * ((S32Ounces)S32TallCup(1) + (S32Ounces)S32GrandeCup(3) + (S32Ounces)S32VentiCup(1)).value()
-				&& after_3pm.getMax(sCaffeineLevelStat) == sCaffeinePerOz * ((S32Ounces)S32TallCup(1) + (S32Ounces)S32GrandeCup(3) + (S32Ounces)S32VentiCup(1)).value());
-	}
+    using namespace LLTrace;
+    struct trace
+    {
+        ThreadRecorder mRecorder;
+    };
+
+    typedef test_group<trace> trace_t;
+    typedef trace_t::object trace_object_t;
+    tut::trace_t tut_singleton("LLTrace");
+
+    static CountStatHandle<S32> sCupsOfCoffeeConsumed("coffeeconsumed", "Delicious cup of dark roast.");
+    static SampleStatHandle<F32Milligrams> sCaffeineLevelStat("caffeinelevel", "Coffee buzz quotient");
+    static EventStatHandle<S32Ounces> sOuncesPerCup("cupsize", "Large, huge, or ginormous");
+
+    static F32 sCaffeineLevel(0.f);
+    const F32Milligrams sCaffeinePerOz(18.f);
+
+    void drink_coffee(S32 num_cups, S32Ounces cup_size)
+    {
+        add(sCupsOfCoffeeConsumed, num_cups);
+        for (S32 i = 0; i < num_cups; i++)
+        {
+            record(sOuncesPerCup, cup_size);
+        }
+
+        sCaffeineLevel += F32Ounces(num_cups * cup_size).value() * sCaffeinePerOz.value();
+        sample(sCaffeineLevelStat, sCaffeineLevel);
+    }
+
+    // basic data collection
+    template<> template<>
+    void trace_object_t::test<1>()
+    {
+        sample(sCaffeineLevelStat, sCaffeineLevel);
+
+        Recording all_day;
+        Recording at_work;
+        Recording after_3pm;
+
+        all_day.start();
+        {
+            // warm up with one grande cup
+            drink_coffee(1, S32TallCup(1));
+
+            // go to work
+            at_work.start();
+            {
+                // drink 3 tall cups, 1 after 3 pm
+                drink_coffee(2, S32GrandeCup(1));
+                after_3pm.start();
+                drink_coffee(1, S32GrandeCup(1));
+            }
+            at_work.stop();
+            drink_coffee(1, S32VentiCup(1));
+        }
+        // don't need to stop recordings to get accurate values out of them
+        //after_3pm.stop();
+        //all_day.stop();
+
+        ensure("count stats are counted when recording is active",
+            at_work.getSum(sCupsOfCoffeeConsumed) == 3
+                && all_day.getSum(sCupsOfCoffeeConsumed) == 5
+                && after_3pm.getSum(sCupsOfCoffeeConsumed) == 2);
+        ensure("measurement sums are counted when recording is active",
+            at_work.getSum(sOuncesPerCup) == S32Ounces(48)
+                && all_day.getSum(sOuncesPerCup) == S32Ounces(80)
+                && after_3pm.getSum(sOuncesPerCup) == S32Ounces(36));
+        ensure("measurement min is specific to when recording is active",
+            at_work.getMin(sOuncesPerCup) == S32GrandeCup(1)
+                && all_day.getMin(sOuncesPerCup) == S32TallCup(1)
+                && after_3pm.getMin(sOuncesPerCup) == S32GrandeCup(1));
+        ensure("measurement max is specific to when recording is active",
+            at_work.getMax(sOuncesPerCup) == S32GrandeCup(1)
+                && all_day.getMax(sOuncesPerCup) == S32VentiCup(1)
+                && after_3pm.getMax(sOuncesPerCup) == S32VentiCup(1));
+        ensure("sample min is specific to when recording is active",
+            at_work.getMin(sCaffeineLevelStat) == sCaffeinePerOz * ((S32Ounces)S32TallCup(1)).value()
+                && all_day.getMin(sCaffeineLevelStat) == F32Milligrams(0.f)
+                && after_3pm.getMin(sCaffeineLevelStat) == sCaffeinePerOz * ((S32Ounces)S32TallCup(1) + (S32Ounces)S32GrandeCup(2)).value());
+        ensure("sample max is specific to when recording is active",
+            at_work.getMax(sCaffeineLevelStat) == sCaffeinePerOz * ((S32Ounces)S32TallCup(1) + (S32Ounces)S32GrandeCup(3)).value()
+                && all_day.getMax(sCaffeineLevelStat) == sCaffeinePerOz * ((S32Ounces)S32TallCup(1) + (S32Ounces)S32GrandeCup(3) + (S32Ounces)S32VentiCup(1)).value()
+                && after_3pm.getMax(sCaffeineLevelStat) == sCaffeinePerOz * ((S32Ounces)S32TallCup(1) + (S32Ounces)S32GrandeCup(3) + (S32Ounces)S32VentiCup(1)).value());
+    }
 
 }
diff --git a/indra/llcommon/tests/lltreeiterators_test.cpp b/indra/llcommon/tests/lltreeiterators_test.cpp
index 1d619867d4..7a2adfd8ba 100644
--- a/indra/llcommon/tests/lltreeiterators_test.cpp
+++ b/indra/llcommon/tests/lltreeiterators_test.cpp
@@ -3,25 +3,25 @@
  * @author Nat Goodspeed
  * @date   2008-08-20
  * @brief  Test of lltreeiterators.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$
  */
@@ -38,7 +38,6 @@
 // external library headers
 #include <boost/bind.hpp>
 #include <boost/range/iterator_range.hpp>
-#include <boost/foreach.hpp>
 
 // associated header
 #include "../lltreeiterators.h"
@@ -402,7 +401,7 @@ private:
  *
  * Example:
  * @code
- * BOOST_FOREACH(TreeNodePtr node, getRootRange<LLTreeIter::UP>(somenode))
+ * for (TreeNodePtr node : getRootRange<LLTreeIter::UP>(somenode))
  * {
  *     std::cout << node->name() << '\n';
  * }
@@ -424,7 +423,7 @@ getRootRange(const TreeNodePtr& node)
  *
  * Example:
  * @code
- * BOOST_FOREACH(TreeNodePtr node, getWalkRange<LLTreeIter::DFS_PRE>(root))
+ * for (TreeNodePtr node : getWalkRange<LLTreeIter::DFS_PRE>(root))
  * {
  *     std::cout << node->name() << '\n';
  * }
@@ -520,7 +519,7 @@ public:
      *
      * Example usage:
      * @code
-     * BOOST_FOREACH(EnhancedTreeNodePtr node, somenode->getRootRange<LLTreeIter::UP>())
+     * for (EnhancedTreeNodePtr node : somenode->getRootRange<LLTreeIter::UP>())
      * {
      *     std::cout << node->name() << '\n';
      * }
@@ -564,7 +563,7 @@ public:
      *
      * Example usage:
      * @code
-     * BOOST_FOREACH(EnhancedTreeNodePtr node, somenode->getWalkRange<LLTreeIter::DFS_PRE>())
+     * for (EnhancedTreeNodePtr node : somenode->getWalkRange<LLTreeIter::DFS_PRE>())
      * {
      *     std::cout << node->name() << '\n';
      * }
@@ -644,7 +643,7 @@ LLLinkedIter<PlainTree> PlainTree_child_end(PlainTree* node)
  *
  * Example:
  * @code
- * BOOST_FOREACH(PlainTree* node, getRootRange<LLTreeIter::UP>(somenode))
+ * for (PlainTree* node : getRootRange<LLTreeIter::UP>(somenode))
  * {
  *     std::cout << node->name() << '\n';
  * }
@@ -668,7 +667,7 @@ getRootRange(PlainTree* node)
  *
  * Example:
  * @code
- * BOOST_FOREACH(PlainTree* node, getWalkRange<LLTreeIter::DFS_PRE>(root))
+ * for (PlainTree* node : getWalkRange<LLTreeIter::DFS_PRE>(root))
  * {
  *     std::cout << node->name() << '\n';
  * }
@@ -1046,7 +1045,7 @@ bool LLTreeWalkIter_test(const std::string& itername, const std::string& nodenam
     {
         std::cout << itername << '<' << nodename << ">(NULL)\n";
         return false;
-    }             
+    }
     return true;
 }
 
@@ -1103,18 +1102,18 @@ namespace tut
         // This test function illustrates the looping techniques described in the
         // comments for the getRootRange() free function, the
         // EnhancedTreeNode::root_range template and the
-        // EnhancedTreeNode::getRootRange() method. Obviously the BOOST_FOREACH()
+        // EnhancedTreeNode::getRootRange() method. Obviously the for()
         // forms are more succinct.
         TreeNodePtr tnroot(example_tree<TreeNode>());
         TreeNodePtr tnB2b(get_B2b<TreeNode, TreeNode::child_iterator>
                           (tnroot, boost::bind(&TreeNode::child_begin, _1)));
-    
-        std::string desc1("BOOST_FOREACH(TreeNodePr, getRootRange<LLTreeIter::UP>(tnB2b))");
+
+        std::string desc1("for (TreeNodePr : getRootRange<LLTreeIter::UP>(tnB2b))");
 //      std::cout << desc1 << "\n";
         // Although we've commented out the output statement, ensure that the
         // loop construct is still valid, as promised by the getRootRange()
         // documentation.
-        BOOST_FOREACH(TreeNodePtr node, getRootRange<LLTreeIter::UP>(tnB2b))
+        for (TreeNodePtr node : getRootRange<LLTreeIter::UP>(tnB2b))
         {
 //          std::cout << node->name() << '\n';
         }
@@ -1137,9 +1136,9 @@ namespace tut
 //          std::cout << (*ri)->name() << '\n';
         }
 
-        std::string desc2("BOOST_FOREACH(EnhancedTreeNodePtr node, etnB2b->getRootRange<LLTreeIter::UP>())");
+        std::string desc2("for (EnhancedTreeNodePtr node : etnB2b->getRootRange<LLTreeIter::UP>())");
 //      std::cout << desc2 << '\n';
-        BOOST_FOREACH(EnhancedTreeNodePtr node, etnB2b->getRootRange<LLTreeIter::UP>())
+        for (EnhancedTreeNodePtr node : etnB2b->getRootRange<LLTreeIter::UP>())
         {
 //          std::cout << node->name() << '\n';
         }
diff --git a/indra/llcommon/tests/llunits_test.cpp b/indra/llcommon/tests/llunits_test.cpp
index 57cf9810af..49f2d3085a 100644
--- a/indra/llcommon/tests/llunits_test.cpp
+++ b/indra/llcommon/tests/llunits_test.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llsingleton_test.cpp
  * @date 2011-08-11
  * @brief Unit test for the LLSingleton class
@@ -32,10 +32,10 @@
 
 namespace LLUnits
 {
-	// using powers of 2 to allow strict floating point equality
-	LL_DECLARE_BASE_UNIT(Quatloos, "Quat");
-	LL_DECLARE_DERIVED_UNIT(Latinum, "Lat", Quatloos, / 4);
-	LL_DECLARE_DERIVED_UNIT(Solari, "Sol", Latinum, * 16);
+    // using powers of 2 to allow strict floating point equality
+    LL_DECLARE_BASE_UNIT(Quatloos, "Quat");
+    LL_DECLARE_DERIVED_UNIT(Latinum, "Lat", Quatloos, / 4);
+    LL_DECLARE_DERIVED_UNIT(Solari, "Sol", Latinum, * 16);
 }
 
 LL_DECLARE_UNIT_TYPEDEFS(LLUnits, Quatloos);
@@ -44,9 +44,9 @@ LL_DECLARE_UNIT_TYPEDEFS(LLUnits, Solari);
 
 namespace LLUnits
 {
-	LL_DECLARE_BASE_UNIT(Celcius, "c");
-	LL_DECLARE_DERIVED_UNIT(Fahrenheit, "f", Celcius, * 9 / 5 + 32);
-	LL_DECLARE_DERIVED_UNIT(Kelvin, "k", Celcius, + 273.15f);
+    LL_DECLARE_BASE_UNIT(Celcius, "c");
+    LL_DECLARE_DERIVED_UNIT(Fahrenheit, "f", Celcius, * 9 / 5 + 32);
+    LL_DECLARE_DERIVED_UNIT(Kelvin, "k", Celcius, + 273.15f);
 }
 
 LL_DECLARE_UNIT_TYPEDEFS(LLUnits, Celcius);
@@ -56,333 +56,333 @@ LL_DECLARE_UNIT_TYPEDEFS(LLUnits, Kelvin);
 
 namespace tut
 {
-	using namespace LLUnits;
-	struct units
-	{
-	};
-
-	typedef test_group<units> units_t;
-	typedef units_t::object units_object_t;
-	tut::units_t tut_singleton("LLUnit");
-
-	// storage type conversions
-	template<> template<>
-	void units_object_t::test<1>()
-	{
-		LLUnit<F32, Quatloos> float_quatloos;
-		ensure("default float unit is zero", float_quatloos == F32Quatloos(0.f));
-
-		LLUnit<F32, Quatloos> float_initialize_quatloos(1);
-		ensure("non-zero initialized unit", float_initialize_quatloos == F32Quatloos(1.f));
-
-		LLUnit<S32, Quatloos> int_quatloos;
-		ensure("default int unit is zero", int_quatloos == S32Quatloos(0));
-
-		int_quatloos = S32Quatloos(42);
-		ensure("int assignment is preserved", int_quatloos == S32Quatloos(42));
-		float_quatloos = int_quatloos;
-		ensure("float assignment from int preserves value", float_quatloos == F32Quatloos(42.f));
-
-		int_quatloos = float_quatloos;
-		ensure("int assignment from float preserves value", int_quatloos == S32Quatloos(42));
-
-		float_quatloos = F32Quatloos(42.1f);
-		int_quatloos = float_quatloos;
-		ensure("int units truncate float units on assignment", int_quatloos == S32Quatloos(42));
-
-		LLUnit<U32, Quatloos> unsigned_int_quatloos(float_quatloos);
-		ensure("unsigned int can be initialized from signed int", unsigned_int_quatloos == S32Quatloos(42));
-
-		S32Solari int_solari(1);
-
-		float_quatloos = int_solari;
-		ensure("fractional units are preserved in conversion from integer to float type", float_quatloos == F32Quatloos(0.25f));
-
-		int_quatloos = S32Quatloos(1);
-		F32Solari float_solari = int_quatloos;
-		ensure("can convert with fractional intermediates from integer to float type", float_solari == F32Solari(4.f));
-	}
-
-	// conversions to/from base unit
-	template<> template<>
-	void units_object_t::test<2>()
-	{
-		LLUnit<F32, Quatloos> quatloos(1.f);
-		LLUnit<F32, Latinum> latinum_bars(quatloos);
-		ensure("conversion between units is automatic via initialization", latinum_bars == F32Latinum(1.f / 4.f));
-
-		latinum_bars = S32Latinum(256);
-		quatloos = latinum_bars;
-		ensure("conversion between units is automatic via assignment, and bidirectional", quatloos == S32Quatloos(1024));
-
-		LLUnit<S32, Quatloos> single_quatloo(1);
-		LLUnit<F32, Latinum> quarter_latinum = single_quatloo;
-		ensure("division of integer unit preserves fractional values when converted to float unit", quarter_latinum == F32Latinum(0.25f));
-	}
-
-	// conversions across non-base units
-	template<> template<>
-	void units_object_t::test<3>()
-	{
-		LLUnit<F32, Quatloos> quatloos(1024);
-		LLUnit<F32, Solari> solari(quatloos);
-		ensure("conversions can work between indirectly related units: Quatloos -> Latinum -> Solari", solari == S32Solari(4096));
-
-		LLUnit<F32, Latinum> latinum_bars = solari;
-		ensure("Non base units can be converted between each other", latinum_bars == S32Latinum(256));
-	}
-
-	// math operations
-	template<> template<>
-	void units_object_t::test<4>()
-	{
-		// exercise math operations
-		LLUnit<F32, Quatloos> quatloos(1.f);
-		quatloos *= 4.f;
-		ensure(quatloos == S32Quatloos(4));
-		quatloos = quatloos * 2;
-		ensure(quatloos == S32Quatloos(8));
-		quatloos = 2.f * quatloos;
-		ensure(quatloos == S32Quatloos(16));
-
-		quatloos += F32Quatloos(4.f);
-		ensure(quatloos == S32Quatloos(20));
-		quatloos += S32Quatloos(4);
-		ensure(quatloos == S32Quatloos(24));
-		quatloos = quatloos + S32Quatloos(4);
-		ensure(quatloos == S32Quatloos(28));
-		quatloos = S32Quatloos(4) + quatloos;
-		ensure(quatloos == S32Quatloos(32));
-		quatloos += quatloos * 3;
-		ensure(quatloos == S32Quatloos(128));
-
-		quatloos -= quatloos / 4 * 3;
-		ensure(quatloos == S32Quatloos(32));
-		quatloos = quatloos - S32Quatloos(8);
-		ensure(quatloos == S32Quatloos(24));
-		quatloos -= S32Quatloos(4);
-		ensure(quatloos == S32Quatloos(20));
-		quatloos -= F32Quatloos(4.f);
-		ensure(quatloos == S32Quatloos(16));
-
-		quatloos /= 2.f;
-		ensure(quatloos == S32Quatloos(8));
-		quatloos = quatloos / 4;
-		ensure(quatloos == S32Quatloos(2));
-
-		F32 ratio = quatloos / LLUnit<F32, Quatloos>(2.f);
-		ensure(ratio == 1);
-		ratio = quatloos / LLUnit<F32, Solari>(8.f);
-		ensure(ratio == 1);
-
-		quatloos += LLUnit<F32, Solari>(8.f);
-		ensure(quatloos == S32Quatloos(4));
-		quatloos -= LLUnit<F32, Latinum>(1.f);
-		ensure(quatloos == S32Quatloos(0));
-	}
-
-	// comparison operators
-	template<> template<>
-	void units_object_t::test<5>()
-	{
-		LLUnit<S32, Quatloos> quatloos(1);
-		ensure("can perform less than comparison against same type", quatloos < S32Quatloos(2));
-		ensure("can perform less than comparison against different storage type", quatloos < F32Quatloos(2.f));
-		ensure("can perform less than comparison against different units", quatloos < S32Latinum(5));
-		ensure("can perform less than comparison against different storage type and units", quatloos < F32Latinum(5.f));
-
-		ensure("can perform greater than comparison against same type", quatloos > S32Quatloos(0));
-		ensure("can perform greater than comparison against different storage type", quatloos > F32Quatloos(0.f));
-		ensure("can perform greater than comparison against different units", quatloos > S32Latinum(0));
-		ensure("can perform greater than comparison against different storage type and units", quatloos > F32Latinum(0.f));
-
-	}
-
-	bool accept_explicit_quatloos(S32Quatloos q)
-	{
-		return true;
-	}
-
-	bool accept_implicit_quatloos(S32Quatloos q)
-	{
-		return true;
-	}
-
-	// signature compatibility
-	template<> template<>
-	void units_object_t::test<6>()
-	{
-		S32Quatloos quatloos(1);
-		ensure("can pass unit values as argument", accept_explicit_quatloos(S32Quatloos(1)));
-		ensure("can pass unit values as argument", accept_explicit_quatloos(quatloos));
-	}
-
-	// implicit units
-	template<> template<>
-	void units_object_t::test<7>()
-	{
-		LLUnit<F32, Quatloos> quatloos;
-		LLUnitImplicit<F32, Quatloos> quatloos_implicit = quatloos + S32Quatloos(1);
-		ensure("can initialize implicit unit from explicit", quatloos_implicit == 1);
-
-		quatloos = quatloos_implicit;
-		ensure("can assign implicit unit to explicit unit", quatloos == S32Quatloos(1));
-		quatloos += quatloos_implicit;
-		ensure("can perform math operation using mixture of implicit and explicit units", quatloos == S32Quatloos(2));
-
-		// math operations on implicits
-		quatloos_implicit = 1;
-		ensure(quatloos_implicit == 1);
-
-		quatloos_implicit += 2;
-		ensure(quatloos_implicit == 3);
-
-		quatloos_implicit *= 2;
-		ensure(quatloos_implicit == 6);
-
-		quatloos_implicit -= 1;
-		ensure(quatloos_implicit == 5);
-
-		quatloos_implicit /= 5;
-		ensure(quatloos_implicit == 1);
-
-		quatloos_implicit = quatloos_implicit + 3 + quatloos_implicit;
-		ensure(quatloos_implicit == 5);
-
-		quatloos_implicit = 10 - quatloos_implicit - 1;
-		ensure(quatloos_implicit == 4);
-
-		quatloos_implicit = 2 * quatloos_implicit * 2;
-		ensure(quatloos_implicit == 16);
-
-		F32 one_half = quatloos_implicit / (quatloos_implicit * 2);
-		ensure(one_half == 0.5f);
-
-		// implicit conversion to POD
-		F32 float_val = quatloos_implicit;
-		ensure("implicit units convert implicitly to regular values", float_val == 16);
-
-		S32 int_val = quatloos_implicit;
-		ensure("implicit units convert implicitly to regular values", int_val == 16);
-
-		// conversion of implicits
-		LLUnitImplicit<F32, Latinum> latinum_implicit(2);
-		ensure("implicit units of different types are comparable", latinum_implicit * 2 == quatloos_implicit);
-
-		quatloos_implicit += F32Quatloos(10);
-		ensure("can add-assign explicit units", quatloos_implicit == 26);
-
-		quatloos_implicit -= F32Quatloos(10);
-		ensure("can subtract-assign explicit units", quatloos_implicit == 16);
-
-		// comparisons
-		ensure("can compare greater than implicit unit", quatloos_implicit > F32QuatloosImplicit(0.f));
-		ensure("can compare greater than non-implicit unit", quatloos_implicit > F32Quatloos(0.f));
-		ensure("can compare greater than or equal to implicit unit", quatloos_implicit >= F32QuatloosImplicit(0.f));
-		ensure("can compare greater than or equal to non-implicit unit", quatloos_implicit >= F32Quatloos(0.f));
-		ensure("can compare less than implicit unit", quatloos_implicit < F32QuatloosImplicit(20.f));
-		ensure("can compare less than non-implicit unit", quatloos_implicit < F32Quatloos(20.f));
-		ensure("can compare less than or equal to implicit unit", quatloos_implicit <= F32QuatloosImplicit(20.f));
-		ensure("can compare less than or equal to non-implicit unit", quatloos_implicit <= F32Quatloos(20.f));
-	}
-
-	// precision tests
-	template<> template<>
-	void units_object_t::test<8>()
-	{
-		U32Bytes max_bytes(U32_MAX);
-		S32Megabytes mega_bytes = max_bytes;
-		ensure("max available precision is used when converting units", mega_bytes == (S32Megabytes)4095);
-
-		mega_bytes = (S32Megabytes)-5 + (U32Megabytes)1;
-		ensure("can mix signed and unsigned in units addition", mega_bytes == (S32Megabytes)-4);
-
-		mega_bytes = (U32Megabytes)5 + (S32Megabytes)-1;
-		ensure("can mix unsigned and signed in units addition", mega_bytes == (S32Megabytes)4);
-	}
-
-	// default units
-	template<> template<>
-	void units_object_t::test<9>()
-	{
-		U32Gigabytes GB(1);
-		U32Megabytes MB(GB);
-		U32Kilobytes KB(GB);
-		U32Bytes B(GB);
-
-		ensure("GB -> MB conversion", MB.value() == 1024);
-		ensure("GB -> KB conversion", KB.value() == 1024 * 1024);
-		ensure("GB -> B conversion", B.value() == 1024 * 1024 * 1024);
-
-		KB = U32Kilobytes(1);
-		U32Kilobits Kb(KB);
-		U32Bits b(KB);
-		ensure("KB -> Kb conversion", Kb.value() == 8);
-		ensure("KB -> b conversion", b.value() == 8 * 1024);
-
-		U32Days days(1);
-		U32Hours hours(days);
-		U32Minutes minutes(days);
-		U32Seconds seconds(days);
-		U32Milliseconds ms(days);
-		
-		ensure("days -> hours conversion", hours.value() == 24);
-		ensure("days -> minutes conversion", minutes.value() == 24 * 60);
-		ensure("days -> seconds conversion", seconds.value() == 24 * 60 * 60);
-		ensure("days -> ms conversion", ms.value() == 24 * 60 * 60 * 1000);
-
-		U32Kilometers km(1);
-		U32Meters m(km);
-		U32Centimeters cm(km);
-		U32Millimeters mm(km);
-
-		ensure("km -> m conversion", m.value() == 1000);
-		ensure("km -> cm conversion", cm.value() == 1000 * 100);
-		ensure("km -> mm conversion", mm.value() == 1000 * 1000);
-		
-		U32Gigahertz GHz(1);
-		U32Megahertz MHz(GHz);
-		U32Kilohertz KHz(GHz);
-		U32Hertz	 Hz(GHz);
-
-		ensure("GHz -> MHz conversion", MHz.value() == 1000);
-		ensure("GHz -> KHz conversion", KHz.value() == 1000 * 1000);
-		ensure("GHz -> Hz conversion", Hz.value() == 1000 * 1000 * 1000);
-
-		F32Radians rad(6.2831853071795f);
-		S32Degrees deg(rad);
-		ensure("radians -> degrees conversion", deg.value() == 360);
-
-		F32Percent percent(50);
-		F32Ratio ratio(percent);
-		ensure("percent -> ratio conversion", ratio.value() == 0.5f);
-
-		U32Kilotriangles ktris(1);
-		U32Triangles tris(ktris);
-		ensure("kilotriangles -> triangles conversion", tris.value() == 1000);
-	}
-
-	bool value_near(F32 value, F32 target, F32 threshold)
-	{
-		return fabsf(value - target) < threshold;
-	}
-
-	// linear transforms
-	template<> template<>
-	void units_object_t::test<10>()
-	{
-		F32Celcius float_celcius(100);
-		F32Fahrenheit float_fahrenheit(float_celcius);
-		ensure("floating point celcius -> fahrenheit conversion using linear transform", value_near(float_fahrenheit.value(), 212, 0.1f) );
-
-		float_celcius = float_fahrenheit;
-		ensure("floating point fahrenheit -> celcius conversion using linear transform (round trip)", value_near(float_celcius.value(), 100.f, 0.1f) );
-
-		S32Celcius int_celcius(100);
-		S32Fahrenheit int_fahrenheit(int_celcius);
-		ensure("integer celcius -> fahrenheit conversion using linear transform", int_fahrenheit.value() == 212);
-
-		int_celcius = int_fahrenheit;
-		ensure("integer fahrenheit -> celcius conversion using linear transform (round trip)", int_celcius.value() == 100);
-	}
+    using namespace LLUnits;
+    struct units
+    {
+    };
+
+    typedef test_group<units> units_t;
+    typedef units_t::object units_object_t;
+    tut::units_t tut_singleton("LLUnit");
+
+    // storage type conversions
+    template<> template<>
+    void units_object_t::test<1>()
+    {
+        LLUnit<F32, Quatloos> float_quatloos;
+        ensure("default float unit is zero", float_quatloos == F32Quatloos(0.f));
+
+        LLUnit<F32, Quatloos> float_initialize_quatloos(1);
+        ensure("non-zero initialized unit", float_initialize_quatloos == F32Quatloos(1.f));
+
+        LLUnit<S32, Quatloos> int_quatloos;
+        ensure("default int unit is zero", int_quatloos == S32Quatloos(0));
+
+        int_quatloos = S32Quatloos(42);
+        ensure("int assignment is preserved", int_quatloos == S32Quatloos(42));
+        float_quatloos = int_quatloos;
+        ensure("float assignment from int preserves value", float_quatloos == F32Quatloos(42.f));
+
+        int_quatloos = float_quatloos;
+        ensure("int assignment from float preserves value", int_quatloos == S32Quatloos(42));
+
+        float_quatloos = F32Quatloos(42.1f);
+        int_quatloos = float_quatloos;
+        ensure("int units truncate float units on assignment", int_quatloos == S32Quatloos(42));
+
+        LLUnit<U32, Quatloos> unsigned_int_quatloos(float_quatloos);
+        ensure("unsigned int can be initialized from signed int", unsigned_int_quatloos == S32Quatloos(42));
+
+        S32Solari int_solari(1);
+
+        float_quatloos = int_solari;
+        ensure("fractional units are preserved in conversion from integer to float type", float_quatloos == F32Quatloos(0.25f));
+
+        int_quatloos = S32Quatloos(1);
+        F32Solari float_solari = int_quatloos;
+        ensure("can convert with fractional intermediates from integer to float type", float_solari == F32Solari(4.f));
+    }
+
+    // conversions to/from base unit
+    template<> template<>
+    void units_object_t::test<2>()
+    {
+        LLUnit<F32, Quatloos> quatloos(1.f);
+        LLUnit<F32, Latinum> latinum_bars(quatloos);
+        ensure("conversion between units is automatic via initialization", latinum_bars == F32Latinum(1.f / 4.f));
+
+        latinum_bars = S32Latinum(256);
+        quatloos = latinum_bars;
+        ensure("conversion between units is automatic via assignment, and bidirectional", quatloos == S32Quatloos(1024));
+
+        LLUnit<S32, Quatloos> single_quatloo(1);
+        LLUnit<F32, Latinum> quarter_latinum = single_quatloo;
+        ensure("division of integer unit preserves fractional values when converted to float unit", quarter_latinum == F32Latinum(0.25f));
+    }
+
+    // conversions across non-base units
+    template<> template<>
+    void units_object_t::test<3>()
+    {
+        LLUnit<F32, Quatloos> quatloos(1024);
+        LLUnit<F32, Solari> solari(quatloos);
+        ensure("conversions can work between indirectly related units: Quatloos -> Latinum -> Solari", solari == S32Solari(4096));
+
+        LLUnit<F32, Latinum> latinum_bars = solari;
+        ensure("Non base units can be converted between each other", latinum_bars == S32Latinum(256));
+    }
+
+    // math operations
+    template<> template<>
+    void units_object_t::test<4>()
+    {
+        // exercise math operations
+        LLUnit<F32, Quatloos> quatloos(1.f);
+        quatloos *= 4.f;
+        ensure(quatloos == S32Quatloos(4));
+        quatloos = quatloos * 2;
+        ensure(quatloos == S32Quatloos(8));
+        quatloos = 2.f * quatloos;
+        ensure(quatloos == S32Quatloos(16));
+
+        quatloos += F32Quatloos(4.f);
+        ensure(quatloos == S32Quatloos(20));
+        quatloos += S32Quatloos(4);
+        ensure(quatloos == S32Quatloos(24));
+        quatloos = quatloos + S32Quatloos(4);
+        ensure(quatloos == S32Quatloos(28));
+        quatloos = S32Quatloos(4) + quatloos;
+        ensure(quatloos == S32Quatloos(32));
+        quatloos += quatloos * 3;
+        ensure(quatloos == S32Quatloos(128));
+
+        quatloos -= quatloos / 4 * 3;
+        ensure(quatloos == S32Quatloos(32));
+        quatloos = quatloos - S32Quatloos(8);
+        ensure(quatloos == S32Quatloos(24));
+        quatloos -= S32Quatloos(4);
+        ensure(quatloos == S32Quatloos(20));
+        quatloos -= F32Quatloos(4.f);
+        ensure(quatloos == S32Quatloos(16));
+
+        quatloos /= 2.f;
+        ensure(quatloos == S32Quatloos(8));
+        quatloos = quatloos / 4;
+        ensure(quatloos == S32Quatloos(2));
+
+        F32 ratio = quatloos / LLUnit<F32, Quatloos>(2.f);
+        ensure(ratio == 1);
+        ratio = quatloos / LLUnit<F32, Solari>(8.f);
+        ensure(ratio == 1);
+
+        quatloos += LLUnit<F32, Solari>(8.f);
+        ensure(quatloos == S32Quatloos(4));
+        quatloos -= LLUnit<F32, Latinum>(1.f);
+        ensure(quatloos == S32Quatloos(0));
+    }
+
+    // comparison operators
+    template<> template<>
+    void units_object_t::test<5>()
+    {
+        LLUnit<S32, Quatloos> quatloos(1);
+        ensure("can perform less than comparison against same type", quatloos < S32Quatloos(2));
+        ensure("can perform less than comparison against different storage type", quatloos < F32Quatloos(2.f));
+        ensure("can perform less than comparison against different units", quatloos < S32Latinum(5));
+        ensure("can perform less than comparison against different storage type and units", quatloos < F32Latinum(5.f));
+
+        ensure("can perform greater than comparison against same type", quatloos > S32Quatloos(0));
+        ensure("can perform greater than comparison against different storage type", quatloos > F32Quatloos(0.f));
+        ensure("can perform greater than comparison against different units", quatloos > S32Latinum(0));
+        ensure("can perform greater than comparison against different storage type and units", quatloos > F32Latinum(0.f));
+
+    }
+
+    bool accept_explicit_quatloos(S32Quatloos q)
+    {
+        return true;
+    }
+
+    bool accept_implicit_quatloos(S32Quatloos q)
+    {
+        return true;
+    }
+
+    // signature compatibility
+    template<> template<>
+    void units_object_t::test<6>()
+    {
+        S32Quatloos quatloos(1);
+        ensure("can pass unit values as argument", accept_explicit_quatloos(S32Quatloos(1)));
+        ensure("can pass unit values as argument", accept_explicit_quatloos(quatloos));
+    }
+
+    // implicit units
+    template<> template<>
+    void units_object_t::test<7>()
+    {
+        LLUnit<F32, Quatloos> quatloos;
+        LLUnitImplicit<F32, Quatloos> quatloos_implicit = quatloos + S32Quatloos(1);
+        ensure("can initialize implicit unit from explicit", quatloos_implicit == 1);
+
+        quatloos = quatloos_implicit;
+        ensure("can assign implicit unit to explicit unit", quatloos == S32Quatloos(1));
+        quatloos += quatloos_implicit;
+        ensure("can perform math operation using mixture of implicit and explicit units", quatloos == S32Quatloos(2));
+
+        // math operations on implicits
+        quatloos_implicit = 1;
+        ensure(quatloos_implicit == 1);
+
+        quatloos_implicit += 2;
+        ensure(quatloos_implicit == 3);
+
+        quatloos_implicit *= 2;
+        ensure(quatloos_implicit == 6);
+
+        quatloos_implicit -= 1;
+        ensure(quatloos_implicit == 5);
+
+        quatloos_implicit /= 5;
+        ensure(quatloos_implicit == 1);
+
+        quatloos_implicit = quatloos_implicit + 3 + quatloos_implicit;
+        ensure(quatloos_implicit == 5);
+
+        quatloos_implicit = 10 - quatloos_implicit - 1;
+        ensure(quatloos_implicit == 4);
+
+        quatloos_implicit = 2 * quatloos_implicit * 2;
+        ensure(quatloos_implicit == 16);
+
+        F32 one_half = quatloos_implicit / (quatloos_implicit * 2);
+        ensure(one_half == 0.5f);
+
+        // implicit conversion to POD
+        F32 float_val = quatloos_implicit;
+        ensure("implicit units convert implicitly to regular values", float_val == 16);
+
+        S32 int_val = quatloos_implicit;
+        ensure("implicit units convert implicitly to regular values", int_val == 16);
+
+        // conversion of implicits
+        LLUnitImplicit<F32, Latinum> latinum_implicit(2);
+        ensure("implicit units of different types are comparable", latinum_implicit * 2 == quatloos_implicit);
+
+        quatloos_implicit += F32Quatloos(10);
+        ensure("can add-assign explicit units", quatloos_implicit == 26);
+
+        quatloos_implicit -= F32Quatloos(10);
+        ensure("can subtract-assign explicit units", quatloos_implicit == 16);
+
+        // comparisons
+        ensure("can compare greater than implicit unit", quatloos_implicit > F32QuatloosImplicit(0.f));
+        ensure("can compare greater than non-implicit unit", quatloos_implicit > F32Quatloos(0.f));
+        ensure("can compare greater than or equal to implicit unit", quatloos_implicit >= F32QuatloosImplicit(0.f));
+        ensure("can compare greater than or equal to non-implicit unit", quatloos_implicit >= F32Quatloos(0.f));
+        ensure("can compare less than implicit unit", quatloos_implicit < F32QuatloosImplicit(20.f));
+        ensure("can compare less than non-implicit unit", quatloos_implicit < F32Quatloos(20.f));
+        ensure("can compare less than or equal to implicit unit", quatloos_implicit <= F32QuatloosImplicit(20.f));
+        ensure("can compare less than or equal to non-implicit unit", quatloos_implicit <= F32Quatloos(20.f));
+    }
+
+    // precision tests
+    template<> template<>
+    void units_object_t::test<8>()
+    {
+        U32Bytes max_bytes(U32_MAX);
+        S32Megabytes mega_bytes = max_bytes;
+        ensure("max available precision is used when converting units", mega_bytes == (S32Megabytes)4095);
+
+        mega_bytes = (S32Megabytes)-5 + (U32Megabytes)1;
+        ensure("can mix signed and unsigned in units addition", mega_bytes == (S32Megabytes)-4);
+
+        mega_bytes = (U32Megabytes)5 + (S32Megabytes)-1;
+        ensure("can mix unsigned and signed in units addition", mega_bytes == (S32Megabytes)4);
+    }
+
+    // default units
+    template<> template<>
+    void units_object_t::test<9>()
+    {
+        U32Gigabytes GB(1);
+        U32Megabytes MB(GB);
+        U32Kilobytes KB(GB);
+        U32Bytes B(GB);
+
+        ensure("GB -> MB conversion", MB.value() == 1024);
+        ensure("GB -> KB conversion", KB.value() == 1024 * 1024);
+        ensure("GB -> B conversion", B.value() == 1024 * 1024 * 1024);
+
+        KB = U32Kilobytes(1);
+        U32Kilobits Kb(KB);
+        U32Bits b(KB);
+        ensure("KB -> Kb conversion", Kb.value() == 8);
+        ensure("KB -> b conversion", b.value() == 8 * 1024);
+
+        U32Days days(1);
+        U32Hours hours(days);
+        U32Minutes minutes(days);
+        U32Seconds seconds(days);
+        U32Milliseconds ms(days);
+
+        ensure("days -> hours conversion", hours.value() == 24);
+        ensure("days -> minutes conversion", minutes.value() == 24 * 60);
+        ensure("days -> seconds conversion", seconds.value() == 24 * 60 * 60);
+        ensure("days -> ms conversion", ms.value() == 24 * 60 * 60 * 1000);
+
+        U32Kilometers km(1);
+        U32Meters m(km);
+        U32Centimeters cm(km);
+        U32Millimeters mm(km);
+
+        ensure("km -> m conversion", m.value() == 1000);
+        ensure("km -> cm conversion", cm.value() == 1000 * 100);
+        ensure("km -> mm conversion", mm.value() == 1000 * 1000);
+
+        U32Gigahertz GHz(1);
+        U32Megahertz MHz(GHz);
+        U32Kilohertz KHz(GHz);
+        U32Hertz     Hz(GHz);
+
+        ensure("GHz -> MHz conversion", MHz.value() == 1000);
+        ensure("GHz -> KHz conversion", KHz.value() == 1000 * 1000);
+        ensure("GHz -> Hz conversion", Hz.value() == 1000 * 1000 * 1000);
+
+        F32Radians rad(6.2831853071795f);
+        S32Degrees deg(rad);
+        ensure("radians -> degrees conversion", deg.value() == 360);
+
+        F32Percent percent(50);
+        F32Ratio ratio(percent);
+        ensure("percent -> ratio conversion", ratio.value() == 0.5f);
+
+        U32Kilotriangles ktris(1);
+        U32Triangles tris(ktris);
+        ensure("kilotriangles -> triangles conversion", tris.value() == 1000);
+    }
+
+    bool value_near(F32 value, F32 target, F32 threshold)
+    {
+        return fabsf(value - target) < threshold;
+    }
+
+    // linear transforms
+    template<> template<>
+    void units_object_t::test<10>()
+    {
+        F32Celcius float_celcius(100);
+        F32Fahrenheit float_fahrenheit(float_celcius);
+        ensure("floating point celcius -> fahrenheit conversion using linear transform", value_near(float_fahrenheit.value(), 212, 0.1f) );
+
+        float_celcius = float_fahrenheit;
+        ensure("floating point fahrenheit -> celcius conversion using linear transform (round trip)", value_near(float_celcius.value(), 100.f, 0.1f) );
+
+        S32Celcius int_celcius(100);
+        S32Fahrenheit int_fahrenheit(int_celcius);
+        ensure("integer celcius -> fahrenheit conversion using linear transform", int_fahrenheit.value() == 212);
+
+        int_celcius = int_fahrenheit;
+        ensure("integer fahrenheit -> celcius conversion using linear transform (round trip)", int_celcius.value() == 100);
+    }
 }
diff --git a/indra/llcommon/tests/lluri_test.cpp b/indra/llcommon/tests/lluri_test.cpp
index 1a4c6641b9..b48dd3ef1b 100644
--- a/indra/llcommon/tests/lluri_test.cpp
+++ b/indra/llcommon/tests/lluri_test.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$
  */
@@ -34,359 +34,359 @@
 
 namespace tut
 {
-	struct URITestData {
-		void checkParts(const LLURI& u,
-				const char* expectedScheme,
-				const char* expectedOpaque,
-				const char* expectedAuthority,
-				const char* expectedPath,
-				const char* expectedQuery = "")
-		{
-			ensure_equals("scheme",		u.scheme(),		expectedScheme);
-			ensure_equals("opaque",		u.opaque(),		expectedOpaque);
-			ensure_equals("authority",	u.authority(),	expectedAuthority);
-			ensure_equals("path",		u.path(),		expectedPath);
-			ensure_equals("query",		u.query(),		expectedQuery);
-		}
-
-		void escapeRoundTrip(const std::string& uri_raw_1)
-		{
-			std::string uri_esc_1(LLURI::escape(uri_raw_1));
-			std::string uri_raw_2(LLURI::unescape(uri_esc_1));
-			ensure_equals("escape/unescape raw", uri_raw_2, uri_raw_1);
-			std::string uri_esc_2(LLURI::escape(uri_raw_2));
-			ensure_equals("escape/unescape escaped", uri_esc_2, uri_esc_1);
-		}
-	};
-
-	typedef test_group<URITestData>	URITestGroup;
-	typedef URITestGroup::object	URITestObject;
-
-	URITestGroup uriTestGroup("LLURI");
-
-	template<> template<>
-	void URITestObject::test<1>()
-	{
-		LLURI u("http://abc.com/def/ghi?x=37&y=hello");
-
-		ensure_equals("scheme",		u.scheme(),		"http");
-		ensure_equals("authority",	u.authority(),	"abc.com");
-		ensure_equals("path",		u.path(),		"/def/ghi");
-		ensure_equals("query",		u.query(),		"x=37&y=hello");
-
-		ensure_equals("host name", u.hostName(), "abc.com");
-		ensure_equals("host port", u.hostPort(), 80);
-
-		LLSD query = u.queryMap();
-		ensure_equals("query x", query["x"].asInteger(), 37);
-		ensure_equals("query y", query["y"].asString(), "hello");
-
-		query = LLURI::queryMap("x=22.23&y=https://lindenlab.com/");
-		ensure_equals("query x", query["x"].asReal(), 22.23);
-		ensure_equals("query y", query["y"].asURI().asString(), "https://lindenlab.com/");
-	}
-
-	template<> template<>
-	void URITestObject::test<2>()
-	{
-		set_test_name("empty string");
-		checkParts(LLURI(""), "", "", "", "");
-	}
-
-	template<> template<>
-	void URITestObject::test<3>()
-	{
-		set_test_name("no scheme");
-		checkParts(LLURI("foo"), "", "foo", "", "");
-		checkParts(LLURI("foo%3A"), "", "foo:", "", "");
-	}
-
-	template<> template<>
-	void URITestObject::test<4>()
-	{
-		set_test_name("scheme w/o paths");
-		checkParts(LLURI("mailto:zero@ll.com"),
-			"mailto", "zero@ll.com", "", "");
-		checkParts(LLURI("silly://abc/def?foo"),
-			"silly", "//abc/def?foo", "", "");
-	}
-
-	template<> template<>
-	void URITestObject::test<5>()
-	{
-		set_test_name("authority section");
-		checkParts(LLURI("http:///"),
-			"http", "///", "", "/");
-
-		checkParts(LLURI("http://abc"),
-			"http", "//abc", "abc", "");
-
-		checkParts(LLURI("http://a%2Fb/cd"),
-			"http", "//a/b/cd", "a/b", "/cd");
-
-		checkParts(LLURI("http://host?"),
-			"http", "//host?", "host", "");
-	}
-
-	template<> template<>
-	void URITestObject::test<6>()
-	{		
-		set_test_name("path section");
-		checkParts(LLURI("http://host/a/b/"),
-				"http", "//host/a/b/", "host", "/a/b/");
-
-		checkParts(LLURI("http://host/a%3Fb/"),
-				"http", "//host/a?b/", "host", "/a?b/");
-
-		checkParts(LLURI("http://host/a:b/"),
-				"http", "//host/a:b/", "host", "/a:b/");
-	}
-
-	template<> template<>
-	void URITestObject::test<7>()
-	{		
-		set_test_name("query string");
-		checkParts(LLURI("http://host/?"),
-				"http", "//host/?", "host", "/", "");
-
-		checkParts(LLURI("http://host/?x"),
-				"http", "//host/?x", "host", "/", "x");
-
-		checkParts(LLURI("http://host/??"),
-				"http", "//host/??", "host", "/", "?");
-
-		checkParts(LLURI("http://host/?%3F"),
-				"http", "//host/??", "host", "/", "?");
-	}
-
-	template<> template<>
-	void URITestObject::test<8>()
-	{
-		LLSD path;
-		path.append("x");
-		path.append("123");
-		checkParts(LLURI::buildHTTP("host", path),
-			"http", "//host/x/123", "host", "/x/123");
-
-		LLSD query;
-		query["123"] = "12";
-		query["abcd"] = "abc";
-		checkParts(LLURI::buildHTTP("host", path, query),
-			"http", "//host/x/123?123=12&abcd=abc",
-			"host", "/x/123", "123=12&abcd=abc");
-
-		ensure_equals(LLURI::buildHTTP("host", "").asString(),
-					  "http://host");
-		ensure_equals(LLURI::buildHTTP("host", "/").asString(),
-					  "http://host/");
-		ensure_equals(LLURI::buildHTTP("host", "//").asString(),
-					  "http://host/");
-		ensure_equals(LLURI::buildHTTP("host", "dir name").asString(),
-					  "http://host/dir%20name");
-		ensure_equals(LLURI::buildHTTP("host", "dir name/").asString(),
-					  "http://host/dir%20name/");
-		ensure_equals(LLURI::buildHTTP("host", "/dir name").asString(),
-					  "http://host/dir%20name");
-		ensure_equals(LLURI::buildHTTP("host", "/dir name/").asString(),
-					  "http://host/dir%20name/");
-		ensure_equals(LLURI::buildHTTP("host", "dir name/subdir name").asString(),
-					  "http://host/dir%20name/subdir%20name");
-		ensure_equals(LLURI::buildHTTP("host", "dir name/subdir name/").asString(),
-					  "http://host/dir%20name/subdir%20name/");
-		ensure_equals(LLURI::buildHTTP("host", "/dir name/subdir name").asString(),
-					  "http://host/dir%20name/subdir%20name");
-		ensure_equals(LLURI::buildHTTP("host", "/dir name/subdir name/").asString(),
-					  "http://host/dir%20name/subdir%20name/");
-		ensure_equals(LLURI::buildHTTP("host", "//dir name//subdir name//").asString(),
-					  "http://host/dir%20name/subdir%20name/");
-	}
-
-	template<> template<>
-	void URITestObject::test<9>()
-	{
-		set_test_name("test unescaped path components");
-		LLSD path;
-		path.append("x@*//*$&^");
-		path.append("123");
-		checkParts(LLURI::buildHTTP("host", path),
-			"http", "//host/x@*//*$&^/123", "host", "/x@*//*$&^/123");
-	}
-
-	template<> template<>
-	void URITestObject::test<10>()
-	{
-		set_test_name("test unescaped query components");
-		LLSD path;
-		path.append("x");
-		path.append("123");
-		LLSD query;
-		query["123"] = "?&*#//";
-		query["**@&?//"] = "abc";
-		checkParts(LLURI::buildHTTP("host", path, query),
-			"http", "//host/x/123?**@&?//=abc&123=?&*#//",
-			"host", "/x/123", "**@&?//=abc&123=?&*#//");
-	}
-
-	template<> template<>
-	void URITestObject::test<11>()
-	{
-		set_test_name("test unescaped host components");
-		LLSD path;
-		path.append("x");
-		path.append("123");
-		LLSD query;
-		query["123"] = "12";
-		query["abcd"] = "abc";
-		checkParts(LLURI::buildHTTP("hi123*33--}{:portstuffs", path, query),
-			"http", "//hi123*33--}{:portstuffs/x/123?123=12&abcd=abc",
-			"hi123*33--}{:portstuffs", "/x/123", "123=12&abcd=abc");
-	}
-
-	template<> template<>
-	void URITestObject::test<12>()
-	{
-		set_test_name("test funky host_port values that are actually prefixes");
-
-		checkParts(LLURI::buildHTTP("http://example.com:8080", LLSD()),
-			"http", "//example.com:8080",
-			"example.com:8080", "");
-
-		checkParts(LLURI::buildHTTP("http://example.com:8080/", LLSD()),
-			"http", "//example.com:8080/",
-			"example.com:8080", "/");
-
-		checkParts(LLURI::buildHTTP("http://example.com:8080/a/b", LLSD()),
-			"http", "//example.com:8080/a/b",
-			"example.com:8080", "/a/b");
-	}
-
-	template<> template<>
-	void URITestObject::test<13>()
-	{
-		const std::string unreserved =   
-			"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-			"0123456789"
-			"-._~";
-		set_test_name("test escape");
-		ensure_equals("escaping", LLURI::escape("abcdefg", "abcdef"), "abcdef%67");
-		ensure_equals("escaping", LLURI::escape("|/&\\+-_!@", ""), "%7C%2F%26%5C%2B%2D%5F%21%40");
-		ensure_equals("escaping as query variable", 
-					  LLURI::escape("http://10.0.1.4:12032/agent/god/agent-id/map/layer/?resume=http://station3.ll.com:12032/agent/203ad6df-b522-491d-ba48-4e24eb57aeff/send-postcard", unreserved + ":@!$'()*+,="), 
-					  "http:%2F%2F10.0.1.4:12032%2Fagent%2Fgod%2Fagent-id%2Fmap%2Flayer%2F%3Fresume=http:%2F%2Fstation3.ll.com:12032%2Fagent%2F203ad6df-b522-491d-ba48-4e24eb57aeff%2Fsend-postcard");
-		// French cedilla (C with squiggle, like in the word Francais) is UTF-8 C3 A7
+    struct URITestData {
+        void checkParts(const LLURI& u,
+                const char* expectedScheme,
+                const char* expectedOpaque,
+                const char* expectedAuthority,
+                const char* expectedPath,
+                const char* expectedQuery = "")
+        {
+            ensure_equals("scheme",     u.scheme(),     expectedScheme);
+            ensure_equals("opaque",     u.opaque(),     expectedOpaque);
+            ensure_equals("authority",  u.authority(),  expectedAuthority);
+            ensure_equals("path",       u.path(),       expectedPath);
+            ensure_equals("query",      u.query(),      expectedQuery);
+        }
+
+        void escapeRoundTrip(const std::string& uri_raw_1)
+        {
+            std::string uri_esc_1(LLURI::escape(uri_raw_1));
+            std::string uri_raw_2(LLURI::unescape(uri_esc_1));
+            ensure_equals("escape/unescape raw", uri_raw_2, uri_raw_1);
+            std::string uri_esc_2(LLURI::escape(uri_raw_2));
+            ensure_equals("escape/unescape escaped", uri_esc_2, uri_esc_1);
+        }
+    };
+
+    typedef test_group<URITestData> URITestGroup;
+    typedef URITestGroup::object    URITestObject;
+
+    URITestGroup uriTestGroup("LLURI");
+
+    template<> template<>
+    void URITestObject::test<1>()
+    {
+        LLURI u("http://abc.com/def/ghi?x=37&y=hello");
+
+        ensure_equals("scheme",     u.scheme(),     "http");
+        ensure_equals("authority",  u.authority(),  "abc.com");
+        ensure_equals("path",       u.path(),       "/def/ghi");
+        ensure_equals("query",      u.query(),      "x=37&y=hello");
+
+        ensure_equals("host name", u.hostName(), "abc.com");
+        ensure_equals("host port", u.hostPort(), 80);
+
+        LLSD query = u.queryMap();
+        ensure_equals("query x", query["x"].asInteger(), 37);
+        ensure_equals("query y", query["y"].asString(), "hello");
+
+        query = LLURI::queryMap("x=22.23&y=https://lindenlab.com/");
+        ensure_equals("query x", query["x"].asReal(), 22.23);
+        ensure_equals("query y", query["y"].asURI().asString(), "https://lindenlab.com/");
+    }
+
+    template<> template<>
+    void URITestObject::test<2>()
+    {
+        set_test_name("empty string");
+        checkParts(LLURI(""), "", "", "", "");
+    }
+
+    template<> template<>
+    void URITestObject::test<3>()
+    {
+        set_test_name("no scheme");
+        checkParts(LLURI("foo"), "", "foo", "", "");
+        checkParts(LLURI("foo%3A"), "", "foo:", "", "");
+    }
+
+    template<> template<>
+    void URITestObject::test<4>()
+    {
+        set_test_name("scheme w/o paths");
+        checkParts(LLURI("mailto:zero@ll.com"),
+            "mailto", "zero@ll.com", "", "");
+        checkParts(LLURI("silly://abc/def?foo"),
+            "silly", "//abc/def?foo", "", "");
+    }
+
+    template<> template<>
+    void URITestObject::test<5>()
+    {
+        set_test_name("authority section");
+        checkParts(LLURI("http:///"),
+            "http", "///", "", "/");
+
+        checkParts(LLURI("http://abc"),
+            "http", "//abc", "abc", "");
+
+        checkParts(LLURI("http://a%2Fb/cd"),
+            "http", "//a/b/cd", "a/b", "/cd");
+
+        checkParts(LLURI("http://host?"),
+            "http", "//host?", "host", "");
+    }
+
+    template<> template<>
+    void URITestObject::test<6>()
+    {
+        set_test_name("path section");
+        checkParts(LLURI("http://host/a/b/"),
+                "http", "//host/a/b/", "host", "/a/b/");
+
+        checkParts(LLURI("http://host/a%3Fb/"),
+                "http", "//host/a?b/", "host", "/a?b/");
+
+        checkParts(LLURI("http://host/a:b/"),
+                "http", "//host/a:b/", "host", "/a:b/");
+    }
+
+    template<> template<>
+    void URITestObject::test<7>()
+    {
+        set_test_name("query string");
+        checkParts(LLURI("http://host/?"),
+                "http", "//host/?", "host", "/", "");
+
+        checkParts(LLURI("http://host/?x"),
+                "http", "//host/?x", "host", "/", "x");
+
+        checkParts(LLURI("http://host/??"),
+                "http", "//host/??", "host", "/", "?");
+
+        checkParts(LLURI("http://host/?%3F"),
+                "http", "//host/??", "host", "/", "?");
+    }
+
+    template<> template<>
+    void URITestObject::test<8>()
+    {
+        LLSD path;
+        path.append("x");
+        path.append("123");
+        checkParts(LLURI::buildHTTP("host", path),
+            "http", "//host/x/123", "host", "/x/123");
+
+        LLSD query;
+        query["123"] = "12";
+        query["abcd"] = "abc";
+        checkParts(LLURI::buildHTTP("host", path, query),
+            "http", "//host/x/123?123=12&abcd=abc",
+            "host", "/x/123", "123=12&abcd=abc");
+
+        ensure_equals(LLURI::buildHTTP("host", "").asString(),
+                      "http://host");
+        ensure_equals(LLURI::buildHTTP("host", "/").asString(),
+                      "http://host/");
+        ensure_equals(LLURI::buildHTTP("host", "//").asString(),
+                      "http://host/");
+        ensure_equals(LLURI::buildHTTP("host", "dir name").asString(),
+                      "http://host/dir%20name");
+        ensure_equals(LLURI::buildHTTP("host", "dir name/").asString(),
+                      "http://host/dir%20name/");
+        ensure_equals(LLURI::buildHTTP("host", "/dir name").asString(),
+                      "http://host/dir%20name");
+        ensure_equals(LLURI::buildHTTP("host", "/dir name/").asString(),
+                      "http://host/dir%20name/");
+        ensure_equals(LLURI::buildHTTP("host", "dir name/subdir name").asString(),
+                      "http://host/dir%20name/subdir%20name");
+        ensure_equals(LLURI::buildHTTP("host", "dir name/subdir name/").asString(),
+                      "http://host/dir%20name/subdir%20name/");
+        ensure_equals(LLURI::buildHTTP("host", "/dir name/subdir name").asString(),
+                      "http://host/dir%20name/subdir%20name");
+        ensure_equals(LLURI::buildHTTP("host", "/dir name/subdir name/").asString(),
+                      "http://host/dir%20name/subdir%20name/");
+        ensure_equals(LLURI::buildHTTP("host", "//dir name//subdir name//").asString(),
+                      "http://host/dir%20name/subdir%20name/");
+    }
+
+    template<> template<>
+    void URITestObject::test<9>()
+    {
+        set_test_name("test unescaped path components");
+        LLSD path;
+        path.append("x@*//*$&^");
+        path.append("123");
+        checkParts(LLURI::buildHTTP("host", path),
+            "http", "//host/x@*//*$&^/123", "host", "/x@*//*$&^/123");
+    }
+
+    template<> template<>
+    void URITestObject::test<10>()
+    {
+        set_test_name("test unescaped query components");
+        LLSD path;
+        path.append("x");
+        path.append("123");
+        LLSD query;
+        query["123"] = "?&*#//";
+        query["**@&?//"] = "abc";
+        checkParts(LLURI::buildHTTP("host", path, query),
+            "http", "//host/x/123?**@&?//=abc&123=?&*#//",
+            "host", "/x/123", "**@&?//=abc&123=?&*#//");
+    }
+
+    template<> template<>
+    void URITestObject::test<11>()
+    {
+        set_test_name("test unescaped host components");
+        LLSD path;
+        path.append("x");
+        path.append("123");
+        LLSD query;
+        query["123"] = "12";
+        query["abcd"] = "abc";
+        checkParts(LLURI::buildHTTP("hi123*33--}{:portstuffs", path, query),
+            "http", "//hi123*33--}{:portstuffs/x/123?123=12&abcd=abc",
+            "hi123*33--}{:portstuffs", "/x/123", "123=12&abcd=abc");
+    }
+
+    template<> template<>
+    void URITestObject::test<12>()
+    {
+        set_test_name("test funky host_port values that are actually prefixes");
+
+        checkParts(LLURI::buildHTTP("http://example.com:8080", LLSD()),
+            "http", "//example.com:8080",
+            "example.com:8080", "");
+
+        checkParts(LLURI::buildHTTP("http://example.com:8080/", LLSD()),
+            "http", "//example.com:8080/",
+            "example.com:8080", "/");
+
+        checkParts(LLURI::buildHTTP("http://example.com:8080/a/b", LLSD()),
+            "http", "//example.com:8080/a/b",
+            "example.com:8080", "/a/b");
+    }
+
+    template<> template<>
+    void URITestObject::test<13>()
+    {
+        const std::string unreserved =
+            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+            "0123456789"
+            "-._~";
+        set_test_name("test escape");
+        ensure_equals("escaping", LLURI::escape("abcdefg", "abcdef"), "abcdef%67");
+        ensure_equals("escaping", LLURI::escape("|/&\\+-_!@", ""), "%7C%2F%26%5C%2B%2D%5F%21%40");
+        ensure_equals("escaping as query variable",
+                      LLURI::escape("http://10.0.1.4:12032/agent/god/agent-id/map/layer/?resume=http://station3.ll.com:12032/agent/203ad6df-b522-491d-ba48-4e24eb57aeff/send-postcard", unreserved + ":@!$'()*+,="),
+                      "http:%2F%2F10.0.1.4:12032%2Fagent%2Fgod%2Fagent-id%2Fmap%2Flayer%2F%3Fresume=http:%2F%2Fstation3.ll.com:12032%2Fagent%2F203ad6df-b522-491d-ba48-4e24eb57aeff%2Fsend-postcard");
+        // French cedilla (C with squiggle, like in the word Francais) is UTF-8 C3 A7
 
 #if LL_WINDOWS
 #pragma warning(disable: 4309)
 #endif
 
-		std::string cedilla;
-		cedilla.push_back( (char)0xC3 );
-		cedilla.push_back( (char)0xA7 );
-		ensure_equals("escape UTF8", LLURI::escape( cedilla, unreserved), "%C3%A7");
-	}
-
-
-	template<> template<>
-	void URITestObject::test<14>()
-	{
-		set_test_name("make sure escape and unescape of empty strings return empty strings.");
-		std::string uri_esc(LLURI::escape(""));
-		ensure("escape string empty", uri_esc.empty());
-		std::string uri_raw(LLURI::unescape(""));
-		ensure("unescape string empty", uri_raw.empty());
-	}
-
-	template<> template<>
-	void URITestObject::test<15>()
-	{
-		set_test_name("do some round-trip tests");
-		escapeRoundTrip("http://secondlife.com");
-		escapeRoundTrip("http://secondlife.com/url with spaces");
-		escapeRoundTrip("http://bad[domain]name.com/");
-		escapeRoundTrip("ftp://bill.gates@ms/micro$oft.com/c:\\autoexec.bat");
-		escapeRoundTrip("");
-	}
-
-	template<> template<>
-	void URITestObject::test<16>()
-	{
-		set_test_name("Test the default escaping");
-		// yes -- this mangles the url. This is expected behavior
-		std::string simple("http://secondlife.com");
-		ensure_equals(
-			"simple http",
-			LLURI::escape(simple),
-			"http%3A%2F%2Fsecondlife.com");
-		ensure_equals(
-			"needs escape",
-			LLURI::escape("http://get.secondlife.com/windows viewer"),
-			"http%3A%2F%2Fget.secondlife.com%2Fwindows%20viewer");
-	}
-
-	template<> template<>
-	void URITestObject::test<17>()
-	{
-		set_test_name("do some round-trip tests with very long strings.");
-		escapeRoundTrip("Welcome to Second Life.We hope you'll have a richly rewarding experience, filled with creativity, self expression and fun.The goals of the Community Standards are simple: treat each other with respect and without harassment, adhere to local standards as indicated by simulator ratings, and refrain from any hate activity which slurs a real-world individual or real-world community. Behavioral Guidelines - The Big Six");
-		escapeRoundTrip(
-			"'asset_data':b(12100){'task_id':ucc706f2d-0b68-68f8-11a4-f1043ff35ca0}\n{\n\tname\tObject|\n\tpermissions 0\n\t{\n\t\tbase_mask\t7fffffff\n\t\towner_mask\t7fffffff\n\t\tgroup_mask\t00000000\n\t\teveryone_mask\t00000000\n\t\tnext_owner_mask\t7fffffff\n\t\tcreator_id\t13fd9595-a47b-4d64-a5fb-6da645f038e0\n\t\towner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tlast_owner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tgroup_id\t00000000-0000-0000-0000-000000000000\n\t}\n\tlocal_id\t217444921\n\ttotal_crc\t323\n\ttype\t2\n\ttask_valid\t2\n\ttravel_access\t13\n\tdisplayopts\t2\n\tdisplaytype\tv\n\tpos\t-0.368634403\t0.00781063363\t-0.569040775\n\toldpos\t150.117996\t25.8658009\t8.19664001\n\trotation\t-0.06293071806430816650390625\t-0.6995697021484375\t-0.7002241611480712890625\t0.1277817934751510620117188\n\tchildpos\t-0.00499999989\t-0.0359999985\t0.307999998\n\tchildrot\t-0.515492737293243408203125\t-0.46601200103759765625\t0.529055416584014892578125\t0.4870323240756988525390625\n\tscale"
-			"\t0.074629\t0.289956\t0.01\n\tsit_offset\t0\t0\t0\n\tcamera_eye_offset\t0\t0\t0\n\tcamera_at_offset\t0\t0\t0\n\tsit_quat\t0\t0\t0\t1\n\tsit_hint\t0\n\tstate\t160\n\tmaterial\t3\n\tsoundid\t00000000-0000-0000-0000-000000000000\n\tsoundgain\t0\n\tsoundradius\t0\n\tsoundflags\t0\n\ttextcolor\t0 0 0 1\n\tselected\t0\n\tselector\t00000000-0000-0000-0000-000000000000\n\tusephysics\t0\n\trotate_x\t1\n\trotate_y\t1\n\trotate_z\t1\n\tphantom\t0\n\tremote_script_access_pin\t0\n\tvolume_detect\t0\n\tblock_grabs\t0\n\tdie_at_edge\t0\n\treturn_at_edge\t0\n\ttemporary\t0\n\tsandbox\t0\n\tsandboxhome\t0\t0\t0\n\tshape 0\n\t{\n\t\tpath 0\n\t\t{\n\t\t\tcurve\t16\n\t\t\tbegin\t0\n\t\t\tend\t1\n\t\t\tscale_x\t1\n\t\t\tscale_y\t1\n\t\t\tshear_x\t0\n\t\t\tshear_y\t0\n\t\t\ttwist\t0\n\t\t\ttwist_begin\t0\n\t\t\tradius_offset\t0\n\t\t\ttaper_x\t0\n\t\t\ttaper_y\t0\n\t\t\trevolutions\t1\n\t\t\tskew\t0\n\t\t}\n\t\tprofile 0\n\t\t{\n\t\t\tcurve\t1\n\t\t\tbegin\t0\n\t\t\tend\t1\n\t\t\thollow\t0\n\t\t}\n\t}\n\tf"
-			"aces\t6\n\t{\n\t\timageid\tddde1ffc-678b-3cda-1748-513086bdf01b\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204"
-			"\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tddde1ffc-678b-3cda-1748-513086bdf01b\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t-1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\tps_next_crc\t1\n\tgpw_bias\t1\n\tip\t0\n\tcomplete\tTRUE\n\tdelay\t50000\n\tnextstart\t0\n\tbirthtime\t1061088050622956\n\treztime\t1094866329019785\n\tparceltime\t1133568981980596\n\ttax_rate\t1.00084\n\tscratchpad\t0\n\t{\n\t\n\t}\n\tsale_info\t0\n\t{\n\t\tsale_type\tnot\n\t\tsale_price\t10\n\t}\n\tcorrect_family_id\t00000000-0000-0000-0000-000000000000\n\thas_rezzed\t0\n\tpre_link_base_mask\t7fffffff\n\tlinked \tchild\n\tdefault_pay_price\t-2\t1\t5\t10\t20\n}\n{'task_id':u61fa7364-e151-0597-774c-523312dae31b}\n{\n\tname\tObject|\n\tpermissions 0\n\t{\n\t\tbase_mask\t7fffff"
-			"ff\n\t\towner_mask\t7fffffff\n\t\tgroup_mask\t00000000\n\t\teveryone_mask\t00000000\n\t\tnext_owner_mask\t7fffffff\n\t\tcreator_id\t13fd9595-a47b-4d64-a5fb-6da645f038e0\n\t\towner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tlast_owner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tgroup_id\t00000000-0000-0000-0000-000000000000\n\t}\n\tlocal_id\t217444922\n\ttotal_crc\t324\n\ttype\t2\n\ttask_valid\t2\n\ttravel_access\t13\n\tdisplayopts\t2\n\tdisplaytype\tv\n\tpos\t-0.367110789\t0.00780026987\t-0.566269755\n\toldpos\t150.115005\t25.8479004\t8.18669987\n\trotation\t0.47332942485809326171875\t-0.380102097988128662109375\t-0.5734078884124755859375\t0.550168216228485107421875\n\tchildpos\t-0.00499999989\t-0.0370000005\t0.305000007\n\tchildrot\t-0.736649334430694580078125\t-0.03042060509324073791503906\t-0.02784589119255542755126953\t0.67501628398895263671875\n\tscale\t0.074629\t0.289956\t0.01\n\tsit_offset\t0\t0\t0\n\tcamera_eye_offset\t0\t0\t0\n\tcamera_at_offset\t0\t0\t0\n\tsit_quat\t0\t"
-			"0\t0\t1\n\tsit_hint\t0\n\tstate\t160\n\tmaterial\t3\n\tsoundid\t00000000-0000-0000-0000-000000000000\n\tsoundgain\t0\n\tsoundradius\t0\n\tsoundflags\t0\n\ttextcolor\t0 0 0 1\n\tselected\t0\n\tselector\t00000000-0000-0000-0000-000000000000\n\tusephysics\t0\n\trotate_x\t1\n\trotate_y\t1\n\trotate_z\t1\n\tphantom\t0\n\tremote_script_access_pin\t0\n\tvolume_detect\t0\n\tblock_grabs\t0\n\tdie_at_edge\t0\n\treturn_at_edge\t0\n\ttemporary\t0\n\tsandbox\t0\n\tsandboxhome\t0\t0\t0\n\tshape 0\n\t{\n\t\tpath 0\n\t\t{\n\t\t\tcurve\t16\n\t\t\tbegin\t0\n\t\t\tend\t1\n\t\t\tscale_x\t1\n\t\t\tscale_y\t1\n\t\t\tshear_x\t0\n\t\t\tshear_y\t0\n\t\t\ttwist\t0\n\t\t\ttwist_begin\t0\n\t\t\tradius_offset\t0\n\t\t\ttaper_x\t0\n\t\t\ttaper_y\t0\n\t\t\trevolutions\t1\n\t\t\tskew\t0\n\t\t}\n\t\tprofile 0\n\t\t{\n\t\t\tcurve\t1\n\t\t\tbegin\t0\n\t\t\tend\t1\n\t\t\thollow\t0\n\t\t}\n\t}\n\tfaces\t6\n\t{\n\t\timageid\tddde1ffc-678b-3cda-1748-513086bdf01b\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t"
-			"\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t"
-			"\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tddde1ffc-678b-3cda-1748-513086bdf01b\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t-1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\tps_next_crc\t1\n\tgpw_bias\t1\n\tip\t0\n\tcomplete\tTRUE\n\tdelay\t50000\n\tnextstart\t0\n\tbirthtime\t1061087839248891\n\treztime\t1094866329020800\n\tparceltime\t1133568981981983\n\ttax_rate\t1.00084\n\tscratchpad\t0\n\t{\n\t\n\t}\n\tsale_info\t0\n\t{\n\t\tsale_type\tnot\n\t\tsale_price\t10\n\t}\n\tcorrect_family_id\t00000000-0000-0000-0000-000000000000\n\thas_rezzed\t0\n\tpre_link_base_mask\t7fffffff\n\tlinked \tchild\n\tdefault_pay_price\t-2\t1\t5\t10\t20\n}\n{'task_id':ub8d68643-7dd8-57af-0d24-8790032aed0c}\n{\n\tname\tObject|\n\tpermissions 0\n\t{\n\t\tbase_mask\t7fffffff\n\t\towner_mask\t7fffffff\n\t\tgroup_mask\t00000000\n\t\teveryone_mask\t00000000\n\t\tnext_owner_mask\t7fffffff\n\t\tcreat"
-			"or_id\t13fd9595-a47b-4d64-a5fb-6da645f038e0\n\t\towner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tlast_owner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tgroup_id\t00000000-0000-0000-0000-000000000000\n\t}\n\tlocal_id\t217444923\n\ttotal_crc\t235\n\ttype\t2\n\ttask_valid\t2\n\ttravel_access\t13\n\tdisplayopts\t2\n\tdisplaytype\tv\n\tpos\t-0.120029509\t-0.00284469454\t-0.0302077383\n\toldpos\t150.710999\t25.8584995\t8.19172001\n\trotation\t0.145459949970245361328125\t-0.1646589934825897216796875\t0.659558117389678955078125\t-0.718826770782470703125\n\tchildpos\t0\t-0.182999998\t-0.26699999\n\tchildrot\t0.991444766521453857421875\t3.271923924330621957778931e-05\t-0.0002416197530692443251609802\t0.1305266767740249633789062\n\tscale\t0.0382982\t0.205957\t0.368276\n\tsit_offset\t0\t0\t0\n\tcamera_eye_offset\t0\t0\t0\n\tcamera_at_offset\t0\t0\t0\n\tsit_quat\t0\t0\t0\t1\n\tsit_hint\t0\n\tstate\t160\n\tmaterial\t3\n\tsoundid\t00000000-0000-0000-0000-000000000000\n\tsoundgain\t0\n\tsoundra"
-			"dius\t0\n\tsoundflags\t0\n\ttextcolor\t0 0 0 1\n\tselected\t0\n\tselector\t00000000-0000-0000-0000-000000000000\n\tusephysics\t0\n\trotate_x\t1\n\trotate_y\t1\n\trotate_z\t1\n\tphantom\t0\n\tremote_script_access_pin\t0\n\tvolume_detect\t0\n\tblock_grabs\t0\n\tdie_at_edge\t0\n\treturn_at_edge\t0\n\ttemporary\t0\n\tsandbox\t0\n\tsandboxhome\t0\t0\t0\n\tshape 0\n\t{\n\t\tpath 0\n\t\t{\n\t\t\tcurve\t32\n\t\t\tbegin\t0.3\n\t\t\tend\t0.65\n\t\t\tscale_x\t1\n\t\t\tscale_y\t0.05\n\t\t\tshear_x\t0\n\t\t\tshear_y\t0\n\t\t\ttwist\t0\n\t\t\ttwist_begin\t0\n\t\t\tradius_offset\t0\n\t\t\ttaper_x\t0\n\t\t\ttaper_y\t0\n\t\t\trevolutions\t1\n\t\t\tskew\t0\n\t\t}\n\t\tprofile 0\n\t\t{\n\t\t\tcurve\t0\n\t\t\tbegin\t0\n\t\t\tend\t1\n\t\t\thollow\t0\n\t\t}\n\t}\n\tfaces\t3\n\t{\n\t\timageid\te7150bed-3e3e-c698-eb15-d17b178148af\n\t\tcolors\t0.843137 0.156863 0.156863 1\n\t\tscales\t15\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t-1.57084\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0"
-			"\n\t}\n\t{\n\t\timageid\te7150bed-3e3e-c698-eb15-d17b178148af\n\t\tcolors\t0.843137 0.156863 0.156863 1\n\t\tscales\t15\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t-1.57084\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\te7150bed-3e3e-c698-eb15-d17b178148af\n\t\tcolors\t0.843137 0.156863 0.156863 1\n\t\tscales\t15\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t-1.57084\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\tps_next_crc\t1\n\tgpw_bias\t1\n\tip\t0\n\tcomplete\tTRUE\n\tdelay\t50000\n\tnextstart\t0\n\tbirthtime\t1061087534454174\n\treztime\t1094866329021741\n\tparceltime\t1133568981982889\n\ttax_rate\t1.00326\n\tscratchpad\t0\n\t{\n\t\n\t}\n\tsale_info\t0\n\t{\n\t\tsale_type\tnot\n\t\tsale_price\t10\n\t}\n\tcorrect_family_id\t00000000-0000-0000-0000-000000000000\n\thas_rezzed\t0\n\tpre_link_base_mask\t7fffffff\n\tlinked \tchild\n\tdefault_pay_price\t-2\t1\t5\t10\t20\n}\n{'task_id':ue4b19200-9d33-962f-c8c5-6f"
-			"25be3a3fd0}\n{\n\tname\tApotheosis_Immolaine_tail|\n\tpermissions 0\n\t{\n\t\tbase_mask\t7fffffff\n\t\towner_mask\t7fffffff\n\t\tgroup_mask\t00000000\n\t\teveryone_mask\t00000000\n\t\tnext_owner_mask\t7fffffff\n\t\tcreator_id\t13fd9595-a47b-4d64-a5fb-6da645f038e0\n\t\towner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tlast_owner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tgroup_id\t00000000-0000-0000-0000-000000000000\n\t}\n\tlocal_id\t217444924\n\ttotal_crc\t675\n\ttype\t1\n\ttask_valid\t2\n\ttravel_access\t13\n\tdisplayopts\t2\n\tdisplaytype\tv\n\tpos\t-0.34780401\t-0.00968400016\t-0.260098994\n\toldpos\t0\t0\t0\n\trotation\t0.73164522647857666015625\t-0.67541944980621337890625\t-0.07733880728483200073242188\t0.05022468417882919311523438\n\tvelocity\t0\t0\t0\n\tangvel\t0\t0\t0\n\tscale\t0.0382982\t0.32228\t0.383834\n\tsit_offset\t0\t0\t0\n\tcamera_eye_offset\t0\t0\t0\n\tcamera_at_offset\t0\t0\t0\n\tsit_quat\t0\t0\t0\t1\n\tsit_hint\t0\n\tstate\t160\n\tmaterial\t3\n\tsoundid\t00000"
-			"000-0000-0000-0000-000000000000\n\tsoundgain\t0\n\tsoundradius\t0\n\tsoundflags\t0\n\ttextcolor\t0 0 0 1\n\tselected\t0\n\tselector\t00000000-0000-0000-0000-000000000000\n\tusephysics\t0\n\trotate_x\t1\n\trotate_y\t1\n\trotate_z\t1\n\tphantom\t0\n\tremote_script_access_pin\t0\n\tvolume_detect\t0\n\tblock_grabs\t0\n\tdie_at_edge\t0\n\treturn_at_edge\t0\n\ttemporary\t0\n\tsandbox\t0\n\tsandboxhome\t0\t0\t0\n\tshape 0\n\t{\n\t\tpath 0\n\t\t{\n\t\t\tcurve\t32\n\t\t\tbegin\t0.3\n\t\t\tend\t0.65\n\t\t\tscale_x\t1\n\t\t\tscale_y\t0.05\n\t\t\tshear_x\t0\n\t\t\tshear_y\t0\n\t\t\ttwist\t0\n\t\t\ttwist_begin\t0\n\t\t\tradius_offset\t0\n\t\t\ttaper_x\t0\n\t\t\ttaper_y\t0\n\t\t\trevolutions\t1\n\t\t\tskew\t0\n\t\t}\n\t\tprofile 0\n\t\t{\n\t\t\tcurve\t0\n\t\t\tbegin\t0\n\t\t\tend\t1\n\t\t\thollow\t0\n\t\t}\n\t}\n\tfaces\t3\n\t{\n\t\timageid\te7150bed-3e3e-c698-eb15-d17b178148af\n\t\tcolors\t0.843137 0.156863 0.156863 1\n\t\tscales\t15\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t-1"
-			".57084\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\te7150bed-3e3e-c698-eb15-d17b178148af\n\t\tcolors\t0.843137 0.156863 0.156863 1\n\t\tscales\t15\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t-1.57084\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\te7150bed-3e3e-c698-eb15-d17b178148af\n\t\tcolors\t0.843137 0.156863 0.156863 1\n\t\tscales\t15\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t-1.57084\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\tps_next_crc\t1\n\tgpw_bias\t1\n\tip\t0\n\tcomplete\tTRUE\n\tdelay\t50000\n\tnextstart\t0\n\tbirthtime\t1061087463950186\n\treztime\t1094866329022555\n\tparceltime\t1133568981984359\n\tdescription\t(No Description)|\n\ttax_rate\t1.01736\n\tnamevalue\tAttachPt U32 RW S 10\n\tnamevalue\tAttachmentOrientation VEC3 RW DS -3.110088, -0.182018, 1.493795\n\tnamevalue\tAttachmentOffset VEC3 RW DS -0.347804, -0.009684, -0.260099\n\tnamevalue\tAttachItemI"
-			"D STRING RW SV 20f36c3a-b44b-9bc7-87f3-018bfdfc8cda\n\tscratchpad\t0\n\t{\n\t\n\t}\n\tsale_info\t0\n\t{\n\t\tsale_type\tnot\n\t\tsale_price\t10\n\t}\n\torig_asset_id\t8747acbc-d391-1e59-69f1-41d06830e6c0\n\torig_item_id\t20f36c3a-b44b-9bc7-87f3-018bfdfc8cda\n\tfrom_task_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\tcorrect_family_id\t00000000-0000-0000-0000-000000000000\n\thas_rezzed\t0\n\tpre_link_base_mask\t7fffffff\n\tlinked \tlinked\n\tdefault_pay_price\t-2\t1\t5\t10\t20\n}\n");
-	}
-
-
-	template<> template<>
-	void URITestObject::test<18>()
-	{
-		LLURI u("secondlife:///app/login?first_name=Testert4&last_name=Tester&web_login_key=test");
-		// if secondlife is the scheme, LLURI should parse /app/login as path, with no authority 
-		ensure_equals("scheme",		u.scheme(),		"secondlife");
-		ensure_equals("authority",	u.authority(),	"");
-		ensure_equals("path",		u.path(),		"/app/login");
-		ensure_equals("pathmap",	u.pathArray()[0].asString(),	"app");
-		ensure_equals("pathmap",	u.pathArray()[1].asString(),	"login");
-		ensure_equals("query",		u.query(),		"first_name=Testert4&last_name=Tester&web_login_key=test");
-		ensure_equals("query map element", u.queryMap()["last_name"].asString(), "Tester");
-
-		u = LLURI("secondlife://Da Boom/128/128/128");
-		// if secondlife is the scheme, LLURI should parse /128/128/128 as path, with Da Boom as authority
-		ensure_equals("scheme",		u.scheme(),		"secondlife");
-		ensure_equals("authority",	u.authority(),	"Da Boom");
-		ensure_equals("path",		u.path(),		"/128/128/128");
-		ensure_equals("pathmap",	u.pathArray()[0].asString(),	"128");
-		ensure_equals("pathmap",	u.pathArray()[1].asString(),	"128");
-		ensure_equals("pathmap",	u.pathArray()[2].asString(),	"128");
-		ensure_equals("query",		u.query(),		"");
-	}
-
-	template<> template<>
-	void URITestObject::test<19>()
-	{
-		set_test_name("Parse about: schemes");
-		LLURI u("about:blank?redirect-http-hack=secondlife%3A%2F%2F%2Fapp%2Flogin%3Ffirst_name%3DCallum%26last_name%3DLinden%26location%3Dspecify%26grid%3Dvaak%26region%3D%2FMorris%2F128%2F128%26web_login_key%3Defaa4795-c2aa-4c58-8966-763c27931e78");
-		ensure_equals("scheme",		u.scheme(),		"about");
-		ensure_equals("authority",	u.authority(),	"");
-		ensure_equals("path",		u.path(),		"blank");
-		ensure_equals("pathmap",	u.pathArray()[0].asString(),	"blank");
-		ensure_equals("query",		u.query(),		"redirect-http-hack=secondlife:///app/login?first_name=Callum&last_name=Linden&location=specify&grid=vaak&region=/Morris/128/128&web_login_key=efaa4795-c2aa-4c58-8966-763c27931e78");
-		ensure_equals("query map element", u.queryMap()["redirect-http-hack"].asString(), "secondlife:///app/login?first_name=Callum&last_name=Linden&location=specify&grid=vaak&region=/Morris/128/128&web_login_key=efaa4795-c2aa-4c58-8966-763c27931e78");
-	}
-
-	template<> template<>
-	void URITestObject::test<20>()
-	{
+        std::string cedilla;
+        cedilla.push_back( (char)0xC3 );
+        cedilla.push_back( (char)0xA7 );
+        ensure_equals("escape UTF8", LLURI::escape( cedilla, unreserved), "%C3%A7");
+    }
+
+
+    template<> template<>
+    void URITestObject::test<14>()
+    {
+        set_test_name("make sure escape and unescape of empty strings return empty strings.");
+        std::string uri_esc(LLURI::escape(""));
+        ensure("escape string empty", uri_esc.empty());
+        std::string uri_raw(LLURI::unescape(""));
+        ensure("unescape string empty", uri_raw.empty());
+    }
+
+    template<> template<>
+    void URITestObject::test<15>()
+    {
+        set_test_name("do some round-trip tests");
+        escapeRoundTrip("http://secondlife.com");
+        escapeRoundTrip("http://secondlife.com/url with spaces");
+        escapeRoundTrip("http://bad[domain]name.com/");
+        escapeRoundTrip("ftp://bill.gates@ms/micro$oft.com/c:\\autoexec.bat");
+        escapeRoundTrip("");
+    }
+
+    template<> template<>
+    void URITestObject::test<16>()
+    {
+        set_test_name("Test the default escaping");
+        // yes -- this mangles the url. This is expected behavior
+        std::string simple("http://secondlife.com");
+        ensure_equals(
+            "simple http",
+            LLURI::escape(simple),
+            "http%3A%2F%2Fsecondlife.com");
+        ensure_equals(
+            "needs escape",
+            LLURI::escape("http://get.secondlife.com/windows viewer"),
+            "http%3A%2F%2Fget.secondlife.com%2Fwindows%20viewer");
+    }
+
+    template<> template<>
+    void URITestObject::test<17>()
+    {
+        set_test_name("do some round-trip tests with very long strings.");
+        escapeRoundTrip("Welcome to Second Life.We hope you'll have a richly rewarding experience, filled with creativity, self expression and fun.The goals of the Community Standards are simple: treat each other with respect and without harassment, adhere to local standards as indicated by simulator ratings, and refrain from any hate activity which slurs a real-world individual or real-world community. Behavioral Guidelines - The Big Six");
+        escapeRoundTrip(
+            "'asset_data':b(12100){'task_id':ucc706f2d-0b68-68f8-11a4-f1043ff35ca0}\n{\n\tname\tObject|\n\tpermissions 0\n\t{\n\t\tbase_mask\t7fffffff\n\t\towner_mask\t7fffffff\n\t\tgroup_mask\t00000000\n\t\teveryone_mask\t00000000\n\t\tnext_owner_mask\t7fffffff\n\t\tcreator_id\t13fd9595-a47b-4d64-a5fb-6da645f038e0\n\t\towner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tlast_owner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tgroup_id\t00000000-0000-0000-0000-000000000000\n\t}\n\tlocal_id\t217444921\n\ttotal_crc\t323\n\ttype\t2\n\ttask_valid\t2\n\ttravel_access\t13\n\tdisplayopts\t2\n\tdisplaytype\tv\n\tpos\t-0.368634403\t0.00781063363\t-0.569040775\n\toldpos\t150.117996\t25.8658009\t8.19664001\n\trotation\t-0.06293071806430816650390625\t-0.6995697021484375\t-0.7002241611480712890625\t0.1277817934751510620117188\n\tchildpos\t-0.00499999989\t-0.0359999985\t0.307999998\n\tchildrot\t-0.515492737293243408203125\t-0.46601200103759765625\t0.529055416584014892578125\t0.4870323240756988525390625\n\tscale"
+            "\t0.074629\t0.289956\t0.01\n\tsit_offset\t0\t0\t0\n\tcamera_eye_offset\t0\t0\t0\n\tcamera_at_offset\t0\t0\t0\n\tsit_quat\t0\t0\t0\t1\n\tsit_hint\t0\n\tstate\t160\n\tmaterial\t3\n\tsoundid\t00000000-0000-0000-0000-000000000000\n\tsoundgain\t0\n\tsoundradius\t0\n\tsoundflags\t0\n\ttextcolor\t0 0 0 1\n\tselected\t0\n\tselector\t00000000-0000-0000-0000-000000000000\n\tusephysics\t0\n\trotate_x\t1\n\trotate_y\t1\n\trotate_z\t1\n\tphantom\t0\n\tremote_script_access_pin\t0\n\tvolume_detect\t0\n\tblock_grabs\t0\n\tdie_at_edge\t0\n\treturn_at_edge\t0\n\ttemporary\t0\n\tsandbox\t0\n\tsandboxhome\t0\t0\t0\n\tshape 0\n\t{\n\t\tpath 0\n\t\t{\n\t\t\tcurve\t16\n\t\t\tbegin\t0\n\t\t\tend\t1\n\t\t\tscale_x\t1\n\t\t\tscale_y\t1\n\t\t\tshear_x\t0\n\t\t\tshear_y\t0\n\t\t\ttwist\t0\n\t\t\ttwist_begin\t0\n\t\t\tradius_offset\t0\n\t\t\ttaper_x\t0\n\t\t\ttaper_y\t0\n\t\t\trevolutions\t1\n\t\t\tskew\t0\n\t\t}\n\t\tprofile 0\n\t\t{\n\t\t\tcurve\t1\n\t\t\tbegin\t0\n\t\t\tend\t1\n\t\t\thollow\t0\n\t\t}\n\t}\n\tf"
+            "aces\t6\n\t{\n\t\timageid\tddde1ffc-678b-3cda-1748-513086bdf01b\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204"
+            "\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tddde1ffc-678b-3cda-1748-513086bdf01b\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t-1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\tps_next_crc\t1\n\tgpw_bias\t1\n\tip\t0\n\tcomplete\tTRUE\n\tdelay\t50000\n\tnextstart\t0\n\tbirthtime\t1061088050622956\n\treztime\t1094866329019785\n\tparceltime\t1133568981980596\n\ttax_rate\t1.00084\n\tscratchpad\t0\n\t{\n\t\n\t}\n\tsale_info\t0\n\t{\n\t\tsale_type\tnot\n\t\tsale_price\t10\n\t}\n\tcorrect_family_id\t00000000-0000-0000-0000-000000000000\n\thas_rezzed\t0\n\tpre_link_base_mask\t7fffffff\n\tlinked \tchild\n\tdefault_pay_price\t-2\t1\t5\t10\t20\n}\n{'task_id':u61fa7364-e151-0597-774c-523312dae31b}\n{\n\tname\tObject|\n\tpermissions 0\n\t{\n\t\tbase_mask\t7fffff"
+            "ff\n\t\towner_mask\t7fffffff\n\t\tgroup_mask\t00000000\n\t\teveryone_mask\t00000000\n\t\tnext_owner_mask\t7fffffff\n\t\tcreator_id\t13fd9595-a47b-4d64-a5fb-6da645f038e0\n\t\towner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tlast_owner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tgroup_id\t00000000-0000-0000-0000-000000000000\n\t}\n\tlocal_id\t217444922\n\ttotal_crc\t324\n\ttype\t2\n\ttask_valid\t2\n\ttravel_access\t13\n\tdisplayopts\t2\n\tdisplaytype\tv\n\tpos\t-0.367110789\t0.00780026987\t-0.566269755\n\toldpos\t150.115005\t25.8479004\t8.18669987\n\trotation\t0.47332942485809326171875\t-0.380102097988128662109375\t-0.5734078884124755859375\t0.550168216228485107421875\n\tchildpos\t-0.00499999989\t-0.0370000005\t0.305000007\n\tchildrot\t-0.736649334430694580078125\t-0.03042060509324073791503906\t-0.02784589119255542755126953\t0.67501628398895263671875\n\tscale\t0.074629\t0.289956\t0.01\n\tsit_offset\t0\t0\t0\n\tcamera_eye_offset\t0\t0\t0\n\tcamera_at_offset\t0\t0\t0\n\tsit_quat\t0\t"
+            "0\t0\t1\n\tsit_hint\t0\n\tstate\t160\n\tmaterial\t3\n\tsoundid\t00000000-0000-0000-0000-000000000000\n\tsoundgain\t0\n\tsoundradius\t0\n\tsoundflags\t0\n\ttextcolor\t0 0 0 1\n\tselected\t0\n\tselector\t00000000-0000-0000-0000-000000000000\n\tusephysics\t0\n\trotate_x\t1\n\trotate_y\t1\n\trotate_z\t1\n\tphantom\t0\n\tremote_script_access_pin\t0\n\tvolume_detect\t0\n\tblock_grabs\t0\n\tdie_at_edge\t0\n\treturn_at_edge\t0\n\ttemporary\t0\n\tsandbox\t0\n\tsandboxhome\t0\t0\t0\n\tshape 0\n\t{\n\t\tpath 0\n\t\t{\n\t\t\tcurve\t16\n\t\t\tbegin\t0\n\t\t\tend\t1\n\t\t\tscale_x\t1\n\t\t\tscale_y\t1\n\t\t\tshear_x\t0\n\t\t\tshear_y\t0\n\t\t\ttwist\t0\n\t\t\ttwist_begin\t0\n\t\t\tradius_offset\t0\n\t\t\ttaper_x\t0\n\t\t\ttaper_y\t0\n\t\t\trevolutions\t1\n\t\t\tskew\t0\n\t\t}\n\t\tprofile 0\n\t\t{\n\t\t\tcurve\t1\n\t\t\tbegin\t0\n\t\t\tend\t1\n\t\t\thollow\t0\n\t\t}\n\t}\n\tfaces\t6\n\t{\n\t\timageid\tddde1ffc-678b-3cda-1748-513086bdf01b\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t"
+            "\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tf54a0c32-3cd1-d49a-5b4f-7b792bebc204\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t"
+            "\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\tddde1ffc-678b-3cda-1748-513086bdf01b\n\t\tcolors\t0.937255 0.796078 0.494118 1\n\t\tscales\t1\n\t\tscalet\t-1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t0\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\tps_next_crc\t1\n\tgpw_bias\t1\n\tip\t0\n\tcomplete\tTRUE\n\tdelay\t50000\n\tnextstart\t0\n\tbirthtime\t1061087839248891\n\treztime\t1094866329020800\n\tparceltime\t1133568981981983\n\ttax_rate\t1.00084\n\tscratchpad\t0\n\t{\n\t\n\t}\n\tsale_info\t0\n\t{\n\t\tsale_type\tnot\n\t\tsale_price\t10\n\t}\n\tcorrect_family_id\t00000000-0000-0000-0000-000000000000\n\thas_rezzed\t0\n\tpre_link_base_mask\t7fffffff\n\tlinked \tchild\n\tdefault_pay_price\t-2\t1\t5\t10\t20\n}\n{'task_id':ub8d68643-7dd8-57af-0d24-8790032aed0c}\n{\n\tname\tObject|\n\tpermissions 0\n\t{\n\t\tbase_mask\t7fffffff\n\t\towner_mask\t7fffffff\n\t\tgroup_mask\t00000000\n\t\teveryone_mask\t00000000\n\t\tnext_owner_mask\t7fffffff\n\t\tcreat"
+            "or_id\t13fd9595-a47b-4d64-a5fb-6da645f038e0\n\t\towner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tlast_owner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tgroup_id\t00000000-0000-0000-0000-000000000000\n\t}\n\tlocal_id\t217444923\n\ttotal_crc\t235\n\ttype\t2\n\ttask_valid\t2\n\ttravel_access\t13\n\tdisplayopts\t2\n\tdisplaytype\tv\n\tpos\t-0.120029509\t-0.00284469454\t-0.0302077383\n\toldpos\t150.710999\t25.8584995\t8.19172001\n\trotation\t0.145459949970245361328125\t-0.1646589934825897216796875\t0.659558117389678955078125\t-0.718826770782470703125\n\tchildpos\t0\t-0.182999998\t-0.26699999\n\tchildrot\t0.991444766521453857421875\t3.271923924330621957778931e-05\t-0.0002416197530692443251609802\t0.1305266767740249633789062\n\tscale\t0.0382982\t0.205957\t0.368276\n\tsit_offset\t0\t0\t0\n\tcamera_eye_offset\t0\t0\t0\n\tcamera_at_offset\t0\t0\t0\n\tsit_quat\t0\t0\t0\t1\n\tsit_hint\t0\n\tstate\t160\n\tmaterial\t3\n\tsoundid\t00000000-0000-0000-0000-000000000000\n\tsoundgain\t0\n\tsoundra"
+            "dius\t0\n\tsoundflags\t0\n\ttextcolor\t0 0 0 1\n\tselected\t0\n\tselector\t00000000-0000-0000-0000-000000000000\n\tusephysics\t0\n\trotate_x\t1\n\trotate_y\t1\n\trotate_z\t1\n\tphantom\t0\n\tremote_script_access_pin\t0\n\tvolume_detect\t0\n\tblock_grabs\t0\n\tdie_at_edge\t0\n\treturn_at_edge\t0\n\ttemporary\t0\n\tsandbox\t0\n\tsandboxhome\t0\t0\t0\n\tshape 0\n\t{\n\t\tpath 0\n\t\t{\n\t\t\tcurve\t32\n\t\t\tbegin\t0.3\n\t\t\tend\t0.65\n\t\t\tscale_x\t1\n\t\t\tscale_y\t0.05\n\t\t\tshear_x\t0\n\t\t\tshear_y\t0\n\t\t\ttwist\t0\n\t\t\ttwist_begin\t0\n\t\t\tradius_offset\t0\n\t\t\ttaper_x\t0\n\t\t\ttaper_y\t0\n\t\t\trevolutions\t1\n\t\t\tskew\t0\n\t\t}\n\t\tprofile 0\n\t\t{\n\t\t\tcurve\t0\n\t\t\tbegin\t0\n\t\t\tend\t1\n\t\t\thollow\t0\n\t\t}\n\t}\n\tfaces\t3\n\t{\n\t\timageid\te7150bed-3e3e-c698-eb15-d17b178148af\n\t\tcolors\t0.843137 0.156863 0.156863 1\n\t\tscales\t15\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t-1.57084\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0"
+            "\n\t}\n\t{\n\t\timageid\te7150bed-3e3e-c698-eb15-d17b178148af\n\t\tcolors\t0.843137 0.156863 0.156863 1\n\t\tscales\t15\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t-1.57084\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\te7150bed-3e3e-c698-eb15-d17b178148af\n\t\tcolors\t0.843137 0.156863 0.156863 1\n\t\tscales\t15\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t-1.57084\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\tps_next_crc\t1\n\tgpw_bias\t1\n\tip\t0\n\tcomplete\tTRUE\n\tdelay\t50000\n\tnextstart\t0\n\tbirthtime\t1061087534454174\n\treztime\t1094866329021741\n\tparceltime\t1133568981982889\n\ttax_rate\t1.00326\n\tscratchpad\t0\n\t{\n\t\n\t}\n\tsale_info\t0\n\t{\n\t\tsale_type\tnot\n\t\tsale_price\t10\n\t}\n\tcorrect_family_id\t00000000-0000-0000-0000-000000000000\n\thas_rezzed\t0\n\tpre_link_base_mask\t7fffffff\n\tlinked \tchild\n\tdefault_pay_price\t-2\t1\t5\t10\t20\n}\n{'task_id':ue4b19200-9d33-962f-c8c5-6f"
+            "25be3a3fd0}\n{\n\tname\tApotheosis_Immolaine_tail|\n\tpermissions 0\n\t{\n\t\tbase_mask\t7fffffff\n\t\towner_mask\t7fffffff\n\t\tgroup_mask\t00000000\n\t\teveryone_mask\t00000000\n\t\tnext_owner_mask\t7fffffff\n\t\tcreator_id\t13fd9595-a47b-4d64-a5fb-6da645f038e0\n\t\towner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tlast_owner_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\t\tgroup_id\t00000000-0000-0000-0000-000000000000\n\t}\n\tlocal_id\t217444924\n\ttotal_crc\t675\n\ttype\t1\n\ttask_valid\t2\n\ttravel_access\t13\n\tdisplayopts\t2\n\tdisplaytype\tv\n\tpos\t-0.34780401\t-0.00968400016\t-0.260098994\n\toldpos\t0\t0\t0\n\trotation\t0.73164522647857666015625\t-0.67541944980621337890625\t-0.07733880728483200073242188\t0.05022468417882919311523438\n\tvelocity\t0\t0\t0\n\tangvel\t0\t0\t0\n\tscale\t0.0382982\t0.32228\t0.383834\n\tsit_offset\t0\t0\t0\n\tcamera_eye_offset\t0\t0\t0\n\tcamera_at_offset\t0\t0\t0\n\tsit_quat\t0\t0\t0\t1\n\tsit_hint\t0\n\tstate\t160\n\tmaterial\t3\n\tsoundid\t00000"
+            "000-0000-0000-0000-000000000000\n\tsoundgain\t0\n\tsoundradius\t0\n\tsoundflags\t0\n\ttextcolor\t0 0 0 1\n\tselected\t0\n\tselector\t00000000-0000-0000-0000-000000000000\n\tusephysics\t0\n\trotate_x\t1\n\trotate_y\t1\n\trotate_z\t1\n\tphantom\t0\n\tremote_script_access_pin\t0\n\tvolume_detect\t0\n\tblock_grabs\t0\n\tdie_at_edge\t0\n\treturn_at_edge\t0\n\ttemporary\t0\n\tsandbox\t0\n\tsandboxhome\t0\t0\t0\n\tshape 0\n\t{\n\t\tpath 0\n\t\t{\n\t\t\tcurve\t32\n\t\t\tbegin\t0.3\n\t\t\tend\t0.65\n\t\t\tscale_x\t1\n\t\t\tscale_y\t0.05\n\t\t\tshear_x\t0\n\t\t\tshear_y\t0\n\t\t\ttwist\t0\n\t\t\ttwist_begin\t0\n\t\t\tradius_offset\t0\n\t\t\ttaper_x\t0\n\t\t\ttaper_y\t0\n\t\t\trevolutions\t1\n\t\t\tskew\t0\n\t\t}\n\t\tprofile 0\n\t\t{\n\t\t\tcurve\t0\n\t\t\tbegin\t0\n\t\t\tend\t1\n\t\t\thollow\t0\n\t\t}\n\t}\n\tfaces\t3\n\t{\n\t\timageid\te7150bed-3e3e-c698-eb15-d17b178148af\n\t\tcolors\t0.843137 0.156863 0.156863 1\n\t\tscales\t15\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t-1"
+            ".57084\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\te7150bed-3e3e-c698-eb15-d17b178148af\n\t\tcolors\t0.843137 0.156863 0.156863 1\n\t\tscales\t15\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t-1.57084\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\t{\n\t\timageid\te7150bed-3e3e-c698-eb15-d17b178148af\n\t\tcolors\t0.843137 0.156863 0.156863 1\n\t\tscales\t15\n\t\tscalet\t1\n\t\toffsets\t0\n\t\toffsett\t0\n\t\timagerot\t-1.57084\n\t\tbump\t0\n\t\tfullbright\t0\n\t\tmedia_flags\t0\n\t}\n\tps_next_crc\t1\n\tgpw_bias\t1\n\tip\t0\n\tcomplete\tTRUE\n\tdelay\t50000\n\tnextstart\t0\n\tbirthtime\t1061087463950186\n\treztime\t1094866329022555\n\tparceltime\t1133568981984359\n\tdescription\t(No Description)|\n\ttax_rate\t1.01736\n\tnamevalue\tAttachPt U32 RW S 10\n\tnamevalue\tAttachmentOrientation VEC3 RW DS -3.110088, -0.182018, 1.493795\n\tnamevalue\tAttachmentOffset VEC3 RW DS -0.347804, -0.009684, -0.260099\n\tnamevalue\tAttachItemI"
+            "D STRING RW SV 20f36c3a-b44b-9bc7-87f3-018bfdfc8cda\n\tscratchpad\t0\n\t{\n\t\n\t}\n\tsale_info\t0\n\t{\n\t\tsale_type\tnot\n\t\tsale_price\t10\n\t}\n\torig_asset_id\t8747acbc-d391-1e59-69f1-41d06830e6c0\n\torig_item_id\t20f36c3a-b44b-9bc7-87f3-018bfdfc8cda\n\tfrom_task_id\t3c115e51-04f4-523c-9fa6-98aff1034730\n\tcorrect_family_id\t00000000-0000-0000-0000-000000000000\n\thas_rezzed\t0\n\tpre_link_base_mask\t7fffffff\n\tlinked \tlinked\n\tdefault_pay_price\t-2\t1\t5\t10\t20\n}\n");
+    }
+
+
+    template<> template<>
+    void URITestObject::test<18>()
+    {
+        LLURI u("secondlife:///app/login?first_name=Testert4&last_name=Tester&web_login_key=test");
+        // if secondlife is the scheme, LLURI should parse /app/login as path, with no authority
+        ensure_equals("scheme",     u.scheme(),     "secondlife");
+        ensure_equals("authority",  u.authority(),  "");
+        ensure_equals("path",       u.path(),       "/app/login");
+        ensure_equals("pathmap",    u.pathArray()[0].asString(),    "app");
+        ensure_equals("pathmap",    u.pathArray()[1].asString(),    "login");
+        ensure_equals("query",      u.query(),      "first_name=Testert4&last_name=Tester&web_login_key=test");
+        ensure_equals("query map element", u.queryMap()["last_name"].asString(), "Tester");
+
+        u = LLURI("secondlife://Da Boom/128/128/128");
+        // if secondlife is the scheme, LLURI should parse /128/128/128 as path, with Da Boom as authority
+        ensure_equals("scheme",     u.scheme(),     "secondlife");
+        ensure_equals("authority",  u.authority(),  "Da Boom");
+        ensure_equals("path",       u.path(),       "/128/128/128");
+        ensure_equals("pathmap",    u.pathArray()[0].asString(),    "128");
+        ensure_equals("pathmap",    u.pathArray()[1].asString(),    "128");
+        ensure_equals("pathmap",    u.pathArray()[2].asString(),    "128");
+        ensure_equals("query",      u.query(),      "");
+    }
+
+    template<> template<>
+    void URITestObject::test<19>()
+    {
+        set_test_name("Parse about: schemes");
+        LLURI u("about:blank?redirect-http-hack=secondlife%3A%2F%2F%2Fapp%2Flogin%3Ffirst_name%3DCallum%26last_name%3DLinden%26location%3Dspecify%26grid%3Dvaak%26region%3D%2FMorris%2F128%2F128%26web_login_key%3Defaa4795-c2aa-4c58-8966-763c27931e78");
+        ensure_equals("scheme",     u.scheme(),     "about");
+        ensure_equals("authority",  u.authority(),  "");
+        ensure_equals("path",       u.path(),       "blank");
+        ensure_equals("pathmap",    u.pathArray()[0].asString(),    "blank");
+        ensure_equals("query",      u.query(),      "redirect-http-hack=secondlife:///app/login?first_name=Callum&last_name=Linden&location=specify&grid=vaak&region=/Morris/128/128&web_login_key=efaa4795-c2aa-4c58-8966-763c27931e78");
+        ensure_equals("query map element", u.queryMap()["redirect-http-hack"].asString(), "secondlife:///app/login?first_name=Callum&last_name=Linden&location=specify&grid=vaak&region=/Morris/128/128&web_login_key=efaa4795-c2aa-4c58-8966-763c27931e78");
+    }
+
+    template<> template<>
+    void URITestObject::test<20>()
+    {
         set_test_name("escapePathAndData uri test");
 
         // Basics scheme:[//authority]path[?query][#fragment]
diff --git a/indra/llcommon/tests/stringize_test.cpp b/indra/llcommon/tests/stringize_test.cpp
index 2a4ed44a67..a3ce7f8e3d 100644
--- a/indra/llcommon/tests/stringize_test.cpp
+++ b/indra/llcommon/tests/stringize_test.cpp
@@ -3,25 +3,25 @@
  * @author Nat Goodspeed
  * @date   2008-09-12
  * @brief  Test of stringize.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$
  */
@@ -78,7 +78,7 @@ namespace tut
         float       f;
         double      d;
         std::string abc;
-		std::wstring def;
+        std::wstring def;
         LLSD        llsd;
     };
     typedef test_group<stringize_data> stringize_group;
diff --git a/indra/llcommon/tests/threadsafeschedule_test.cpp b/indra/llcommon/tests/threadsafeschedule_test.cpp
index 8851590189..f2f17dd2e6 100644
--- a/indra/llcommon/tests/threadsafeschedule_test.cpp
+++ b/indra/llcommon/tests/threadsafeschedule_test.cpp
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2021-10-04
  * @brief  Test for threadsafeschedule.
- * 
+ *
  * $LicenseInfo:firstyear=2021&license=viewerlgpl$
  * Copyright (c) 2021, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/llcommon/tests/tuple_test.cpp b/indra/llcommon/tests/tuple_test.cpp
index af94e2086c..aff129753f 100644
--- a/indra/llcommon/tests/tuple_test.cpp
+++ b/indra/llcommon/tests/tuple_test.cpp
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2021-10-04
  * @brief  Test for tuple.
- * 
+ *
  * $LicenseInfo:firstyear=2021&license=viewerlgpl$
  * Copyright (c) 2021, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/llcommon/tests/workqueue_test.cpp b/indra/llcommon/tests/workqueue_test.cpp
index df16f4a46e..209b6b868c 100644
--- a/indra/llcommon/tests/workqueue_test.cpp
+++ b/indra/llcommon/tests/workqueue_test.cpp
@@ -3,7 +3,7 @@
  * @author Nat Goodspeed
  * @date   2021-10-07
  * @brief  Test for workqueue.
- * 
+ *
  * $LicenseInfo:firstyear=2021&license=viewerlgpl$
  * Copyright (c) 2021, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/llcommon/tests/wrapllerrs.h b/indra/llcommon/tests/wrapllerrs.h
index d657b329bb..9cd2c69b11 100644
--- a/indra/llcommon/tests/wrapllerrs.h
+++ b/indra/llcommon/tests/wrapllerrs.h
@@ -3,25 +3,25 @@
  * @author Nat Goodspeed
  * @date   2009-03-11
  * @brief  Define a class useful for unit tests that engage llerrs (LL_ERRS) functionality
- * 
+ *
  * $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$
  */
@@ -117,9 +117,9 @@ class CaptureLogRecorder : public LLError::Recorder, public boost::noncopyable
 {
 public:
     CaptureLogRecorder()
-		: LLError::Recorder(),
-		boost::noncopyable(),
-		mMessages()
+        : LLError::Recorder(),
+        boost::noncopyable(),
+        mMessages()
     {
     }
 
@@ -218,12 +218,12 @@ public:
     /// for the sought string.
     std::string messageWith(const std::string& search, bool required=true)
     {
-        return boost::dynamic_pointer_cast<CaptureLogRecorder>(mRecorder)->messageWith(search, required);
+        return std::dynamic_pointer_cast<CaptureLogRecorder>(mRecorder)->messageWith(search, required);
     }
 
     std::ostream& streamto(std::ostream& out) const
     {
-        return boost::dynamic_pointer_cast<CaptureLogRecorder>(mRecorder)->streamto(out);
+        return std::dynamic_pointer_cast<CaptureLogRecorder>(mRecorder)->streamto(out);
     }
 
     friend inline std::ostream& operator<<(std::ostream& out, const CaptureLog& self)