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

1 files changed, 94 insertions, 94 deletions

diff --git a/indra/test/lltut.h b/indra/test/lltut.h
index 9835565bb6..e56b4e8d1c 100644
--- a/indra/test/lltut.h
+++ b/indra/test/lltut.h
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file lltut.h
  * @author Phoenix
  * @date 2005-09-26
@@ -7,21 +7,21 @@
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -38,35 +38,35 @@ class LLURI;
 
 namespace tut
 {
-	void ensure_equals(const std::string& msg,
-		const LLDate& actual, const LLDate& expected);
+    void ensure_equals(const std::string& msg,
+        const LLDate& actual, const LLDate& expected);
 
-	void ensure_equals(const std::string& msg,
-		const LLURI& actual, const LLURI& expected);
+    void ensure_equals(const std::string& msg,
+        const LLURI& actual, const LLURI& expected);
 
-	// std::vector<U8> is the current definition of LLSD::Binary. Because
-	// we're only forward-declaring LLSD in this header file, we can't
-	// directly reference that nested type. If the build complains that
-	// there's no definition for this declaration, it could be that
-	// LLSD::Binary has changed, and that this declaration must be adjusted to
-	// match.
-	void ensure_equals(const std::string& msg,
-		const std::vector<U8>& actual, const std::vector<U8>& expected);
+    // std::vector<U8> is the current definition of LLSD::Binary. Because
+    // we're only forward-declaring LLSD in this header file, we can't
+    // directly reference that nested type. If the build complains that
+    // there's no definition for this declaration, it could be that
+    // LLSD::Binary has changed, and that this declaration must be adjusted to
+    // match.
+    void ensure_equals(const std::string& msg,
+        const std::vector<U8>& actual, const std::vector<U8>& expected);
 
-	void ensure_equals(const std::string& msg,
-		const LLSD& actual, const LLSD& expected);
+    void ensure_equals(const std::string& msg,
+        const LLSD& actual, const LLSD& expected);
 
-	void ensure_starts_with(const std::string& msg,
-		const std::string& actual, const std::string& expectedStart);
+    void ensure_starts_with(const std::string& msg,
+        const std::string& actual, const std::string& expectedStart);
 
-	void ensure_ends_with(const std::string& msg,
-		const std::string& actual, const std::string& expectedEnd);
+    void ensure_ends_with(const std::string& msg,
+        const std::string& actual, const std::string& expectedEnd);
 
-	void ensure_contains(const std::string& msg,
-		const std::string& actual, const std::string& expectedSubString);
+    void ensure_contains(const std::string& msg,
+        const std::string& actual, const std::string& expectedSubString);
 
-	void ensure_does_not_contain(const std::string& msg,
-		const std::string& actual, const std::string& expectedSubString);
+    void ensure_does_not_contain(const std::string& msg,
+        const std::string& actual, const std::string& expectedSubString);
 }
 
 // This is an odd place to #include an important contributor -- but the usual
