#824 Process source files in bulk: replace tabs with spaces, convert CRLF to LF, and trim trailing whitespaces as needed

1 files changed, 89 insertions, 89 deletions

diff --git a/indra/llimage/tests/llimageworker_test.cpp b/indra/llimage/tests/llimageworker_test.cpp
index ffcd7d257f..49fc1afd82 100644
--- a/indra/llimage/tests/llimageworker_test.cpp
+++ b/indra/llimage/tests/llimageworker_test.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llimageworker_test.cpp
  * @author Merov Linden
  * @date 2009-04-28
@@ -6,28 +6,28 @@
  * $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$
  */
 
 // Precompiled header: almost always required for newview cpp files
 #include "linden_common.h"
-// Class to test 
+// Class to test
 #include "../llimageworker.h"
 // For timer class
 #include "../llcommon/lltimer.h"
@@ -38,13 +38,13 @@
 
 // -------------------------------------------------------------------------------------------
 // Stubbing: Declarations required to link and run the class being tested
-// Notes: 
+// Notes:
 // * Add here stubbed implementation of the few classes and methods used in the class to be tested
 // * Add as little as possible (let the link errors guide you)
 // * Do not make any assumption as to how those classes or methods work (i.e. don't copy/paste code)
 // * A simulator for a class can be implemented here. Please comment and document thoroughly.
 
-LLImageBase::LLImageBase() 
+LLImageBase::LLImageBase()
 : mData(NULL),
 mDataSize(0),
 mWidth(0),
