Merge commit 'e7eced3' into release/luau-scripting: whitespace fix.

37 files changed, 3891 insertions, 3891 deletions

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 b4cdbdc6bf..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 std::dynamic_pointer_cast<TestRecorder>(mRecorder)->countMessages();
-		}
-
-		void clearMessages()
-		{
-			std::dynamic_pointer_cast<TestRecorder>(mRecorder)->clearMessages();
-		}
-
-		void setWantsTime(bool t)
+    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 std::dynamic_pointer_cast<TestRecorder>(mRecorder)->countMessages();
+        }
+
+        void clearMessages()
+        {
+            std::dynamic_pointer_cast<TestRecorder>(mRecorder)->clearMessages();
+        }
+
+        void setWantsTime(bool t)
             {
                 std::dynamic_pointer_cast<TestRecorder>(mRecorder)->showTime(t);
             }
 
-		void setWantsMultiline(bool t)
+        void setWantsMultiline(bool t)
             {
                 std::dynamic_pointer_cast<TestRecorder>(mRecorder)->showMultiline(t);
             }
 
-		std::string message(int n)
-		{
-			return std::dynamic_pointer_cast<TestRecorder>(mRecorder)->message(n);
-		}
+        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);
-		}
+        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 = "")
-	{
-		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);
-		}
-	}
+    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", std::dynamic_pointer_cast<TestRecorder>(altRecorder)->countMessages(), 1);
-		ensure_contains("alt recorder message 0", std::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());
-		std::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", 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);
+        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/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 95af9c2a50..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$
  */
@@ -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/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 628f046f55..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$
@@ -1075,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/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 8af057328b..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$
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 b9c7a70c07..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$
  */
@@ -1045,7 +1045,7 @@ bool LLTreeWalkIter_test(const std::string& itername, const std::string& nodenam
     {
         std::cout << itername << '<' << nodename << ">(NULL)\n";
         return false;
-    }             
+    }
     return true;
 }
 
@@ -1107,7 +1107,7 @@ namespace tut
         TreeNodePtr tnroot(example_tree<TreeNode>());
         TreeNodePtr tnB2b(get_B2b<TreeNode, TreeNode::child_iterator>
                           (tnroot, boost::bind(&TreeNode::child_begin, _1)));
-    
+
         std::string desc1("for (TreeNodePr : getRootRange<LLTreeIter::UP>(tnB2b))");
 //      std::cout << desc1 << "\n";
         // Although we've commented out the output statement, ensure that the
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 6978c296b3..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()
     {
     }