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

3 files changed, 300 insertions, 300 deletions

diff --git a/indra/llprimitive/tests/llmediaentry_test.cpp b/indra/llprimitive/tests/llmediaentry_test.cpp
index c3e17d1267..e8f40d1ffd 100644
--- a/indra/llprimitive/tests/llmediaentry_test.cpp
+++ b/indra/llprimitive/tests/llmediaentry_test.cpp
@@ -1,27 +1,27 @@
-/** 
+/**
  * @file llmediaentry_test.cpp
  * @brief llmediaentry unit tests
  *
- * $LicenseInfo:firstyear=2001&license=viewerlgpl$                               
+ * $LicenseInfo:firstyear=2001&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$                                                               
+ * $/LicenseInfo$
  */
 
 #include "linden_common.h"
@@ -154,7 +154,7 @@ namespace tut
             defaultMediaEntryStr = DEFAULT_MEDIA_ENTRY;
             std::istringstream d(DEFAULT_MEDIA_ENTRY);
             LLSDSerialize::fromXML(defaultMediaEntryLLSD, d);
-        }     
+        }
         std::string emptyMediaEntryStr;
         LLSD emptyMediaEntryLLSD;
         std::string defaultMediaEntryStr;
@@ -164,7 +164,7 @@ namespace tut
     typedef test_group<MediaEntry_test, 55> factory;
     typedef factory::object object;
 }
-        
+
 
 namespace
 {
@@ -237,18 +237,18 @@ namespace tut
         whitelist_test(num, true, whitelist, candidate_url, true);
     }
 
-	template<> template<>
-	void object::test<1>()
-	{
-		set_test_name("Test LLMediaEntry Instantiation");
-		LLMediaEntry entry;
+    template<> template<>
+    void object::test<1>()
+    {
+        set_test_name("Test LLMediaEntry Instantiation");
+        LLMediaEntry entry;
         ensure_llsd_equals(get_test_name() + " failed", defaultMediaEntryLLSD, entry.asLLSD());
-	}
+    }
 
-	template<> template<>
-	void object::test<2>()
-	{
-		set_test_name("Test LLMediaEntry Instantiation from LLSD");
+    template<> template<>
+    void object::test<2>()
+    {
+        set_test_name("Test LLMediaEntry Instantiation from LLSD");
         LLMediaEntry entry;
         LLSD sd;
         entry.fromLLSD(sd);
@@ -275,33 +275,33 @@ namespace tut
         set_test_name("Test LLMediaEntry::asLLSD()");
         LLMediaEntry entry;
         LLSD sd;
-		// Put some cruft in the LLSD
+        // Put some cruft in the LLSD
         sd[LLMediaEntry::CURRENT_URL_KEY] = "http://www.example.com";
-		LLSD whitelist;
-		whitelist.append("*.example.com");
+        LLSD whitelist;
+        whitelist.append("*.example.com");
         sd[LLMediaEntry::WHITELIST_KEY] = whitelist;
         entry.asLLSD(sd);
         ensure_llsd_equals(get_test_name() + " failed", defaultMediaEntryLLSD, sd);
     }
 
-	
+
     template<> template<>
     void object::test<5>()
     {
         set_test_name("Test LLMediaEntry::asLLSD() -> LLMediaEntry::fromLLSD()");
         LLMediaEntry entry1, entry2;
-		// Add a whitelist to entry2
-		std::vector<std::string> whitelist;
-		whitelist.push_back("*.example.com");
+        // Add a whitelist to entry2
+        std::vector<std::string> whitelist;
+        whitelist.push_back("*.example.com");
         entry2.setWhiteList(whitelist);
-		// Render entry1 (which has no whitelist) as an LLSD
+        // Render entry1 (which has no whitelist) as an LLSD
         LLSD sd;
-		entry1.asLLSD(sd);
-		// "read" that LLSD into entry 2
-		entry2.fromLLSD(sd);
+        entry1.asLLSD(sd);
+        // "read" that LLSD into entry 2
+        entry2.fromLLSD(sd);
         ensure_llsd_equals(get_test_name() + " failed", defaultMediaEntryLLSD, entry2.asLLSD());
     }
-	
+
     // limit tests
     const char *URL_OK = "http://www.example.com";
     const char *URL_TOO_BIG = "http://www.example.com.qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq";
@@ -315,7 +315,7 @@ namespace tut
         ensure(get_test_name() + " ok failed", status == LSL_STATUS_OK);
         status = entry.setCurrentURL(URL_TOO_BIG);
         ensure(get_test_name() + " ok failed", status == LSL_STATUS_BOUNDS_ERROR);
-    }    
+    }
 
     template<> template<>
     void object::test<7>()