@@ -78,91 +78,91 @@ U8* LLImageBase::getData() { return NULL; }
 
 namespace tut
 {
-	// Test wrapper declarations
+    // Test wrapper declarations
 
-	// Note: We derive the responder class for 2 reasons:
-	// 1. It's a pure virtual class and we can't compile without completed() being implemented
-	// 2. We actually need a responder to test that the thread work test completed
-	// We implement this making no assumption on what's done in the thread or worker
-	// though, just that the responder's completed() method is called in the end.
-	// Note on responders: responders are ref counted and *will* be deleted by the request they are 
-	// attached to when the queued request is deleted. The recommended way of using them is to 
-	// create them when creating a request, put a callback method in completed() and not rely on 
-	// anything to survive in the responder object once completed() has been called. Let the request
-	// do the deletion and clean up itself.
-	class responder_test : public LLImageDecodeThread::Responder
-	{
-		public:
-			responder_test(bool* res)
-			{ 
-				done = res;
-				*done = false;
-			}
-			virtual void completed(bool success, LLImageRaw* raw, LLImageRaw* aux, U32)
-			{
-				*done = true;
-			}
-		private:
-			// This is what can be thought of as the minimal implementation of a responder
-			// Done will be switched to true when completed() is called and can be tested
-			// outside the responder. A better way of doing this is to store a callback here.
-			bool* done;
-	};
+    // Note: We derive the responder class for 2 reasons:
+    // 1. It's a pure virtual class and we can't compile without completed() being implemented
+    // 2. We actually need a responder to test that the thread work test completed
+    // We implement this making no assumption on what's done in the thread or worker
+    // though, just that the responder's completed() method is called in the end.
+    // Note on responders: responders are ref counted and *will* be deleted by the request they are
+    // attached to when the queued request is deleted. The recommended way of using them is to
+    // create them when creating a request, put a callback method in completed() and not rely on
+    // anything to survive in the responder object once completed() has been called. Let the request
+    // do the deletion and clean up itself.
+    class responder_test : public LLImageDecodeThread::Responder
+    {
+        public:
+            responder_test(bool* res)
+            {
+                done = res;
+                *done = false;
+            }
+            virtual void completed(bool success, LLImageRaw* raw, LLImageRaw* aux, U32)
+            {
+                *done = true;
+            }
+        private:
+            // This is what can be thought of as the minimal implementation of a responder
+            // Done will be switched to true when completed() is called and can be tested
+            // outside the responder. A better way of doing this is to store a callback here.
+            bool* done;
+    };
 
-	// Test wrapper declaration : decode thread
-	struct imagedecodethread_test
-	{
-		// Instance to be tested
-		LLImageDecodeThread* mThread;
-		// Constructor and destructor of the test wrapper
-		imagedecodethread_test()
-		{
-			mThread = NULL;
-		}
-		~imagedecodethread_test()
-		{
-			delete mThread;
-		}
-	};
+    // Test wrapper declaration : decode thread
+    struct imagedecodethread_test
+    {
+        // Instance to be tested
+        LLImageDecodeThread* mThread;
+        // Constructor and destructor of the test wrapper
+        imagedecodethread_test()
+        {
+            mThread = NULL;
+        }
+        ~imagedecodethread_test()
+        {
+            delete mThread;
+        }
+    };
 
-	// Tut templating thingamagic: test group, object and test instance
-	typedef test_group<imagedecodethread_test> imagedecodethread_t;
-	typedef imagedecodethread_t::object imagedecodethread_object_t;
-	tut::imagedecodethread_t tut_imagedecodethread("LLImageDecodeThread");
+    // Tut templating thingamagic: test group, object and test instance
+    typedef test_group<imagedecodethread_test> imagedecodethread_t;
+    typedef imagedecodethread_t::object imagedecodethread_object_t;
+    tut::imagedecodethread_t tut_imagedecodethread("LLImageDecodeThread");
 
-	// ---------------------------------------------------------------------------------------
-	// Test functions
-	// Notes:
-	// * Test as many as you possibly can without requiring a full blown simulation of everything
-	// * The tests are executed in sequence so the test instance state may change between calls
-	// * Remember that you cannot test private methods with tut
-	// ---------------------------------------------------------------------------------------
+    // ---------------------------------------------------------------------------------------
+    // Test functions
+    // Notes:
+    // * Test as many as you possibly can without requiring a full blown simulation of everything
+    // * The tests are executed in sequence so the test instance state may change between calls
+    // * Remember that you cannot test private methods with tut
+    // ---------------------------------------------------------------------------------------
 
-	// ---------------------------------------------------------------------------------------
-	// Test the LLImageDecodeThread interface
-	// ---------------------------------------------------------------------------------------
+    // ---------------------------------------------------------------------------------------
+    // Test the LLImageDecodeThread interface
+    // ---------------------------------------------------------------------------------------
 
-	template<> template<>
-	void imagedecodethread_object_t::test<1>()
-	{
-		// Test a *threaded* instance of the class
-		mThread = new LLImageDecodeThread(true);
-		ensure("LLImageDecodeThread: threaded constructor failed", mThread != NULL);
-		// Insert something in the queue
-		bool done = false;
-		LLImageDecodeThread::handle_t decodeHandle = mThread->decodeImage(NULL, 0, FALSE, new responder_test(&done));
-		// Verifies we get back a valid handle
-		ensure("LLImageDecodeThread:  threaded decodeImage(), returned handle is null", decodeHandle != 0);
-		// Wait till the thread has time to handle the work order (though it doesn't do much per work order...)
-		const U32 INCREMENT_TIME = 500;				// 500 milliseconds
-		const U32 MAX_TIME = 20 * INCREMENT_TIME;	// Do the loop 20 times max, i.e. wait 10 seconds but no more
-		U32 total_time = 0;
-		while ((done == false) && (total_time < MAX_TIME))
-		{
-			ms_sleep(INCREMENT_TIME);
-			total_time += INCREMENT_TIME;
-		}
-		// Verifies that the responder has now been called
-		ensure("LLImageDecodeThread: threaded work unit not processed", done == true);
-	}
+    template<> template<>
+    void imagedecodethread_object_t::test<1>()
+    {
+        // Test a *threaded* instance of the class
+        mThread = new LLImageDecodeThread(true);
+        ensure("LLImageDecodeThread: threaded constructor failed", mThread != NULL);
+        // Insert something in the queue
+        bool done = false;
+        LLImageDecodeThread::handle_t decodeHandle = mThread->decodeImage(NULL, 0, FALSE, new responder_test(&done));
+        // Verifies we get back a valid handle
+        ensure("LLImageDecodeThread:  threaded decodeImage(), returned handle is null", decodeHandle != 0);
+        // Wait till the thread has time to handle the work order (though it doesn't do much per work order...)
+        const U32 INCREMENT_TIME = 500;             // 500 milliseconds
+        const U32 MAX_TIME = 20 * INCREMENT_TIME;   // Do the loop 20 times max, i.e. wait 10 seconds but no more
+        U32 total_time = 0;
+        while ((done == false) && (total_time < MAX_TIME))
+        {
+            ms_sleep(INCREMENT_TIME);
+            total_time += INCREMENT_TIME;
+        }
+        // Verifies that the responder has now been called
+        ensure("LLImageDecodeThread: threaded work unit not processed", done == true);
+    }
 }