@@ -87,73 +87,73 @@ namespace tut
 // The functions BELOW this point actually consume tut.hpp functionality.
 namespace tut
 {
-	inline void ensure_approximately_equals(const char* msg, F64 actual, F64 expected, U32 frac_bits)
-	{
-		if(!is_approx_equal_fraction(actual, expected, frac_bits))
-		{
-			std::stringstream ss;
-			ss << (msg?msg:"") << (msg?": ":"") << "not equal actual: " << actual << " expected: " << expected;
-			throw tut::failure(ss.str().c_str());
-		}
-	}
-
-	inline void ensure_approximately_equals(const char* msg, F32 actual, F32 expected, U32 frac_bits)
-	{
-		if(!is_approx_equal_fraction(actual, expected, frac_bits))
-		{
-			std::stringstream ss;
-			ss << (msg?msg:"") << (msg?": ":"") << "not equal actual: " << actual << " expected: " << expected;
-			throw tut::failure(ss.str().c_str());
-		}
-	}
-
-	inline void ensure_approximately_equals(F32 actual, F32 expected, U32 frac_bits)
-	{
-		ensure_approximately_equals(NULL, actual, expected, frac_bits);
-	}
-
-	inline void ensure_approximately_equals_range(const char *msg, F32 actual, F32 expected, F32 delta)
-	{
-		if (fabs(actual-expected)>delta)
-		{
-			std::stringstream ss;
-			ss << (msg?msg:"") << (msg?": ":"") << "not equal actual: " << actual << " expected: " << expected << " tolerance: " << delta;
-			throw tut::failure(ss.str().c_str());
-		}
-	}
-
-	inline void ensure_memory_matches(const char* msg,const void* actual, U32 actual_len, const void* expected,U32 expected_len)
-	{
-		if((expected_len != actual_len) || 
-			(std::memcmp(actual, expected, actual_len) != 0))
-		{
-			std::stringstream ss;
-			ss << (msg?msg:"") << (msg?": ":"") << "not equal";
-			throw tut::failure(ss.str().c_str());
-		}
-	}
-
-	inline void ensure_memory_matches(const void* actual, U32 actual_len, const void* expected,U32 expected_len)
-	{
-		ensure_memory_matches(NULL, actual, actual_len, expected, expected_len);
-	}
-
-	template <class T,class Q>
-	void ensure_not_equals(const char* msg,const Q& actual,const T& expected)
-	{
-		if( expected == actual )
-		{
-			std::stringstream ss;
-			ss << (msg?msg:"") << (msg?": ":"") << "both equal " << expected;
-			throw tut::failure(ss.str().c_str());
-		}
-	}
-
-	template <class T,class Q>
-	void ensure_not_equals(const Q& actual,const T& expected)
-	{
-		ensure_not_equals(NULL, actual, expected);
-	}
+    inline void ensure_approximately_equals(const char* msg, F64 actual, F64 expected, U32 frac_bits)
+    {
+        if(!is_approx_equal_fraction(actual, expected, frac_bits))
+        {
+            std::stringstream ss;
+            ss << (msg?msg:"") << (msg?": ":"") << "not equal actual: " << actual << " expected: " << expected;
+            throw tut::failure(ss.str().c_str());
+        }
+    }
+
+    inline void ensure_approximately_equals(const char* msg, F32 actual, F32 expected, U32 frac_bits)
+    {
+        if(!is_approx_equal_fraction(actual, expected, frac_bits))
+        {
+            std::stringstream ss;
+            ss << (msg?msg:"") << (msg?": ":"") << "not equal actual: " << actual << " expected: " << expected;
+            throw tut::failure(ss.str().c_str());
+        }
+    }
+
+    inline void ensure_approximately_equals(F32 actual, F32 expected, U32 frac_bits)
+    {
+        ensure_approximately_equals(NULL, actual, expected, frac_bits);
+    }
+
+    inline void ensure_approximately_equals_range(const char *msg, F32 actual, F32 expected, F32 delta)
+    {
+        if (fabs(actual-expected)>delta)
+        {
+            std::stringstream ss;
+            ss << (msg?msg:"") << (msg?": ":"") << "not equal actual: " << actual << " expected: " << expected << " tolerance: " << delta;
+            throw tut::failure(ss.str().c_str());
+        }
+    }
+
+    inline void ensure_memory_matches(const char* msg,const void* actual, U32 actual_len, const void* expected,U32 expected_len)
+    {
+        if((expected_len != actual_len) ||
+            (std::memcmp(actual, expected, actual_len) != 0))
+        {
+            std::stringstream ss;
+            ss << (msg?msg:"") << (msg?": ":"") << "not equal";
+            throw tut::failure(ss.str().c_str());
+        }
+    }
+
+    inline void ensure_memory_matches(const void* actual, U32 actual_len, const void* expected,U32 expected_len)
+    {
+        ensure_memory_matches(NULL, actual, actual_len, expected, expected_len);
+    }
+
+    template <class T,class Q>
+    void ensure_not_equals(const char* msg,const Q& actual,const T& expected)
+    {
+        if( expected == actual )
+        {
+            std::stringstream ss;
+            ss << (msg?msg:"") << (msg?": ":"") << "both equal " << expected;
+            throw tut::failure(ss.str().c_str());
+        }
+    }
+
+    template <class T,class Q>
+    void ensure_not_equals(const Q& actual,const T& expected)
+    {
+        ensure_not_equals(NULL, actual, expected);
+    }
 }
 
 #endif // LL_LLTUT_H