Fix Xcode 6 compile errors relating to tut::ensure_equals() overloads.

lltut.h declares a number of ensure_equals() overloads for various data types,
notably the types supported by LLSD. We expect these to be called by tut code.
But the tut code in question is in a template in tut.hpp -- which was
#included BEFORE the overloads were declared. Previous C++ compilers have
evidently made multiple passes, collecting the relevant overloads before
attempting to compile the template bodies. clang does not, complaining that
the overloads must be declared before the tut.hpp template code that
references them. Reordering parts of lltut.h seems to address that problem.
For similar reasons, test programs that use StringVec.h and its operator<<()
must #include StringVec.h before lltut.h.
Add ensure_equals(const std::string&, const LLSD::Binary&, const LLSD::Binary&)
overload. The sloppy mix of (const char*, ...) and (const std::string&, ...)
overloads bothers me, since for many of those ... types we seem to have to
duplicate them.

indra/test/llevents_tut.cpp

@@ -48,10 +48,10 @@
 #include <boost/shared_ptr.hpp>
 #include <boost/assign/list_of.hpp>
 // other Linden headers
+#include "tests/listener.h"             // must PRECEDE lltut.h
 #include "lltut.h"
 #include "catch_and_store_what_in.h"
 #include "stringize.h"
-#include "tests/listener.h"
 
 using boost::assign::list_of;
 

indra/test/lltut.cpp

@@ -52,12 +52,25 @@ namespace tut
 			actual.asString(), expected.asString());
 	}
 
+	// The lexical param types here intentionally diverge from the declaration
+	// in our header file. In lltut.h, LLSD is only a forward-declared type;
+	// we have no access to its LLSD::Binary nested type, and so must restate
+	// it explicitly to declare this overload. However, an overload that does
+	// NOT match LLSD::Binary does us no good whatsoever: it would never be
+	// engaged. Stating LLSD::Binary for this definition at least means that
+	// if the LLSD::Binary type ever diverges from what we expect in lltut.h,
+	// that divergence will produce an error: no definition will match that
+	// declaration.
 	void ensure_equals(const char* msg,
-		const std::vector<U8>& actual, const std::vector<U8>& expected)
+		const LLSD::Binary& actual, const LLSD::Binary& expected)
 	{
-		std::string s(msg);
-		
-		ensure_equals(s + " size", actual.size(), expected.size());
+		ensure_equals(std::string(msg? msg : ""), actual, expected);
+	}
+
+	void ensure_equals(const std::string& msg,
+		const LLSD::Binary& actual, const LLSD::Binary& expected)
+	{
+		ensure_equals(msg + " size", actual.size(), expected.size());
 		
 		std::vector<U8>::const_iterator i, j;
 		int k;
@@ -65,14 +78,14 @@ namespace tut
 			i != actual.end();
 			++i, ++j, ++k)
 		{
-			ensure_equals(s + " field", *i, *j);
+			ensure_equals(msg + " field", *i, *j);
 		}
 	}
 
 	void ensure_equals(const char* m, const LLSD& actual,
 		const LLSD& expected)
     {
-        ensure_equals(std::string(m), actual, expected);
+        ensure_equals(std::string(m? m : ""), actual, expected);
     }
 
 	void ensure_equals(const std::string& msg, const LLSD& actual,

indra/test/lltut.h

@@ -30,6 +30,60 @@
 #define LL_LLTUT_H
 
 #include "is_approx_equal_fraction.h" // instead of llmath.h
+#include <cstring>
+
+class LLDate;
+class LLSD;
+class LLURI;
+
+namespace tut
+{
+	template <class T,class Q>
+	void ensure_equals(const std::string& msg,
+		const Q& actual,const T& expected)
+		{ ensure_equals(msg.c_str(), actual, expected); }
+
+	void ensure_equals(const char* msg,
+		const LLDate& actual, const LLDate& expected);
+
+	void ensure_equals(const char* 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 either of these declarations, it could be
+	// that LLSD::Binary has changed, and that these declarations must be
+	// adjusted to match.
+	void ensure_equals(const char* msg,
+		const std::vector<U8>& actual, const std::vector<U8>& expected);
+
+	void ensure_equals(const std::string& msg,
+		const std::vector<U8>& actual, const std::vector<U8>& expected);
+
+	void ensure_equals(const char* 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_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_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
+// rules are reversed here. Instead of the overloads above referencing tut.hpp
+// features, we need calls in tut.hpp template functions to dispatch to our
+// overloads declared above.
 
 // turn off warnings about unused functions from clang for tut package
 #pragma clang diagnostic push
@@ -37,12 +91,7 @@
 #include <tut/tut.hpp>
 #pragma clang diagnostic pop
 
-#include <cstring>
-
-class LLDate;
-class LLSD;
-class LLURI;
-
+// 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)
@@ -112,40 +161,6 @@ namespace tut
 	{
 		ensure_not_equals(NULL, actual, expected);
 	}
-	
-	
-	template <class T,class Q>
-	void ensure_equals(const std::string& msg,
-		const Q& actual,const T& expected)
-		{ ensure_equals(msg.c_str(), actual, expected); }
-
-	void ensure_equals(const char* msg,
-		const LLDate& actual, const LLDate& expected);
-
-	void ensure_equals(const char* msg,
-		const LLURI& actual, const LLURI& expected);
-		
-	void ensure_equals(const char* msg,
-		const std::vector<U8>& actual, const std::vector<U8>& expected);
-
-	void ensure_equals(const char* 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_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_does_not_contain(const std::string& msg,
-		const std::string& actual, const std::string& expectedSubString);
 }
 
-
 #endif // LL_LLTUT_H