Imported existing code

indra/test/lltut.cpp

@@ -0,0 +1,202 @@
+/** 
+ * @file lltut.cpp
+ * @author Mark Lentczner
+ * @date 5/16/06
+ * @brief MacTester
+ *
+ * $LicenseInfo:firstyear=2006&license=viewergpl$
+ * 
+ * Copyright (c) 2006-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "lltut.h"
+
+#include "lldate.h"
+#include "llformat.h"
+#include "llsd.h"
+#include "lluri.h"
+
+namespace tut
+{
+	void ensure_equals(const char* msg, const LLDate& actual,
+		const LLDate& expected)
+	{
+		ensure_equals(msg,
+			actual.secondsSinceEpoch(), expected.secondsSinceEpoch());
+	}
+
+	void ensure_equals(const char* msg, const LLURI& actual,
+		const LLURI& expected)
+	{
+		ensure_equals(msg,
+			actual.asString(), expected.asString());
+	}
+
+	void ensure_equals(const char* msg,
+		const std::vector<U8>& actual, const std::vector<U8>& expected)
+	{
+		std::string s(msg);
+		
+		ensure_equals(s + " size", actual.size(), expected.size());
+		
+		std::vector<U8>::const_iterator i, j;
+		int k;
+		for (i = actual.begin(), j = expected.begin(), k = 0;
+			i != actual.end();
+			++i, ++j, ++k)
+		{
+			ensure_equals(s + " field", *i, *j);
+		}
+	}
+
+	void ensure_equals(const char* m, const LLSD& actual,
+		const LLSD& expected)
+	{
+		const std::string& msg = m ? m : "";
+		
+		ensure_equals(msg + " type", actual.type(), expected.type());
+		switch (actual.type())
+		{
+			case LLSD::TypeUndefined:
+				return;
+			
+			case LLSD::TypeBoolean:
+				ensure_equals(msg + " boolean", actual.asBoolean(), expected.asBoolean());
+				return;
+			
+			case LLSD::TypeInteger:
+				ensure_equals(msg + " integer", actual.asInteger(), expected.asInteger());
+				return;
+			
+			case LLSD::TypeReal:
+				ensure_equals(msg + " real", actual.asReal(), expected.asReal());
+				return;
+			
+			case LLSD::TypeString:
+				ensure_equals(msg + " string", actual.asString(), expected.asString());
+				return;
+			
+			case LLSD::TypeUUID:
+				ensure_equals(msg + " uuid", actual.asUUID(), expected.asUUID());
+				return;
+			
+			case LLSD::TypeDate:
+				ensure_equals(msg + " date", actual.asDate(), expected.asDate());
+				return;
+				
+			case LLSD::TypeURI:
+				ensure_equals(msg + " uri", actual.asURI(), expected.asURI());
+				return;
+		
+			case LLSD::TypeBinary:
+				ensure_equals(msg + " binary", actual.asBinary(), expected.asBinary());
+				return;
+		
+			case LLSD::TypeMap:
+			{
+				ensure_equals(msg + " map size", actual.size(), expected.size());
+				
+				LLSD::map_const_iterator actual_iter = actual.beginMap();
+				LLSD::map_const_iterator expected_iter = expected.beginMap();
+				
+				while(actual_iter != actual.endMap())
+				{
+					ensure_equals(msg + " map keys", 
+						actual_iter->first, expected_iter->first);
+					ensure_equals((msg + "[" + actual_iter->first + "]").c_str(),
+						actual_iter->second, expected_iter->second);
+					++actual_iter;
+					++expected_iter;
+				}
+				return;
+			}
+			case LLSD::TypeArray:
+			{
+				ensure_equals(msg + " array size", actual.size(), expected.size());
+				
+				for(int i = 0; i < actual.size(); ++i)
+				{
+					ensure_equals((msg + llformat("[%d]", i)).c_str(),
+						actual[i], expected[i]);
+				}
+				return;
+			}
+		}
+	}
+
+	void ensure_starts_with(const std::string& msg,
+		const std::string& actual, const std::string& expectedStart)
+	{
+		if( actual.find(expectedStart, 0) != 0 )
+		{
+			std::stringstream ss;
+			ss << msg << ": " << "expected to find " << expectedStart
+				<< " at start of actual " << actual;
+			throw failure(ss.str().c_str());
+		}
+	}
+
+	void ensure_ends_with(const std::string& msg,
+		const std::string& actual, const std::string& expectedEnd)
+	{
+		if( actual.size() < expectedEnd.size()
+			|| actual.rfind(expectedEnd)
+				!= (actual.size() - expectedEnd.size()) )
+		{
+			std::stringstream ss;
+			ss << msg << ": " << "expected to find " << expectedEnd
+				<< " at end of actual " << actual;
+			throw failure(ss.str().c_str());
+		}
+	}
+
+	void ensure_contains(const std::string& msg,
+		const std::string& actual, const std::string& expectedSubString)
+	{
+		if( actual.find(expectedSubString, 0) == std::string::npos )
+		{
+			std::stringstream ss;
+			ss << msg << ": " << "expected to find " << expectedSubString
+				<< " in actual " << actual;
+			throw failure(ss.str().c_str());
+		}
+	}
+
+	void ensure_does_not_contain(const std::string& msg,
+		const std::string& actual, const std::string& expectedSubString)
+	{
+		if( actual.find(expectedSubString, 0) != std::string::npos )
+		{
+			std::stringstream ss;
+			ss << msg << ": " << "expected not to find " << expectedSubString
+				<< " in actual " << actual;
+			throw failure(ss.str().c_str());
+		}
+	}
+}
+