@@ -332,7 +332,7 @@ namespace tut
     void object::test<8>()
     {
         set_test_name("Test Limits on setting whitelist");
-        
+
         // Test a valid list
         LLMediaEntry entry;
         std::vector<std::string> whitelist;
@@ -346,7 +346,7 @@ namespace tut
     void object::test<9>()
     {
         set_test_name("Test Limits on setting whitelist too big");
-        
+
         // Test an invalid list
         LLMediaEntry entry;
         std::vector<std::string> whitelist, empty;
@@ -361,7 +361,7 @@ namespace tut
     void object::test<10>()
     {
         set_test_name("Test Limits on setting whitelist too many");
-        
+
         // Test an invalid list
         LLMediaEntry entry;
         std::vector<std::string> whitelist, empty;
@@ -377,7 +377,7 @@ namespace tut
     void object::test<11>()
     {
         set_test_name("Test to make sure both setWhiteList() functions behave the same");
-        
+
         // Test a valid list
         std::vector<std::string> whitelist, empty;
         LLSD whitelist_llsd;
@@ -387,10 +387,10 @@ namespace tut
         ensure(get_test_name() + " setWhiteList(s) don't match",
                entry1.setWhiteList(whitelist) == LSL_STATUS_OK &&
                entry2.setWhiteList(whitelist_llsd)== LSL_STATUS_OK );
-        ensure(get_test_name() + " failed", 
+        ensure(get_test_name() + " failed",
                entry1.getWhiteList() == entry2.getWhiteList());
     }
-    
+
     template<> template<>
     void object::test<12>()
     {
@@ -407,7 +407,7 @@ namespace tut
         ensure(get_test_name() + " setWhiteList(s) don't match",
                entry1.setWhiteList(whitelist) == LSL_STATUS_BOUNDS_ERROR &&
                entry2.setWhiteList(whitelist_llsd) == LSL_STATUS_BOUNDS_ERROR);
-        ensure(get_test_name() + " failed", 
+        ensure(get_test_name() + " failed",
                empty == entry1.getWhiteList() &&
                empty == entry2.getWhiteList());
     }
@@ -425,78 +425,78 @@ namespace tut
             whitelist_llsd.append("Q");
         }
         LLMediaEntry entry1, entry2;
-        ensure(get_test_name() + " invalid result", 
+        ensure(get_test_name() + " invalid result",
                entry1.setWhiteList(whitelist) == LSL_STATUS_BOUNDS_ERROR &&
                entry2.setWhiteList(whitelist_llsd) == LSL_STATUS_BOUNDS_ERROR);
-        ensure(get_test_name() + " failed", 
+        ensure(get_test_name() + " failed",
                empty == entry1.getWhiteList() &&
                empty == entry2.getWhiteList());
     }
-    
+
     template<> template<>
-    void object::test<14>() 
-	{
-		// Whitelist check tests
-		int n=0;
-		
-		// Check the "empty whitelist" case
-		whitelist_test(++n, "", "http://www.example.com", true); 
-
-		// Check the "missing scheme" case
-		whitelist_test(++n, "www.example.com", "http://www.example.com", true);
-
-		// Check the "exactly the same" case
-		whitelist_test(++n, "http://example.com", "http://example.com", true);
-
-		// Check the enable flag
-		whitelist_test(++n, false, "www.example.com", "http://www.secondlife.com", true);
-		whitelist_test(++n, true, "www.example.com", "http://www.secondlife.com", false);
-
-		// Check permutations of trailing slash:
-		whitelist_test(++n, "http://www.example.com", "http://www.example.com/", true);
-		whitelist_test(++n, "http://www.example.com/", "http://www.example.com/", true);
-		whitelist_test(++n, "http://www.example.com/", "http://www.example.com", false);
-		whitelist_test(++n, "http://www.example.com", "http://www.example.com/foobar", true);
-		whitelist_test(++n, "http://www.example.com/", "http://www.example.com/foobar", false);
-
-    
-		// More cases...
-		whitelist_test(++n, "http://example.com", "http://example.com/wiki", true);
-		whitelist_test(++n, "www.example.com", "http://www.example.com/help", true);
-		whitelist_test(++n, "http://www.example.com", "http://wwwexample.com", false);
-		whitelist_test(++n, "http://www.example.com", "http://www.example.com/wiki", true);
-		whitelist_test(++n, "example.com", "http://wwwexample.com", false);
-		whitelist_test(++n, "http://www.example.com/", "http://www.amazon.com/wiki", false);
-		whitelist_test(++n, "www.example.com", "http://www.amazon.com", false);
-
-		// regexp cases
-		whitelist_test(++n, "*.example.com", "http://www.example.com", true);
-		whitelist_test(++n, "*.example.com", "http://www.amazon.com", false);
-		whitelist_test(++n, "*.example.com", "http://www.example.com/foo/bar", true);
-		whitelist_test(++n, "*.example.com", "http:/example.com/foo/bar", false);
-		whitelist_test(++n, "*example.com", "http://example.com/foo/bar", true);
-		whitelist_test(++n, "*example.com", "http://my.virus.com/foo/bar?example.com", false);
-		whitelist_test(++n, "example.com", "http://my.virus.com/foo/bar?example.com", false);
-		whitelist_test(++n, "*example.com", "http://my.virus.com/foo/bar?*example.com", false);
-		whitelist_test(++n, "http://*example.com", "http://www.example.com", true);
-		whitelist_test(++n, "http://*.example.com", "http://www.example.com", true);
-		whitelist_test(++n, "http://*.e$?^.com", "http://www.e$?^.com", true);
-		whitelist_test(++n, "*.example.com/foo/bar", "http://www.example.com/", false);
-		whitelist_test(++n, "*.example.com/foo/bar", "http://example.com/foo/bar", false);
-		whitelist_test(++n, "http://*.example.com/foo/bar", "http://www.example.com", false);
-		whitelist_test(++n, "http://*.example.com", "https://www.example.com", false);
-		whitelist_test(++n, "http*://*.example.com", "rtsp://www.example.com", false);
-		whitelist_test(++n, "http*://*.example.com", "https://www.example.com", true);
-		whitelist_test(++n, "example.com", "http://www.example.com", false);
-		whitelist_test(++n, "www.example.com", "http://www.example.com:80", false);
-		whitelist_test(++n, "www.example.com", "http://www.example.com", true);
-		whitelist_test(++n, "www.example.com/", "http://www.example.com", false);
-		whitelist_test(++n, "www.example.com/foo/bar/*", "http://www.example.com/foo/bar/baz", true);
+    void object::test<14>()
+    {
+        // Whitelist check tests
+        int n=0;
+
+        // Check the "empty whitelist" case
+        whitelist_test(++n, "", "http://www.example.com", true);
+
+        // Check the "missing scheme" case
+        whitelist_test(++n, "www.example.com", "http://www.example.com", true);
+
+        // Check the "exactly the same" case
+        whitelist_test(++n, "http://example.com", "http://example.com", true);
+
+        // Check the enable flag
+        whitelist_test(++n, false, "www.example.com", "http://www.secondlife.com", true);
+        whitelist_test(++n, true, "www.example.com", "http://www.secondlife.com", false);
+
+        // Check permutations of trailing slash:
+        whitelist_test(++n, "http://www.example.com", "http://www.example.com/", true);
+        whitelist_test(++n, "http://www.example.com/", "http://www.example.com/", true);
+        whitelist_test(++n, "http://www.example.com/", "http://www.example.com", false);
+        whitelist_test(++n, "http://www.example.com", "http://www.example.com/foobar", true);
+        whitelist_test(++n, "http://www.example.com/", "http://www.example.com/foobar", false);
+
+
+        // More cases...
+        whitelist_test(++n, "http://example.com", "http://example.com/wiki", true);
+        whitelist_test(++n, "www.example.com", "http://www.example.com/help", true);
+        whitelist_test(++n, "http://www.example.com", "http://wwwexample.com", false);
+        whitelist_test(++n, "http://www.example.com", "http://www.example.com/wiki", true);
+        whitelist_test(++n, "example.com", "http://wwwexample.com", false);
+        whitelist_test(++n, "http://www.example.com/", "http://www.amazon.com/wiki", false);
+        whitelist_test(++n, "www.example.com", "http://www.amazon.com", false);
+
+        // regexp cases
+        whitelist_test(++n, "*.example.com", "http://www.example.com", true);
+        whitelist_test(++n, "*.example.com", "http://www.amazon.com", false);
+        whitelist_test(++n, "*.example.com", "http://www.example.com/foo/bar", true);
+        whitelist_test(++n, "*.example.com", "http:/example.com/foo/bar", false);
+        whitelist_test(++n, "*example.com", "http://example.com/foo/bar", true);
+        whitelist_test(++n, "*example.com", "http://my.virus.com/foo/bar?example.com", false);
+        whitelist_test(++n, "example.com", "http://my.virus.com/foo/bar?example.com", false);
+        whitelist_test(++n, "*example.com", "http://my.virus.com/foo/bar?*example.com", false);
+        whitelist_test(++n, "http://*example.com", "http://www.example.com", true);
+        whitelist_test(++n, "http://*.example.com", "http://www.example.com", true);
+        whitelist_test(++n, "http://*.e$?^.com", "http://www.e$?^.com", true);
+        whitelist_test(++n, "*.example.com/foo/bar", "http://www.example.com/", false);
+        whitelist_test(++n, "*.example.com/foo/bar", "http://example.com/foo/bar", false);
+        whitelist_test(++n, "http://*.example.com/foo/bar", "http://www.example.com", false);
+        whitelist_test(++n, "http://*.example.com", "https://www.example.com", false);
+        whitelist_test(++n, "http*://*.example.com", "rtsp://www.example.com", false);
+        whitelist_test(++n, "http*://*.example.com", "https://www.example.com", true);
+        whitelist_test(++n, "example.com", "http://www.example.com", false);
+        whitelist_test(++n, "www.example.com", "http://www.example.com:80", false);
+        whitelist_test(++n, "www.example.com", "http://www.example.com", true);
+        whitelist_test(++n, "www.example.com/", "http://www.example.com", false);
+        whitelist_test(++n, "www.example.com/foo/bar/*", "http://www.example.com/foo/bar/baz", true);
 
         // Path only
-		whitelist_test(++n, "/foo/*/baz", "http://www.example.com/foo/bar/baz", true);
-		whitelist_test(++n, "/foo/*/baz", "http://www.example.com/foo/bar/", false);
-	}
-	
+        whitelist_test(++n, "/foo/*/baz", "http://www.example.com/foo/bar/baz", true);
+        whitelist_test(++n, "/foo/*/baz", "http://www.example.com/foo/bar/", false);
+    }
+
 }
 
diff --git a/indra/llprimitive/tests/llmessagesystem_stub.cpp b/indra/llprimitive/tests/llmessagesystem_stub.cpp
index 9006833054..531a8b069d 100644
--- a/indra/llprimitive/tests/llmessagesystem_stub.cpp
+++ b/indra/llprimitive/tests/llmessagesystem_stub.cpp
@@ -1,26 +1,26 @@
-/** 
+/**
  * @file llmessagesystem_stub.cpp
  *
- * $LicenseInfo:firstyear=2008&license=viewerlgpl$                               
+ * $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$                                                               
+ * $/LicenseInfo$
  */
 
 #include "linden_common.h"
@@ -29,12 +29,12 @@ const char * const _PREHASH_TextureEntry = "TextureEntry";
 
 S32 LLMessageSystem::getSizeFast(char const*, char const*) const
 {
-	return 0;
+    return 0;
 }
 
 S32 LLMessageSystem::getSizeFast(char const*, int, char const*) const
 {
-	return 0;
+    return 0;
 }
 
 void LLMessageSystem::getBinaryDataFast(char const*, char const*, void*, int, int, int)
diff --git a/indra/llprimitive/tests/llprimitive_test.cpp b/indra/llprimitive/tests/llprimitive_test.cpp
index 0ff0795fdc..1b47182c28 100644
--- a/indra/llprimitive/tests/llprimitive_test.cpp
+++ b/indra/llprimitive/tests/llprimitive_test.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llprimitive_test.cpp
  * @brief llprimitive tests
  *
  * $LicenseInfo:firstyear=2001&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -35,40 +35,40 @@
 class DummyVolumeMgr : public LLVolumeMgr
 {
 public:
-	DummyVolumeMgr() : LLVolumeMgr(), mVolumeTest(NULL), mCurrDetailTest(0) {}
-	~DummyVolumeMgr() 
-	{
-	}
-	
-	
-	virtual LLVolume *refVolume(const LLVolumeParams &volume_params, const S32 detail) 
-	{
-		if (mVolumeTest.isNull() || volume_params != mCurrParamsTest || detail != mCurrDetailTest)
-		{
-			F32 volume_detail = LLVolumeLODGroup::getVolumeScaleFromDetail(detail);
-			mVolumeTest = new LLVolume(volume_params, volume_detail, FALSE, FALSE);
-			mCurrParamsTest = volume_params;
-			mCurrDetailTest = detail;
-			return mVolumeTest;
-		} 
-		else 
-		{
-			return mVolumeTest;
-		}
-	}
-	
-	virtual void unrefVolume(LLVolume *volumep) 
-	{
-		if (mVolumeTest == volumep)
-		{
-			mVolumeTest = NULL;
-		}
-	}
-	
+    DummyVolumeMgr() : LLVolumeMgr(), mVolumeTest(NULL), mCurrDetailTest(0) {}
+    ~DummyVolumeMgr()
+    {
+    }
+
+
+    virtual LLVolume *refVolume(const LLVolumeParams &volume_params, const S32 detail)
+    {
+        if (mVolumeTest.isNull() || volume_params != mCurrParamsTest || detail != mCurrDetailTest)
+        {
+            F32 volume_detail = LLVolumeLODGroup::getVolumeScaleFromDetail(detail);
+            mVolumeTest = new LLVolume(volume_params, volume_detail, FALSE, FALSE);
+            mCurrParamsTest = volume_params;
+            mCurrDetailTest = detail;
+            return mVolumeTest;
+        }
+        else
+        {
+            return mVolumeTest;
+        }
+    }
+
+    virtual void unrefVolume(LLVolume *volumep)
+    {
+        if (mVolumeTest == volumep)
+        {
+            mVolumeTest = NULL;
+        }
+    }
+
 private:
-	LLPointer<LLVolume> mVolumeTest;
-	LLVolumeParams mCurrParamsTest;
-	S32 mCurrDetailTest;
+    LLPointer<LLVolume> mVolumeTest;
+    LLVolumeParams mCurrParamsTest;
+    S32 mCurrDetailTest;
 };
 
 LLMaterialID::LLMaterialID() {}
@@ -114,158 +114,158 @@ S32 LLPrimTextureList::size() const { return mEntryList.size(); }
 class PRIMITIVE_TEST_SETUP
 {
 public:
-	PRIMITIVE_TEST_SETUP()
-	{
-		volume_manager_test = new DummyVolumeMgr();
-		LLPrimitive::setVolumeManager(volume_manager_test);
-	}
-	
-	~PRIMITIVE_TEST_SETUP()
-	{
-		LLPrimitive::cleanupVolumeManager();
-	}
-	DummyVolumeMgr * volume_manager_test;
-}; 
+    PRIMITIVE_TEST_SETUP()
+    {
+        volume_manager_test = new DummyVolumeMgr();
+        LLPrimitive::setVolumeManager(volume_manager_test);
+    }
+
+    ~PRIMITIVE_TEST_SETUP()
+    {
+        LLPrimitive::cleanupVolumeManager();
+    }
+    DummyVolumeMgr * volume_manager_test;
+};
 
 namespace tut
 {
-	struct llprimitive
-	{
-		PRIMITIVE_TEST_SETUP setup_class;
-	};
-    
-	typedef test_group<llprimitive> llprimitive_t;
-	typedef llprimitive_t::object llprimitive_object_t;
-	tut::llprimitive_t tut_llprimitive("LLPrimitive");
-
-	template<> template<>
-	void llprimitive_object_t::test<1>()
-	{
-		set_test_name("Test LLPrimitive Instantiation");
-		LLPrimitive test;
-	}
-	
-	template<> template<>
-	void llprimitive_object_t::test<2>()
-	{
-		set_test_name("Test LLPrimitive PCode setter and getter.");
-		LLPrimitive test;
-		ensure_equals(test.getPCode(), 0);
-		LLPCode code = 1;
-		test.setPCode(code);
-		ensure_equals(test.getPCode(), code);
-	}
-	
-	template<> template<>
-	void llprimitive_object_t::test<3>()
-	{
-		set_test_name("Test llprimitive constructor and initer.");
-		LLPCode code = 1;
-		LLPrimitive primitive;
-		primitive.init_primitive(code);
-		ensure_equals(primitive.getPCode(), code);
-	}
-	
-	template<> template<>
-	void llprimitive_object_t::test<4>()
-	{
-		set_test_name("Test Static llprimitive constructor and initer.");
-		LLPCode code = 1;
-		LLPrimitive * primitive = LLPrimitive::createPrimitive(code);
-		ensure(primitive != NULL);
-		ensure_equals(primitive->getPCode(), code);
-	}
-
-	template<> template<>
-	void llprimitive_object_t::test<5>()
-	{
-		set_test_name("Test setVolume creation of new unique volume.");
-		LLPrimitive primitive;
-		LLVolumeParams params;
-		
-		// Make sure volume starts off null
-		ensure(primitive.getVolume() == NULL);
-		
-		// Make sure we have no texture entries before setting the volume
-		ensure_equals(primitive.getNumTEs(), 0);
-		
-		// Test that GEOMETRY has not been flagged as changed.
-		ensure(!primitive.isChanged(LLXform::GEOMETRY));
-		
-		// Make sure setVolume returns true
-		ensure(primitive.setVolume(params, 0, true) == TRUE);
-		LLVolume* new_volume = primitive.getVolume();
-		
-		// make sure new volume was actually created
-		ensure(new_volume != NULL);
-		
-		// Make sure that now that we've set the volume we have texture entries
-		ensure_not_equals(primitive.getNumTEs(), 0);
-		
-		// Make sure that the number of texture entries equals the number of faces in the volume (should be 6)
-		ensure_equals(new_volume->getNumFaces(), 6);
-		ensure_equals(primitive.getNumTEs(), new_volume->getNumFaces());
-		
-		// Test that GEOMETRY has been flagged as changed.
-		ensure(primitive.isChanged(LLXform::GEOMETRY));
-		
-		// Run it twice to make sure it doesn't create a different one if params are the same
-		ensure(primitive.setVolume(params, 0, true) == FALSE);
-		ensure(new_volume == primitive.getVolume());
-		
-		// Change the param definition and try setting it again.
-		params.setRevolutions(4);
-		ensure(primitive.setVolume(params, 0, true) == TRUE);
-		
-		// Ensure that we now have a different volume
-		ensure(new_volume != primitive.getVolume());
-	}
-	
-	template<> template<>
-	void llprimitive_object_t::test<6>()
-	{
-		set_test_name("Test setVolume creation of new NOT-unique volume.");
-		LLPrimitive primitive;
-		LLVolumeParams params;
-		
-		// Make sure volume starts off null
-		ensure(primitive.getVolume() == NULL);
-		
-		// Make sure we have no texture entries before setting the volume
-		ensure_equals(primitive.getNumTEs(), 0);
-		
-		// Test that GEOMETRY has not been flagged as changed.
-		ensure(!primitive.isChanged(LLXform::GEOMETRY));
-		
-		// Make sure setVolume returns true
-		ensure(primitive.setVolume(params, 0, false) == TRUE);
-		
-		LLVolume* new_volume = primitive.getVolume();
-		
-		// make sure new volume was actually created
-		ensure(new_volume != NULL);
-		
-		// Make sure that now that we've set the volume we have texture entries
-		ensure_not_equals(primitive.getNumTEs(), 0);
-		
-		// Make sure that the number of texture entries equals the number of faces in the volume (should be 6)
-		ensure_equals(new_volume->getNumFaces(), 6);
-		ensure_equals(primitive.getNumTEs(), new_volume->getNumFaces());
-		
-		// Test that GEOMETRY has been flagged as changed.
-		ensure(primitive.isChanged(LLXform::GEOMETRY));
-		
-		// Run it twice to make sure it doesn't create a different one if params are the same
-		ensure(primitive.setVolume(params, 0, false) == FALSE);
-		ensure(new_volume == primitive.getVolume());
-		
-		// Change the param definition and try setting it again.
-		params.setRevolutions(4);
-		ensure(primitive.setVolume(params, 0, false) == TRUE); 
-		
-		// Ensure that we now have a different volume
-		ensure(new_volume != primitive.getVolume());
-	}
+    struct llprimitive
+    {
+        PRIMITIVE_TEST_SETUP setup_class;
+    };
+
+    typedef test_group<llprimitive> llprimitive_t;
+    typedef llprimitive_t::object llprimitive_object_t;
+    tut::llprimitive_t tut_llprimitive("LLPrimitive");
+
+    template<> template<>
+    void llprimitive_object_t::test<1>()
+    {
+        set_test_name("Test LLPrimitive Instantiation");
+        LLPrimitive test;
+    }
+
+    template<> template<>
+    void llprimitive_object_t::test<2>()
+    {
+        set_test_name("Test LLPrimitive PCode setter and getter.");
+        LLPrimitive test;
+        ensure_equals(test.getPCode(), 0);
+        LLPCode code = 1;
+        test.setPCode(code);
+        ensure_equals(test.getPCode(), code);
+    }
+
+    template<> template<>
+    void llprimitive_object_t::test<3>()
+    {
+        set_test_name("Test llprimitive constructor and initer.");
+        LLPCode code = 1;
+        LLPrimitive primitive;
+        primitive.init_primitive(code);
+        ensure_equals(primitive.getPCode(), code);
+    }
+
+    template<> template<>
+    void llprimitive_object_t::test<4>()
+    {
+        set_test_name("Test Static llprimitive constructor and initer.");
+        LLPCode code = 1;
+        LLPrimitive * primitive = LLPrimitive::createPrimitive(code);
+        ensure(primitive != NULL);
+        ensure_equals(primitive->getPCode(), code);
+    }
+
+    template<> template<>
+    void llprimitive_object_t::test<5>()
+    {
+        set_test_name("Test setVolume creation of new unique volume.");
+        LLPrimitive primitive;
+        LLVolumeParams params;
+
+        // Make sure volume starts off null
+        ensure(primitive.getVolume() == NULL);
+
+        // Make sure we have no texture entries before setting the volume
+        ensure_equals(primitive.getNumTEs(), 0);
+
+        // Test that GEOMETRY has not been flagged as changed.
+        ensure(!primitive.isChanged(LLXform::GEOMETRY));
+
+        // Make sure setVolume returns true
+        ensure(primitive.setVolume(params, 0, true) == TRUE);
+        LLVolume* new_volume = primitive.getVolume();
+
+        // make sure new volume was actually created
+        ensure(new_volume != NULL);
+
+        // Make sure that now that we've set the volume we have texture entries
+        ensure_not_equals(primitive.getNumTEs(), 0);
+
+        // Make sure that the number of texture entries equals the number of faces in the volume (should be 6)
+        ensure_equals(new_volume->getNumFaces(), 6);
+        ensure_equals(primitive.getNumTEs(), new_volume->getNumFaces());
+
+        // Test that GEOMETRY has been flagged as changed.
+        ensure(primitive.isChanged(LLXform::GEOMETRY));
+
+        // Run it twice to make sure it doesn't create a different one if params are the same
+        ensure(primitive.setVolume(params, 0, true) == FALSE);
+        ensure(new_volume == primitive.getVolume());
+
+        // Change the param definition and try setting it again.
+        params.setRevolutions(4);
+        ensure(primitive.setVolume(params, 0, true) == TRUE);
+
+        // Ensure that we now have a different volume
+        ensure(new_volume != primitive.getVolume());
+    }
+
+    template<> template<>
+    void llprimitive_object_t::test<6>()
+    {
+        set_test_name("Test setVolume creation of new NOT-unique volume.");
+        LLPrimitive primitive;
+        LLVolumeParams params;
+
+        // Make sure volume starts off null
+        ensure(primitive.getVolume() == NULL);
+
+        // Make sure we have no texture entries before setting the volume
+        ensure_equals(primitive.getNumTEs(), 0);
+
+        // Test that GEOMETRY has not been flagged as changed.
+        ensure(!primitive.isChanged(LLXform::GEOMETRY));
+
+        // Make sure setVolume returns true
+        ensure(primitive.setVolume(params, 0, false) == TRUE);
+
+        LLVolume* new_volume = primitive.getVolume();
+
+        // make sure new volume was actually created
+        ensure(new_volume != NULL);
+
+        // Make sure that now that we've set the volume we have texture entries
+        ensure_not_equals(primitive.getNumTEs(), 0);
+
+        // Make sure that the number of texture entries equals the number of faces in the volume (should be 6)
+        ensure_equals(new_volume->getNumFaces(), 6);
+        ensure_equals(primitive.getNumTEs(), new_volume->getNumFaces());
+
+        // Test that GEOMETRY has been flagged as changed.
+        ensure(primitive.isChanged(LLXform::GEOMETRY));
+
+        // Run it twice to make sure it doesn't create a different one if params are the same
+        ensure(primitive.setVolume(params, 0, false) == FALSE);
+        ensure(new_volume == primitive.getVolume());
+
+        // Change the param definition and try setting it again.
+        params.setRevolutions(4);
+        ensure(primitive.setVolume(params, 0, false) == TRUE);
+
+        // Ensure that we now have a different volume
+        ensure(new_volume != primitive.getVolume());
+    }
 }
 
 #include "llmessagesystem_stub.cpp"