From b6a08ad007deb855ce4d428654279206853a3b99 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 13 Jan 2012 12:41:54 -0500
Subject: Extract APR and temp-fixture-file helper code to indra/test.
 Specifically: Introduce ManageAPR class in indra/test/manageapr.h. This is
 useful for a simple test program without lots of static constructors. Extract
 NamedTempFile from llsdserialize_test.cpp to indra/test/ namedtempfile.h.
 Refactor to use APR file operations rather than platform- dependent APIs. Use
 NamedTempFile for llprocesslauncher_test.cpp.

---
 indra/test/manageapr.h     |  45 ++++++++++++++++++
 indra/test/namedtempfile.h | 113 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 158 insertions(+)
 create mode 100644 indra/test/manageapr.h
 create mode 100644 indra/test/namedtempfile.h

(limited to 'indra/test')

diff --git a/indra/test/manageapr.h b/indra/test/manageapr.h
new file mode 100644
index 0000000000..0c1ca7b7be
--- /dev/null
+++ b/indra/test/manageapr.h
@@ -0,0 +1,45 @@
+/**
+ * @file   manageapr.h
+ * @author Nat Goodspeed
+ * @date   2012-01-13
+ * @brief  ManageAPR class for simple test programs
+ * 
+ * $LicenseInfo:firstyear=2012&license=viewerlgpl$
+ * Copyright (c) 2012, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_MANAGEAPR_H)
+#define LL_MANAGEAPR_H
+
+#include "llapr.h"
+
+/**
+ * Declare a static instance of this class for dead-simple ll_init_apr() at
+ * program startup, ll_cleanup_apr() at termination. This is recommended for
+ * use only with simple test programs. Once you start introducing static
+ * instances of other classes that depend on APR already being initialized,
+ * the indeterminate static-constructor-order problem rears its ugly head.
+ */
+class ManageAPR
+{
+public:
+    ManageAPR()
+    {
+        ll_init_apr();
+    }
+
+    ~ManageAPR()
+    {
+        ll_cleanup_apr();
+    }
+
+    static std::string strerror(apr_status_t rv)
+    {
+        char errbuf[256];
+        apr_strerror(rv, errbuf, sizeof(errbuf));
+        return errbuf;
+    }
+};
+
+#endif /* ! defined(LL_MANAGEAPR_H) */
diff --git a/indra/test/namedtempfile.h b/indra/test/namedtempfile.h
new file mode 100644
index 0000000000..9670d4db53
--- /dev/null
+++ b/indra/test/namedtempfile.h
@@ -0,0 +1,113 @@
+/**
+ * @file   namedtempfile.h
+ * @author Nat Goodspeed
+ * @date   2012-01-13
+ * @brief  NamedTempFile class for tests that need disk files as fixtures.
+ * 
+ * $LicenseInfo:firstyear=2012&license=viewerlgpl$
+ * Copyright (c) 2012, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_NAMEDTEMPFILE_H)
+#define LL_NAMEDTEMPFILE_H
+
+#include "llapr.h"
+#include "apr_file_io.h"
+#include <string>
+#include <boost/function.hpp>
+#include "boost/lambda/lambda.hpp"
+#include "boost/lambda/bind.hpp"
+#include <iostream>
+#include <sstream>
+
+/**
+ * Create a text file with specified content "somewhere in the
+ * filesystem," cleaning up when it goes out of scope.
+ */
+class NamedTempFile
+{
+public:
+    NamedTempFile(const std::string& pfx, const std::string& content, apr_pool_t* pool=gAPRPoolp):
+        mPool(pool)
+    {
+        createFile(pfx, boost::lambda::_1 << content);
+    }
+
+    // Disambiguate when passing string literal
+    NamedTempFile(const std::string& pfx, const char* content, apr_pool_t* pool=gAPRPoolp):
+        mPool(pool)
+    {
+        createFile(pfx, boost::lambda::_1 << content);
+    }
+
+    // Function that accepts an ostream ref and (presumably) writes stuff to
+    // it, e.g.:
+    // (boost::lambda::_1 << "the value is " << 17 << '\n')
+    typedef boost::function<void(std::ostream&)> Streamer;
+
+    NamedTempFile(const std::string& pfx, const Streamer& func, apr_pool_t* pool=gAPRPoolp):
+        mPool(pool)
+    {
+        createFile(pfx, func);
+    }
+
+    ~NamedTempFile()
+    {
+        ll_apr_assert_status(apr_file_remove(mPath.c_str(), mPool));
+    }
+
+    std::string getName() const { return mPath; }
+
+private:
+    void createFile(const std::string& pfx, const Streamer& func)
+    {
+        // Create file in a temporary place.
+        const char* tempdir = NULL;
+        ll_apr_assert_status(apr_temp_dir_get(&tempdir, mPool));
+
+        // Construct a temp filename template in that directory.
+        char *tempname = NULL;
+        ll_apr_assert_status(apr_filepath_merge(&tempname,
+                                                tempdir,
+                                                (pfx + "XXXXXX").c_str(),
+                                                0,
+                                                mPool));
+
+        // Create a temp file from that template.
+        apr_file_t* fp = NULL;
+        ll_apr_assert_status(apr_file_mktemp(&fp,
+                                             tempname,
+                                             APR_CREATE | APR_WRITE | APR_EXCL,
+                                             mPool));
+        // apr_file_mktemp() alters tempname with the actual name. Not until
+        // now is it valid to capture as our mPath.
+        mPath = tempname;
+
+        // Write desired content.
+        std::ostringstream out;
+        // Stream stuff to it.
+        func(out);
+
+        std::string data(out.str());
+        apr_size_t writelen(data.length());
+        ll_apr_assert_status(apr_file_write(fp, data.c_str(), &writelen));
+        ll_apr_assert_status(apr_file_close(fp));
+        llassert_always(writelen == data.length());
+    }
+
+    void peep()
+    {
+        std::cout << "File '" << mPath << "' contains:\n";
+        std::ifstream reader(mPath.c_str());
+        std::string line;
+        while (std::getline(reader, line))
+            std::cout << line << '\n';
+        std::cout << "---\n";
+    }
+
+    std::string mPath;
+    apr_pool_t* mPool;
+};
+
+#endif /* ! defined(LL_NAMEDTEMPFILE_H) */
-- 
cgit v1.2.3


From a01dd3549cca620de47fae824198473c51a12f49 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 17 Jan 2012 18:40:05 -0500
Subject: Make NamedTempFile::peep() a public member for debugging unit tests.

---
 indra/test/namedtempfile.h | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/namedtempfile.h b/indra/test/namedtempfile.h
index 9670d4db53..7ffb2836cc 100644
--- a/indra/test/namedtempfile.h
+++ b/indra/test/namedtempfile.h
@@ -59,6 +59,16 @@ public:
 
     std::string getName() const { return mPath; }
 
+    void peep()
+    {
+        std::cout << "File '" << mPath << "' contains:\n";
+        std::ifstream reader(mPath.c_str());
+        std::string line;
+        while (std::getline(reader, line))
+            std::cout << line << '\n';
+        std::cout << "---\n";
+    }
+
 private:
     void createFile(const std::string& pfx, const Streamer& func)
     {
@@ -96,16 +106,6 @@ private:
         llassert_always(writelen == data.length());
     }
 
-    void peep()
-    {
-        std::cout << "File '" << mPath << "' contains:\n";
-        std::ifstream reader(mPath.c_str());
-        std::string line;
-        while (std::getline(reader, line))
-            std::cout << line << '\n';
-        std::cout << "---\n";
-    }
-
     std::string mPath;
     apr_pool_t* mPool;
 };
-- 
cgit v1.2.3


From 51b26cab9ad8dc54277c6158ad40afdf3ed0e6d0 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 17 Jan 2012 20:30:46 -0500
Subject: Any proper RAII class must either handle copying or be noncopyable.
 NamedTempFile makes no attempt to deal with copying, therefore make it
 noncopyable.

---
 indra/test/namedtempfile.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/namedtempfile.h b/indra/test/namedtempfile.h
index 7ffb2836cc..aa7058b111 100644
--- a/indra/test/namedtempfile.h
+++ b/indra/test/namedtempfile.h
@@ -16,8 +16,9 @@
 #include "apr_file_io.h"
 #include <string>
 #include <boost/function.hpp>
-#include "boost/lambda/lambda.hpp"
-#include "boost/lambda/bind.hpp"
+#include <boost/lambda/lambda.hpp>
+#include <boost/lambda/bind.hpp>
+#include <boost/noncopyable.hpp>
 #include <iostream>
 #include <sstream>
 
@@ -25,7 +26,7 @@
  * Create a text file with specified content "somewhere in the
  * filesystem," cleaning up when it goes out of scope.
  */
-class NamedTempFile
+class NamedTempFile: public boost::noncopyable
 {
 public:
     NamedTempFile(const std::string& pfx, const std::string& content, apr_pool_t* pool=gAPRPoolp):
-- 
cgit v1.2.3


From d99acd56cdc41d72a073a4419e3e51c356e675bb Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 6 Feb 2012 17:06:55 -0500
Subject: ManageAPR should be noncopyable. Make that explicit. Any RAII class
 should either be noncopyable or should deal appropriately with a copy
 operation. ManageAPR is intended only for extremely simple cases, and hence
 should be noncopyable.

---
 indra/test/manageapr.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'indra/test')

diff --git a/indra/test/manageapr.h b/indra/test/manageapr.h
index 0c1ca7b7be..2452fb6ae4 100644
--- a/indra/test/manageapr.h
+++ b/indra/test/manageapr.h
@@ -13,6 +13,7 @@
 #define LL_MANAGEAPR_H
 
 #include "llapr.h"
+#include <boost/noncopyable.hpp>
 
 /**
  * Declare a static instance of this class for dead-simple ll_init_apr() at
@@ -21,7 +22,7 @@
  * instances of other classes that depend on APR already being initialized,
  * the indeterminate static-constructor-order problem rears its ugly head.
  */
-class ManageAPR
+class ManageAPR: public boost::noncopyable
 {
 public:
     ManageAPR()
-- 
cgit v1.2.3


From 10ab4adc86207f86df30ab23d8858c23e7f550ea Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 15 Feb 2012 13:44:43 -0500
Subject: Fix llprocess_test.cpp's exception catching for Linux. In the course
 of re-enabling the indra/test tests last year, Log generalized a workaround
 I'd introduced in llsdmessage_test.cpp. In Linux viewer land, a test program
 trying to catch an expected exception can't seem to catch it by its specific
 class (across the libllcommon.so boundary), but must instead catch
 std::runtime_error and validate the typeid().name() string. Log added a macro
 for this idiom in llevents_tut.cpp. Generalize that macro further for
 normal-case processing as well, move it to a header file of its own and use
 it in all known places -- plus the new exception-catching tests in
 llprocess_test.cpp.

---
 indra/test/catch_and_store_what_in.h | 86 ++++++++++++++++++++++++++++++++++++
 indra/test/llevents_tut.cpp          | 69 +++--------------------------
 2 files changed, 92 insertions(+), 63 deletions(-)
 create mode 100644 indra/test/catch_and_store_what_in.h

(limited to 'indra/test')

diff --git a/indra/test/catch_and_store_what_in.h b/indra/test/catch_and_store_what_in.h
new file mode 100644
index 0000000000..59f8cc0085
--- /dev/null
+++ b/indra/test/catch_and_store_what_in.h
@@ -0,0 +1,86 @@
+/**
+ * @file   catch_and_store_what_in.h
+ * @author Nat Goodspeed
+ * @date   2012-02-15
+ * @brief  CATCH_AND_STORE_WHAT_IN() macro
+ * 
+ * $LicenseInfo:firstyear=2012&license=viewerlgpl$
+ * Copyright (c) 2012, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_CATCH_AND_STORE_WHAT_IN_H)
+#define LL_CATCH_AND_STORE_WHAT_IN_H
+
+/**
+ * Idiom useful for test programs: catch an expected exception, store its
+ * what() string in a specified std::string variable. From there the caller
+ * can do things like:
+ * @code
+ * ensure("expected exception not thrown", ! string.empty());
+ * @endcode
+ * or
+ * @code
+ * ensure_contains("exception doesn't mention blah", string, "blah");
+ * @endcode
+ * etc.
+ *
+ * The trouble is that when linking to a dynamic libllcommon.so on Linux, we
+ * generally fail to catch the specific exception. Oddly, we can catch it as
+ * std::runtime_error and validate its typeid().name(), so we do -- but that's
+ * a lot of boilerplate per test. Encapsulate with this macro. Usage:
+ *
+ * @code
+ * std::string threw;
+ * try
+ * {
+ *     some_call_that_should_throw_Foo();
+ * }
+ * CATCH_AND_STORE_WHAT_IN(threw, Foo)
+ * ensure("some_call_that_should_throw_Foo() didn't throw", ! threw.empty());
+ * @endcode
+ */
+#define CATCH_AND_STORE_WHAT_IN(THREW, EXCEPTION)	\
+catch (const EXCEPTION& ex)							\
+{													\
+	(THREW) = ex.what();							\
+}													\
+CATCH_MISSED_LINUX_EXCEPTION(THREW, EXCEPTION)
+
+#ifndef LL_LINUX
+#define CATCH_MISSED_LINUX_EXCEPTION(THREW, EXCEPTION)					\
+	/* only needed on Linux */
+#else // LL_LINUX
+
+#define CATCH_MISSED_LINUX_EXCEPTION(THREW, EXCEPTION)					\
+catch (const std::runtime_error& ex)									\
+{																		\
+	/* This clause is needed on Linux, on the viewer side, because	*/	\
+	/* the exception isn't caught by catch (const EXCEPTION&).		*/	\
+	/* But if the expected exception was thrown, allow the test to	*/	\
+	/* succeed anyway. Not sure how else to handle this odd case.	*/	\
+	if (std::string(typeid(ex).name()) == typeid(EXCEPTION).name())		\
+	{																	\
+		/* std::cerr << "Caught " << typeid(ex).name() */				\
+		/*			 << " with Linux workaround" << std::endl; */		\
+		(THREW) = ex.what();											\
+		/*std::cout << ex.what() << std::endl;*/						\
+	}																	\
+	else																\
+	{																	\
+		/* We don't even recognize this exception. Let it propagate	*/	\
+		/* out to TUT to fail the test.								*/	\
+		throw;															\
+	}																	\
+}																		\
+catch (...)																\
+{																		\
+	std::cerr << "Failed to catch expected exception "					\
+			  << #EXCEPTION << "!" << std::endl;						\
+	/* This indicates a problem in the test that should be addressed. */ \
+	throw;																\
+}
+
+#endif // LL_LINUX
+
+#endif /* ! defined(LL_CATCH_AND_STORE_WHAT_IN_H) */
diff --git a/indra/test/llevents_tut.cpp b/indra/test/llevents_tut.cpp
index 4699bb1827..ca4c74099f 100644
--- a/indra/test/llevents_tut.cpp
+++ b/indra/test/llevents_tut.cpp
@@ -49,46 +49,12 @@
 #include <boost/assign/list_of.hpp>
 // other Linden headers
 #include "lltut.h"
+#include "catch_and_store_what_in.h"
 #include "stringize.h"
 #include "tests/listener.h"
 
 using boost::assign::list_of;
 
-#ifdef LL_LINUX
-#define CATCH_MISSED_LINUX_EXCEPTION(exception, threw)										\
-catch (const std::runtime_error& ex)														\
-{																							\
-	/* This clause is needed on Linux, on the viewer side, because the	*/					\
-	/* exception isn't caught by the clause above. Warn the user...		*/					\
-	std::cerr << "Failed to catch " << typeid(ex).name() << std::endl;						\
-	/* But if the expected exception was thrown, allow the test to		*/					\
-	/* succeed anyway. Not sure how else to handle this odd case.		*/					\
-	/* This approach is also used in llsdmessage_test.cpp. 				*/					\
-	if (std::string(typeid(ex).name()) == typeid(exception).name())							\
-	{																						\
-		threw = ex.what();																	\
-		/*std::cout << ex.what() << std::endl;*/											\
-	}																						\
-	else																					\
-	{																						\
-		/* We don't even recognize this exception. Let it propagate		*/					\
-		/* out to TUT to fail the test.									*/					\
-		throw;																				\
-	}																						\
-}																							\
-catch (...)																					\
-{																							\
-	std::cerr << "Utterly failed to catch expected exception " << #exception << "!" <<		\
-	std::endl;																				\
-	/* This indicates a problem in the test that should be addressed.   */					\
-	throw;																					\
-}
-
-#else // LL_LINUX
-#define CATCH_MISSED_LINUX_EXCEPTION(exception, threw)										\
-	/* Not needed on other platforms */
-#endif // LL_LINUX
-
 template<typename T>
 T make(const T& value)
 {
@@ -178,11 +144,7 @@ void events_object::test<1>()
 		per_frame.listen(listener0.getName(), // note bug, dup name
 						 boost::bind(&Listener::call, boost::ref(listener1), _1));
 	}
-	catch (const LLEventPump::DupListenerName& e)
-	{
-		threw = e.what();
-	}
-	CATCH_MISSED_LINUX_EXCEPTION(LLEventPump::DupListenerName, threw)
+	CATCH_AND_STORE_WHAT_IN(threw, LLEventPump::DupListenerName)
 	ensure_equals(threw,
 				  std::string("DupListenerName: "
 							  "Attempt to register duplicate listener name '") +
@@ -388,12 +350,7 @@ void events_object::test<7>()
 					  // after "Mary" and "checked" -- whoops!
 			 		  make<NameList>(list_of("Mary")("checked")));
 	}
-	catch (const LLEventPump::Cycle& e)
-	{
-		threw = e.what();
-		// std::cout << "Caught: " << e.what() << '\n';
-	}
-	CATCH_MISSED_LINUX_EXCEPTION(LLEventPump::Cycle, threw)
+	CATCH_AND_STORE_WHAT_IN(threw, LLEventPump::Cycle)
 	// Obviously the specific wording of the exception text can
 	// change; go ahead and change the test to match.
 	// Establish that it contains:
@@ -426,12 +383,7 @@ void events_object::test<7>()
 					  make<NameList>(list_of("shoelaces")),
 					  make<NameList>(list_of("yellow")));
 	}
-	catch (const LLEventPump::OrderChange& e)
-	{
-		threw = e.what();
-		// std::cout << "Caught: " << e.what() << '\n';
-	}
-	CATCH_MISSED_LINUX_EXCEPTION(LLEventPump::OrderChange, threw)
+	CATCH_AND_STORE_WHAT_IN(threw, LLEventPump::OrderChange)
 	// Same remarks about the specific wording of the exception. Just
 	// ensure that it contains enough information to clarify the
 	// problem and what must be done to resolve it.
@@ -459,12 +411,7 @@ void events_object::test<8>()
 			// then another with a duplicate name.
 			LLEventStream bob2("bob");
 		}
-		catch (const LLEventPump::DupPumpName& e)
-		{
-			threw = e.what();
-			// std::cout << "Caught: " << e.what() << '\n';
-		}
-		CATCH_MISSED_LINUX_EXCEPTION(LLEventPump::DupPumpName, threw)
+		CATCH_AND_STORE_WHAT_IN(threw, LLEventPump::DupPumpName)
 		ensure("Caught DupPumpName", !threw.empty());
 	} 	// delete first 'bob'
 	LLEventStream bob("bob"); 		// should work, previous one unregistered
@@ -505,11 +452,7 @@ void events_object::test<9>()
 		LLListenerOrPumpName empty;
 		empty(17);
 	}
-	catch (const LLListenerOrPumpName::Empty& e)
-	{
-		threw = e.what();
-	}
-	CATCH_MISSED_LINUX_EXCEPTION(LLListenerOrPumpName::Empty, threw)
+	CATCH_AND_STORE_WHAT_IN(threw, LLListenerOrPumpName::Empty)
 
 	ensure("threw Empty", !threw.empty());
 }
-- 
cgit v1.2.3


From 5adc39753b9392050d961eb01edb31f8a6fbb05d Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 24 Feb 2012 16:02:39 -0500
Subject: Update llevents_tut.cpp to use StringVec, not local StringList.

---
 indra/test/llevents_tut.cpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/llevents_tut.cpp b/indra/test/llevents_tut.cpp
index ca4c74099f..a9114075fc 100644
--- a/indra/test/llevents_tut.cpp
+++ b/indra/test/llevents_tut.cpp
@@ -316,7 +316,6 @@ void events_object::test<7>()
 {
 	set_test_name("listener dependency order");
 	typedef LLEventPump::NameList NameList;
-	typedef Collect::StringList StringList;
 	LLEventPump& button(pumps.obtain("button"));
 	Collect collector;
 	button.listen("Mary",
@@ -330,7 +329,7 @@ void events_object::test<7>()
 	button.listen("spot",
 				  boost::bind(&Collect::add, boost::ref(collector), "spot", _1));
 	button.post(1);
-	ensure_equals(collector.result, make<StringList>(list_of("spot")("checked")("Mary")));
+	ensure_equals(collector.result, make<StringVec>(list_of("spot")("checked")("Mary")));
 	collector.clear();
 	button.stopListening("Mary");
 	button.listen("Mary",
@@ -339,7 +338,7 @@ void events_object::test<7>()
 			// now "Mary" must come before "spot"
 			make<NameList>(list_of("spot")));
 	button.post(2);
-	ensure_equals(collector.result, make<StringList>(list_of("Mary")("spot")("checked")));
+	ensure_equals(collector.result, make<StringVec>(list_of("Mary")("spot")("checked")));
 	collector.clear();
 	button.stopListening("spot");
 	std::string threw;
@@ -373,7 +372,7 @@ void events_object::test<7>()
 				  boost::bind(&Collect::add, boost::ref(collector), "shoelaces", _1),
 				  make<NameList>(list_of("checked")));
 	button.post(3);
-	ensure_equals(collector.result, make<StringList>(list_of("Mary")("checked")("yellow")("shoelaces")));
+	ensure_equals(collector.result, make<StringVec>(list_of("Mary")("checked")("yellow")("shoelaces")));
 	collector.clear();
 	threw.clear();
 	try
@@ -395,7 +394,7 @@ void events_object::test<7>()
 	ensure_contains("old order", threw, "was: Mary, checked, yellow, shoelaces");
 	ensure_contains("new order", threw, "now: Mary, checked, shoelaces, of, yellow");
 	button.post(4);
-	ensure_equals(collector.result, make<StringList>(list_of("Mary")("checked")("yellow")("shoelaces")));
+	ensure_equals(collector.result, make<StringVec>(list_of("Mary")("checked")("yellow")("shoelaces")));
 }
 
 template<> template<>
-- 
cgit v1.2.3


From c8032de94e7fcad3cc8ce45db2d20cb1664ebea9 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 1 Mar 2012 14:37:41 -0500
Subject: Add NamedExtTempFile to invent arbitrary name with specified ext.
 This arises, for instance, if you want to be able to create a temporary
 Python module you can import from test scripts. The Python module file MUST
 have the .py extension.

---
 indra/test/namedtempfile.h | 97 ++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 94 insertions(+), 3 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/namedtempfile.h b/indra/test/namedtempfile.h
index aa7058b111..6069064627 100644
--- a/indra/test/namedtempfile.h
+++ b/indra/test/namedtempfile.h
@@ -12,6 +12,7 @@
 #if ! defined(LL_NAMEDTEMPFILE_H)
 #define LL_NAMEDTEMPFILE_H
 
+#include "llerror.h"
 #include "llapr.h"
 #include "apr_file_io.h"
 #include <string>
@@ -28,6 +29,7 @@
  */
 class NamedTempFile: public boost::noncopyable
 {
+    LOG_CLASS(NamedTempFile);
 public:
     NamedTempFile(const std::string& pfx, const std::string& content, apr_pool_t* pool=gAPRPoolp):
         mPool(pool)
@@ -53,12 +55,12 @@ public:
         createFile(pfx, func);
     }
 
-    ~NamedTempFile()
+    virtual ~NamedTempFile()
     {
         ll_apr_assert_status(apr_file_remove(mPath.c_str(), mPool));
     }
 
-    std::string getName() const { return mPath; }
+    virtual std::string getName() const { return mPath; }
 
     void peep()
     {
@@ -70,7 +72,7 @@ public:
         std::cout << "---\n";
     }
 
-private:
+protected:
     void createFile(const std::string& pfx, const Streamer& func)
     {
         // Create file in a temporary place.
@@ -111,4 +113,93 @@ private:
     apr_pool_t* mPool;
 };
 
+/**
+ * Create a NamedTempFile with a specified filename extension. This is useful
+ * when, for instance, you must be able to use the file in a Python import
+ * statement.
+ *
+ * A NamedExtTempFile actually has two different names. We retain the original
+ * no-extension name as a placeholder in the temp directory to ensure
+ * uniqueness; to that we link the name plus the desired extension. Naturally,
+ * both must be removed on destruction.
+ */
+class NamedExtTempFile: public NamedTempFile
+{
+    LOG_CLASS(NamedExtTempFile);
+public:
+    NamedExtTempFile(const std::string& ext, const std::string& content, apr_pool_t* pool=gAPRPoolp):
+        NamedTempFile(remove_dot(ext), content, pool),
+        mLink(mPath + ensure_dot(ext))
+    {
+        linkto(mLink);
+    }
+
+    // Disambiguate when passing string literal
+    NamedExtTempFile(const std::string& ext, const char* content, apr_pool_t* pool=gAPRPoolp):
+        NamedTempFile(remove_dot(ext), content, pool),
+        mLink(mPath + ensure_dot(ext))
+    {
+        linkto(mLink);
+    }
+
+    NamedExtTempFile(const std::string& ext, const Streamer& func, apr_pool_t* pool=gAPRPoolp):
+        NamedTempFile(remove_dot(ext), func, pool),
+        mLink(mPath + ensure_dot(ext))
+    {
+        linkto(mLink);
+    }
+
+    virtual ~NamedExtTempFile()
+    {
+        ll_apr_assert_status(apr_file_remove(mLink.c_str(), mPool));
+    }
+
+    // Since the caller has gone to the trouble to create the name with the
+    // extension, that should be the name we return. In this class, mPath is
+    // just a placeholder to ensure that future createFile() calls won't
+    // collide.
+    virtual std::string getName() const { return mLink; }
+
+    static std::string ensure_dot(const std::string& ext)
+    {
+        if (ext.empty())
+        {
+            // What SHOULD we do when the caller makes a point of using
+            // NamedExtTempFile to generate a file with a particular
+            // extension, then passes an empty extension? Use just "."? That
+            // sounds like a Bad Idea, especially on Windows. Treat that as a
+            // coding error.
+            LL_ERRS("NamedExtTempFile") << "passed empty extension" << LL_ENDL;
+        }
+        if (ext[0] == '.')
+        {
+            return ext;
+        }
+        return std::string(".") + ext;
+    }
+
+    static std::string remove_dot(const std::string& ext)
+    {
+        std::string::size_type found = ext.find_first_not_of(".");
+        if (found == std::string::npos)
+        {
+            return ext;
+        }
+        return ext.substr(found);
+    }
+
+private:
+    void linkto(const std::string& path)
+    {
+        // This method assumes that since mPath (without extension) is
+        // guaranteed by apr_file_mktemp() to be unique, then (mPath + any
+        // extension) is also unique. This is likely, though not guaranteed:
+        // files could be created in the same temp directory other than by
+        // this class.
+        ll_apr_assert_status(apr_file_link(mPath.c_str(), path.c_str()));
+    }
+
+    std::string mLink;
+};
+
 #endif /* ! defined(LL_NAMEDTEMPFILE_H) */
-- 
cgit v1.2.3


From f02ded46fe6f166a07673d97301bf169eb0b9ba8 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 5 Mar 2012 13:07:14 -0500
Subject: Make test.cpp support LOGFAIL env var: only failed tests show log.
 Set LOGFAIL= one of ALL, DEBUG, INFO, WARN, ERROR, NONE. A passing test will
 run silently, as now; but a failing test will replay log output at the
 specified level or higher. While at it, support LOGTEST environment variable,
 same values. This is like setting --debug (or -d), but allows specifying an
 arbitrary level -- and, unlike --debug, can be set for a TeamCity build
 config without modifying any scripts or code. Publish
 LLError::decodeLevel(std::string), previously private to llerror.cpp.

---
 indra/test/test.cpp | 126 +++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 114 insertions(+), 12 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/test.cpp b/indra/test/test.cpp
index 1adcfb6f45..128d84e428 100644
--- a/indra/test/test.cpp
+++ b/indra/test/test.cpp
@@ -38,6 +38,7 @@
 #include "llerrorcontrol.h"
 #include "lltut.h"
 #include "stringize.h"
+#include "namedtempfile.h"
 
 #include "apr_pools.h"
 #include "apr_getopt.h"
@@ -69,17 +70,79 @@
 #include <boost/foreach.hpp>
 #include <boost/lambda/lambda.hpp>
 
+#include <fstream>
+
+void wouldHaveCrashed(const std::string& message);
+
 namespace tut
 {
 	std::string sSourceDir;
-	
-    test_runner_singleton runner;
+
+	test_runner_singleton runner;
 }
 
+class LLReplayLog
+{
+public:
+	LLReplayLog() {}
+	virtual ~LLReplayLog() {}
+
+	virtual void reset() {}
+	virtual void replay(std::ostream&) {}
+};
+
+class LLReplayLogReal: public LLReplayLog, public LLError::Recorder
+{
+public:
+	LLReplayLogReal(LLError::ELevel level, apr_pool_t* pool):
+		mOldSettings(LLError::saveAndResetSettings()),
+		mTempFile("log", "", pool),		// create file
+		mFile(mTempFile.getName().c_str()) // open it
+	{
+		LLError::setFatalFunction(wouldHaveCrashed);
+		LLError::setDefaultLevel(level);
+		LLError::addRecorder(this);
+	}
+
+	virtual ~LLReplayLogReal()
+	{
+		LLError::removeRecorder(this);
+		LLError::restoreSettings(mOldSettings);
+	}
+
+	virtual void recordMessage(LLError::ELevel level, const std::string& message)
+	{
+		mFile << message << std::endl;
+	}
+
+	virtual void reset()
+	{
+		mFile.close();
+		mFile.open(mTempFile.getName().c_str());
+	}
+
+	virtual void replay(std::ostream& out)
+	{
+		mFile.close();
+		std::ifstream inf(mTempFile.getName().c_str());
+		std::string line;
+		while (std::getline(inf, line))
+		{
+			out << line << std::endl;
+		}
+	}
+
+private:
+	LLError::Settings* mOldSettings;
+	NamedTempFile mTempFile;
+	std::ofstream mFile;
+};
+
 class LLTestCallback : public tut::callback
 {
 public:
-	LLTestCallback(bool verbose_mode, std::ostream *stream) :
+	LLTestCallback(bool verbose_mode, std::ostream *stream,
+				   boost::shared_ptr<LLReplayLog> replayer) :
 	mVerboseMode(verbose_mode),
 	mTotalTests(0),
 	mPassedTests(0),
@@ -87,7 +150,8 @@ public:
 	mSkippedTests(0),
 	// By default, capture a shared_ptr to std::cout, with a no-op "deleter"
 	// so that destroying the shared_ptr makes no attempt to delete std::cout.
-	mStream(boost::shared_ptr<std::ostream>(&std::cout, boost::lambda::_1))
+	mStream(boost::shared_ptr<std::ostream>(&std::cout, boost::lambda::_1)),
+	mReplayer(replayer)
 	{
 		if (stream)
 		{
@@ -125,6 +189,16 @@ public:
 	virtual void test_completed(const tut::test_result& tr)
 	{
 		++mTotalTests;
+
+		// If this test failed, dump requested log messages BEFORE stating the
+		// test result.
+		if (tr.result != tut::test_result::ok && tr.result != tut::test_result::skip)
+		{
+			mReplayer->replay(*mStream);
+		}
+		// Either way, clear stored messages in preparation for next test.
+		mReplayer->reset();
+
 		std::ostringstream out;
 		out << "[" << tr.group << ", " << tr.test;
 		if (! tr.name.empty())
@@ -205,6 +279,7 @@ protected:
 	int mFailedTests;
 	int mSkippedTests;
 	boost::shared_ptr<std::ostream> mStream;
+	boost::shared_ptr<LLReplayLog> mReplayer;
 };
 
 // TeamCity specific class which emits service messages
@@ -213,8 +288,9 @@ protected:
 class LLTCTestCallback : public LLTestCallback
 {
 public:
-	LLTCTestCallback(bool verbose_mode, std::ostream *stream) :
-		LLTestCallback(verbose_mode, stream)
+	LLTCTestCallback(bool verbose_mode, std::ostream *stream,
+					 boost::shared_ptr<LLReplayLog> replayer) :
+		LLTestCallback(verbose_mode, stream, replayer)
 	{
 	}
 
@@ -355,6 +431,14 @@ void stream_usage(std::ostream& s, const char* app)
 		++option;
 	}
 
+	s << app << " is also sensitive to environment variables:\n"
+	  << "LOGTEST=level : for all tests, emit log messages at level 'level'\n"
+	  << "LOGFAIL=level : only for failed tests, emit log messages at level 'level'\n"
+	  << "where 'level' is one of ALL, DEBUG, INFO, WARN, ERROR, NONE.\n"
+	  << "--debug is like LOGTEST=DEBUG, but --debug overrides LOGTEST.\n"
+	  << "Setting LOGFAIL overrides both LOGTEST and --debug: the only log\n"
+	  << "messages you will see will be for failed tests.\n\n";
+
 	s << "Examples:" << std::endl;
 	s << "  " << app << " --verbose" << std::endl;
 	s << "\tRun all the tests and report all results." << std::endl;
@@ -391,8 +475,14 @@ int main(int argc, char **argv)
 	LLError::initForApplication(".");
 	LLError::setFatalFunction(wouldHaveCrashed);
 	LLError::setDefaultLevel(LLError::LEVEL_ERROR);
-	//< *TODO: should come from error config file. Note that we
-	// have a command line option that sets this to debug.
+	// ^ possibly overridden by --debug, LOGTEST or LOGFAIL
+
+	// LOGTEST overrides default, but can be overridden by --debug or LOGFAIL.
+	const char* LOGTEST = getenv("LOGTEST");
+	if (LOGTEST)
+	{
+		LLError::setDefaultLevel(LLError::decodeLevel(LOGTEST));
+	}
 
 #ifdef CTYPE_WORKAROUND
 	ctype_workaround();
@@ -467,8 +557,6 @@ int main(int argc, char **argv)
 				wait_at_exit = true;
 				break;
 			case 'd':
-				// *TODO: should come from error config file. We set it to
-				// ERROR by default, so this allows full debug levels.
 				LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
 				break;
 			case 'x':
@@ -483,14 +571,28 @@ int main(int argc, char **argv)
 
 	// run the tests
 
+	const char* LOGFAIL = getenv("LOGFAIL");
+	boost::shared_ptr<LLReplayLog> replayer;
+	// As described in stream_usage(), LOGFAIL overrides both --debug and
+	// LOGTEST.
+	if (LOGFAIL)
+	{
+		LLError::ELevel level = LLError::decodeLevel(LOGFAIL);
+		replayer.reset(new LLReplayLogReal(level, pool));
+	}
+	else
+	{
+		replayer.reset(new LLReplayLog());
+	}
+
 	LLTestCallback* mycallback;
 	if (getenv("TEAMCITY_PROJECT_NAME"))
 	{
-		mycallback = new LLTCTestCallback(verbose_mode, output);		
+		mycallback = new LLTCTestCallback(verbose_mode, output, replayer);
 	}
 	else
 	{
-		mycallback = new LLTestCallback(verbose_mode, output);
+		mycallback = new LLTestCallback(verbose_mode, output, replayer);
 	}
 
 	tut::runner.get().set_callback(mycallback);
-- 
cgit v1.2.3


From eb1bea222322385e6e5b05206f09f21bb891f3f7 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 23 Apr 2012 11:26:18 -0400
Subject: IQA-463: LLError::addRecorder() claims ownership of passed Recorder*.
 That is, when the underlying LLError::Settings object is destroyed --
 possibly at termination, possibly on LLError::restoreSettings() -- the passed
 Recorder* is deleted. There was much existing code that seemed as unaware of
 this alarming fact as I was myself. Passing to addRecorder() a pointer to a
 stack object, or to a member of some other object, is just Bad. It might be
 preferable to make addRecorder() accept std::auto_ptr<Recorder> to make the
 ownership transfer more explicit -- or even boost::shared_ptr<Recorder>
 instead, which would allow the caller to either forget or retain the passed
 Recorder. This preliminary pass retains the Recorder* dumb pointer API, but
 documents the ownership issue, and eliminates known instances of passing
 pointers to anything but a standalone heap Recorder subclass object.

---
 indra/test/test.cpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/test.cpp b/indra/test/test.cpp
index 128d84e428..06128e0902 100644
--- a/indra/test/test.cpp
+++ b/indra/test/test.cpp
@@ -37,6 +37,7 @@
 #include "linden_common.h"
 #include "llerrorcontrol.h"
 #include "lltut.h"
+#include "tests/wrapllerrs.h"             // RecorderProxy
 #include "stringize.h"
 #include "namedtempfile.h"
 
@@ -91,22 +92,24 @@ public:
 	virtual void replay(std::ostream&) {}
 };
 
-class LLReplayLogReal: public LLReplayLog, public LLError::Recorder
+class LLReplayLogReal: public LLReplayLog, public LLError::Recorder, public boost::noncopyable
 {
 public:
 	LLReplayLogReal(LLError::ELevel level, apr_pool_t* pool):
 		mOldSettings(LLError::saveAndResetSettings()),
+		mProxy(new RecorderProxy(this)),
 		mTempFile("log", "", pool),		// create file
 		mFile(mTempFile.getName().c_str()) // open it
 	{
 		LLError::setFatalFunction(wouldHaveCrashed);
 		LLError::setDefaultLevel(level);
-		LLError::addRecorder(this);
+		LLError::addRecorder(mProxy);
 	}
 
 	virtual ~LLReplayLogReal()
 	{
-		LLError::removeRecorder(this);
+		LLError::removeRecorder(mProxy);
+		delete mProxy;
 		LLError::restoreSettings(mOldSettings);
 	}
 
@@ -134,6 +137,7 @@ public:
 
 private:
 	LLError::Settings* mOldSettings;
+	LLError::Recorder* mProxy;
 	NamedTempFile mTempFile;
 	std::ofstream mFile;
 };
-- 
cgit v1.2.3


From 95a147dea7a8c4f2a20a2623fda0f9af5ce973ad Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 9 May 2012 23:03:37 -0400
Subject: CHOP-900: Fix test.cpp merge errors merging up to viewer-release

---
 indra/test/test.cpp | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/test.cpp b/indra/test/test.cpp
index 48f20b2e79..9d24383bcc 100644
--- a/indra/test/test.cpp
+++ b/indra/test/test.cpp
@@ -66,6 +66,7 @@
 #pragma warning (pop)
 #endif
 
+#include <boost/scoped_ptr.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/foreach.hpp>
@@ -147,17 +148,16 @@ class LLTestCallback : public tut::callback
 public:
 	LLTestCallback(bool verbose_mode, std::ostream *stream,
 				   boost::shared_ptr<LLReplayLog> replayer) :
-	mVerboseMode(verbose_mode),
-	mTotalTests(0),
-	mPassedTests(0),
-	mFailedTests(0),
-	mSkippedTests(0),
-	// By default, capture a shared_ptr to std::cout, with a no-op "deleter"
-	// so that destroying the shared_ptr makes no attempt to delete std::cout.
-	mStream(boost::shared_ptr<std::ostream>(&std::cout, boost::lambda::_1)),
-	mReplayer(replayer)
-		if (stream)
-		{
+		mVerboseMode(verbose_mode),
+		mTotalTests(0),
+		mPassedTests(0),
+		mFailedTests(0),
+		mSkippedTests(0),
+		// By default, capture a shared_ptr to std::cout, with a no-op "deleter"
+		// so that destroying the shared_ptr makes no attempt to delete std::cout.
+		mStream(boost::shared_ptr<std::ostream>(&std::cout, boost::lambda::_1)),
+		mReplayer(replayer)
+	{
 		if (stream)
 		{
 			// We want a boost::iostreams::tee_device that will stream to two
@@ -593,11 +593,11 @@ int main(int argc, char **argv)
 	LLTestCallback* mycallback;
 	if (getenv("TEAMCITY_PROJECT_NAME"))
 	{
-		mycallback = new LLTCTestCallback(verbose_mode, output, replayer);
+		mycallback = new LLTCTestCallback(verbose_mode, output.get(), replayer);
 	}
 	else
 	{
-		mycallback = new LLTestCallback(verbose_mode, output, replayer);
+		mycallback = new LLTestCallback(verbose_mode, output.get(), replayer);
 	}
 
 	tut::runner.get().set_callback(mycallback);
-- 
cgit v1.2.3


From f92e7d30a8ae4b1017968c253bb90f5eb05e1725 Mon Sep 17 00:00:00 2001
From: Oz Linden <oz@lindenlab.com>
Date: Sun, 24 Jun 2012 07:27:34 -0400
Subject: Add logging during tests (debug level, to test-specific files)

---
 indra/test/test.cpp | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/test.cpp b/indra/test/test.cpp
index e58e7293fb..abe8f4f77b 100644
--- a/indra/test/test.cpp
+++ b/indra/test/test.cpp
@@ -113,13 +113,16 @@ public:
 	virtual void run_started()
 	{
 		//std::cout << "run_started" << std::endl;
+		LL_INFOS("TestRunner")<<"Test Started"<< LL_ENDL;
 	}
 
 	virtual void group_started(const std::string& name) {
+		LL_INFOS("TestRunner")<<"Unit test group_started name=" << name << LL_ENDL;
 		*mStream << "Unit test group_started name=" << name << std::endl;
 	}
 
 	virtual void group_completed(const std::string& name) {
+		LL_INFOS("TestRunner")<<"Unit test group_completed name=" << name << LL_ENDL;
 		*mStream << "Unit test group_completed name=" << name << std::endl;
 	}
 
@@ -167,9 +170,11 @@ public:
 			if(!tr.message.empty())
 			{
 				*mStream << ": '" << tr.message << "'";
+				LL_WARNS("TestRunner") << "not ok : "<<tr.message << LL_ENDL;
 			}
 			*mStream << std::endl;
 		}
+		LL_INFOS("TestRunner")<<out.str()<<LL_ENDL;
 	}
 
 	virtual int getFailedTests() const { return mFailedTests; }
@@ -389,11 +394,14 @@ int main(int argc, char **argv)
 #ifndef LL_WINDOWS
 	::testing::InitGoogleMock(&argc, argv);
 #endif
-	LLError::initForApplication(".");
+	LLError::initForApplication(".", false /* do not log to stderr */);
 	LLError::setFatalFunction(wouldHaveCrashed);
-	LLError::setDefaultLevel(LLError::LEVEL_ERROR);
-	//< *TODO: should come from error config file. Note that we
-	// have a command line option that sets this to debug.
+	LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
+	LLError::setPrintLocation(true);
+	std::string test_app_name(argv[0]);
+	std::string test_log = test_app_name + ".log";
+	LLFile::remove(test_log);
+	LLError::logToFile(test_log);
 
 #ifdef CTYPE_WORKAROUND
 	ctype_workaround();
-- 
cgit v1.2.3


From 5c2c85c6f7f7552a184169bc5959a84efac05895 Mon Sep 17 00:00:00 2001
From: Oz Linden <oz@lindenlab.com>
Date: Tue, 26 Jun 2012 09:41:35 -0400
Subject: integrate Nats improvements to test logging with mine

---
 indra/test/test.cpp | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/test.cpp b/indra/test/test.cpp
index 8df404f16b..dc8580fe69 100644
--- a/indra/test/test.cpp
+++ b/indra/test/test.cpp
@@ -456,6 +456,13 @@ void stream_usage(std::ostream& s, const char* app)
 	s << "\tList all available test groups." << std::endl;
 	s << "  " << app << " --group=uuid" << std::endl;
 	s << "\tRun the test group 'uuid'." << std::endl;
+
+	s << "\n\n"
+	  << "In any event, logs are recorded in the build directory by appending\n"
+	  << "the suffix '.log' to the full path name of this application.\n"
+	  << "If no level is specified as described above, these log files are at\n"
+	  << "DEBUG level.\n"
+		;
 }
 
 void stream_groups(std::ostream& s, const char* app)
@@ -482,24 +489,25 @@ int main(int argc, char **argv)
 #ifndef LL_WINDOWS
 	::testing::InitGoogleMock(&argc, argv);
 #endif
-	LLError::initForApplication(".", false /* do not log to stderr */);
-	LLError::setFatalFunction(wouldHaveCrashed);
-	LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
-	// ^ possibly overridden by --debug, LOGTEST or LOGFAIL
-
 	// LOGTEST overrides default, but can be overridden by --debug or LOGFAIL.
 	const char* LOGTEST = getenv("LOGTEST");
 	if (LOGTEST)
 	{
+		LLError::initForApplication(".", true /* log to stderr */);
 		LLError::setDefaultLevel(LLError::decodeLevel(LOGTEST));
 	}
+	else
+	{
+		LLError::initForApplication(".", false /* do not log to stderr */);
+		LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
+	}	
+	LLError::setFatalFunction(wouldHaveCrashed);
 	LLError::setPrintLocation(true);
 	std::string test_app_name(argv[0]);
 	std::string test_log = test_app_name + ".log";
 	LLFile::remove(test_log);
 	LLError::logToFile(test_log);
 
-
 #ifdef CTYPE_WORKAROUND
 	ctype_workaround();
 #endif
-- 
cgit v1.2.3


From 4a5ad357930f0bede4d84b9810978e9d0c5d268b Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 20 Jul 2012 11:42:15 -0500
Subject: MAINT-570 Remove unused memory tracking system LLMemType

---
 indra/test/llbuffer_tut.cpp | 1 -
 1 file changed, 1 deletion(-)

(limited to 'indra/test')

diff --git a/indra/test/llbuffer_tut.cpp b/indra/test/llbuffer_tut.cpp
index dc1a5cdd3d..a25fdebb7f 100644
--- a/indra/test/llbuffer_tut.cpp
+++ b/indra/test/llbuffer_tut.cpp
@@ -31,7 +31,6 @@
 #include "lltut.h"
 #include "llbuffer.h"
 #include "llerror.h"
-#include "llmemtype.h"
 
 
 namespace tut
-- 
cgit v1.2.3


From 7153d1db11c00245a379fa9601f092020152ea73 Mon Sep 17 00:00:00 2001
From: Don Kjer <don@lindenlab.com>
Date: Thu, 20 Sep 2012 04:29:17 +0000
Subject: Partial rewrite of llifstream and llofstream (Windows implementation
 pending).  Moved more functionality from llviewerwearable to llwearable

---
 indra/test/llpermissions_tut.cpp | 14 +++++++-------
 indra/test/llsaleinfo_tut.cpp    |  9 +++++----
 2 files changed, 12 insertions(+), 11 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/llpermissions_tut.cpp b/indra/test/llpermissions_tut.cpp
index bf6766424c..dff8bca53f 100644
--- a/indra/test/llpermissions_tut.cpp
+++ b/indra/test/llpermissions_tut.cpp
@@ -407,7 +407,7 @@ namespace tut
 		LLFILE* fp = LLFile::fopen("linden_file.dat","w+");
 		if(!fp)
 		{
-			llerrs << "file coudnt be opened\n" << llendl;
+			llerrs << "file couldn't be opened\n" << llendl;
 			return;
 		}
 		LLPermissions perm,perm1;
@@ -425,15 +425,15 @@ namespace tut
 
 		perm.initMasks(base, ownerp, everyone, groupp, next);
 
-		perm.exportFile(fp);
+		ensure("Permissions export failed", perm.exportFile(fp));
 		fclose(fp);	
 		fp = LLFile::fopen("linden_file.dat","r+");
 		if(!fp)
 		{
-			llerrs << "file coudnt be opened\n" << llendl;
+			llerrs << "file couldn't be opened\n" << llendl;
 			return;
 		}
-		perm1.importFile(fp);
+		ensure("Permissions import failed", perm1.importFile(fp));
 		fclose(fp);
 		ensure_equals("exportFile()/importFile():failed to export and import the data ", perm1, perm);	
 }
@@ -457,11 +457,11 @@ namespace tut
 		perm.initMasks(base, ownerp, everyone, groupp, next);
 
 		std::ostringstream ostream;
-		perm.exportLegacyStream(ostream);
+		perm.exportStream(ostream);
 		std::istringstream istream(ostream.str());
-		perm1.importLegacyStream(istream);
+		perm1.importStream(istream);
 
-		ensure_equals("exportLegacyStream()/importLegacyStream():failed to export and import the data ", perm1, perm);
+		ensure_equals("exportStream()/importStream():failed to export and import the data ", perm1, perm);
 	}
 
 	template<> template<>
diff --git a/indra/test/llsaleinfo_tut.cpp b/indra/test/llsaleinfo_tut.cpp
index 09fca2abba..d546803947 100644
--- a/indra/test/llsaleinfo_tut.cpp
+++ b/indra/test/llsaleinfo_tut.cpp
@@ -146,16 +146,17 @@ namespace tut
 		LLSaleInfo llsaleinfo(LLSaleInfo::FS_ORIGINAL, sale_price);
 		
 		std::ostringstream ostream;
-		llsaleinfo.exportLegacyStream(ostream);
+		llsaleinfo.exportStream(ostream);
 		
 		std::istringstream istream(ostream.str());
 		LLSaleInfo llsaleinfo1;
 		U32 perm_mask = 0;
 		BOOL has_perm_mask = FALSE;
-		llsaleinfo1.importLegacyStream(istream, has_perm_mask, perm_mask);
+		llsaleinfo1.importStream(istream, has_perm_mask, perm_mask);
 					
-		ensure("importLegacyStream() fn failed ", llsaleinfo.getSalePrice() == llsaleinfo1.getSalePrice() &&
-										       llsaleinfo.getSaleType() == llsaleinfo1.getSaleType());		
+		ensure("importStream() fn failed ",
+			llsaleinfo.getSalePrice() == llsaleinfo1.getSalePrice() &&
+			llsaleinfo.getSaleType() == llsaleinfo1.getSaleType());
 	}
 
 	template<> template<>
-- 
cgit v1.2.3


From e97c06cf0c1b7bc81d787b54d98b8870da22166c Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 10 Oct 2012 10:45:37 -0400
Subject: On lluuidhashmap_tut<1> failure, save/reload data in temp file.
 Generating new random data on every test run makes it impossible to debug a
 test failure. While in general we do want to generate random data to
 thoroughly exercise the generator logic, if every new run generates new data,
 the only thing we can do about an observed failure is shrug and ignore it.
 Add logic to save data on failure, with corresponding logic to notice and
 reload from a previously-generated save file. In case of a merge collision,
 this version SUPERCEDES my previous efforts with this file. (My other changes
 may still be in a backed-up merge request.) It is okay to resolve collisions
 in favor of this version.

---
 indra/test/lluuidhashmap_tut.cpp | 141 +++++++++++++++++++++++++++++++++------
 1 file changed, 119 insertions(+), 22 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/lluuidhashmap_tut.cpp b/indra/test/lluuidhashmap_tut.cpp
index 0544e832ce..408bc3faf1 100644
--- a/indra/test/lluuidhashmap_tut.cpp
+++ b/indra/test/lluuidhashmap_tut.cpp
@@ -30,6 +30,10 @@
 #include "linden_common.h"
 #include "lluuidhashmap.h"
 #include "llsdserialize.h"
+#include "lldir.h"
+#include "stringize.h"
+#include <iostream>
+#include <fstream>
 
 namespace tut
 {
@@ -79,40 +83,133 @@ namespace tut
 	template<> template<>
 	void hash_index_object_t::test<1>()
 	{
-		LLUUIDHashMap<UUIDTableEntry, 32>	hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
+		set_test_name("stress test");
+		// As of 2012-10-10, I (nat) have observed sporadic failures of this
+		// test: "set/get did not work." The trouble is that since test data
+		// are randomly generated with every run, it is impossible to debug a
+		// test failure. One is left with the uneasy suspicion that
+		// LLUUID::generate() can sometimes produce duplicates even within the
+		// moderately small number requested here. Since rerunning the test
+		// generally allows it to pass, it's too easy to shrug and forget it.
+		// The following code is intended to support reproducing such test
+		// failures. The idea is that, on test failure, we save the generated
+		// data to a canonical filename in a temp directory. Then on every
+		// subsequent run, we check for that filename. If it exists, we reload
+		// that specific data rather than generating fresh data -- which
+		// should presumably reproduce the same test failure. But we inform
+		// the user that to resume normal (random) test runs, s/he need only
+		// delete that file. And since it's in a temp directory, sooner or
+		// later the system will clean it up anyway.
+		const char* tempvar = "TEMP";
+		const char* tempdir = getenv(tempvar); // Windows convention
+		if (! tempdir)
+		{
+			tempvar = "TMPDIR";
+			tempdir = getenv(tempvar); // Mac convention
+		}
+		if (! tempdir)
+		{
+			// reset tempvar to the first var we check; it's just a
+			// recommendation
+			tempvar = "TEMP";
+			tempdir = "/tmp";		// Posix in general
+		}
+		std::string savefile(gDirUtilp->add(tempdir, "lluuidhashmap_tut.save.txt"));
 		const int numElementsToCheck = 32*256*32;
-		std::vector<LLUUID> idList(numElementsToCheck);
-		int i;
-		
-		for (i = 0; i < numElementsToCheck; i++)
+		std::vector<LLUUID> idList;
+		if (gDirUtilp->fileExists(savefile))
 		{
-			LLUUID id;
-			id.generate();
-			UUIDTableEntry entry(id, i);
-			hashTable.set(id, entry);
-			idList[i] = id;
+			// We have saved data from a previous failed run. Reload that data.
+			std::ifstream inf(savefile.c_str());
+			if (! inf.is_open())
+			{
+				fail(STRINGIZE("Although save file '" << savefile << "' exists, it cannot be opened"));
+			}
+			std::string item;
+			while (std::getline(inf, item))
+			{
+				idList.push_back(LLUUID(item));
+			}
+			std::cout << "Reloaded " << idList.size() << " items from '" << savefile << "'";
+			if (idList.size() != numElementsToCheck)
+			{
+				std::cout << " (expected " << numElementsToCheck << ")";
+			}
+			std::cout << " -- delete this file to generate new data" << std::endl;
+		}
+		else
+		{
+			// savefile does not exist (normal case): regenerate idList from
+			// scratch.
+			for (int i = 0; i < numElementsToCheck; ++i)
+			{
+				LLUUID id;
+				id.generate();
+				idList.push_back(id);
+			}
 		}
 
-		for (i = 0; i < numElementsToCheck; i++)
+		LLUUIDHashMap<UUIDTableEntry, 32>	hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
+		int i;
+		
+		for (i = 0; i < idList.size(); ++i)
 		{
-			LLUUID idToCheck = idList[i];
-			UUIDTableEntry entryToCheck = hashTable.get(idToCheck);
-			ensure("set/get did not work", entryToCheck.getID() == idToCheck && entryToCheck.getValue() == (size_t)i);
+			UUIDTableEntry entry(idList[i], i);
+			hashTable.set(idList[i], entry);
 		}
 
-		for (i = 0; i < numElementsToCheck; i++)
+		try
 		{
-			LLUUID idToCheck = idList[i];
-			if (i % 2 != 0)
+			for (i = 0; i < idList.size(); i++)
 			{
-				hashTable.remove(idToCheck);
+				LLUUID idToCheck = idList[i];
+				UUIDTableEntry entryToCheck = hashTable.get(idToCheck);
+				ensure_equals(STRINGIZE("set/get ID (entry " << i << ")").c_str(),
+							  entryToCheck.getID(), idToCheck);
+				ensure_equals(STRINGIZE("set/get value (ID " << idToCheck << ")").c_str(),
+							  entryToCheck.getValue(), (size_t)i);
 			}
-		}
 
-		for (i = 0; i < numElementsToCheck; i++)
+			for (i = 0; i < idList.size(); i++)
+			{
+				LLUUID idToCheck = idList[i];
+				if (i % 2 != 0)
+				{
+					hashTable.remove(idToCheck);
+				}
+			}
+
+			for (i = 0; i < idList.size(); i++)
+			{
+				LLUUID idToCheck = idList[i];
+				ensure("remove or check did not work", (i % 2 == 0 && hashTable.check(idToCheck)) || (i % 2 != 0 && !hashTable.check(idToCheck)));
+			}
+		}
+		catch (const failure&)
 		{
-			LLUUID idToCheck = idList[i];
-			ensure("remove or check did not work", (i % 2 == 0 && hashTable.check(idToCheck)) || (i % 2 != 0 && !hashTable.check(idToCheck)));
+			// One of the above tests failed. Try to save idList to repro with
+			// a later run.
+			std::ofstream outf(savefile.c_str());
+			if (! outf.is_open())
+			{
+				// Sigh, don't use fail() here because we want to preserve
+				// the original test failure.
+				std::cout << "Cannot open file '" << savefile
+						  << "' to save data -- check and fix " << tempvar << std::endl;
+			}
+			else
+			{
+				// outf.is_open()
+				for (int i = 0; i < idList.size(); ++i)
+				{
+					outf << idList[i] << std::endl;
+				}
+				std::cout << "Saved " << idList.size() << " entries to '" << savefile
+						  << "' -- rerun test to debug with these" << std::endl;
+			}
+			// re-raise the same exception -- we WANT this test failure to
+			// be reported! We just needed to save the data on the way out.
+			throw;
 		}
 	}
 
-- 
cgit v1.2.3


From c06c35609c6683731eaea283468f6b32af18fea2 Mon Sep 17 00:00:00 2001
From: Don Kjer <don@lindenlab.com>
Date: Thu, 11 Oct 2012 00:09:04 +0000
Subject: Updating linux build to gcc4.6

---
 indra/test/CMakeLists.txt                   |  4 +++
 indra/test/io.cpp                           |  8 ++---
 indra/test/llstreamtools_tut.cpp            | 53 +++++++++++++----------------
 indra/test/lltemplatemessagebuilder_tut.cpp |  3 +-
 4 files changed, 33 insertions(+), 35 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/CMakeLists.txt b/indra/test/CMakeLists.txt
index 816f1d7175..31e1d89c68 100644
--- a/indra/test/CMakeLists.txt
+++ b/indra/test/CMakeLists.txt
@@ -28,6 +28,10 @@ include_directories(
     ${GOOGLEMOCK_INCLUDE_DIRS}
     ${TUT_INCLUDE_DIR}
     )
+include_directories(SYSTEM
+    ${LLCOMMON_SYSTEM_INCLUDE_DIRS}
+    ${LLXML_SYSTEM_INCLUDE_DIRS}
+    )
 
 set(test_SOURCE_FILES
     io.cpp
diff --git a/indra/test/io.cpp b/indra/test/io.cpp
index ce747f667d..47a67deed0 100644
--- a/indra/test/io.cpp
+++ b/indra/test/io.cpp
@@ -1140,7 +1140,7 @@ namespace tut
 		bool connected = client->blockingConnect(server_host);
 		ensure("Connected to server", connected);
 		lldebugs << "connected" << llendl;
-		F32 elapsed = pump_loop(mPump,0.1f);
+		pump_loop(mPump,0.1f);
 		count = mPump->runningChains();
 		ensure_equals("server chain onboard", count, 2);
 		lldebugs << "** Client is connected." << llendl;
@@ -1156,20 +1156,20 @@ namespace tut
 		chain.clear();
 
 		// pump for a bit and make sure all 3 chains are running
-		elapsed = pump_loop(mPump,0.1f);
+		pump_loop(mPump,0.1f);
 		count = mPump->runningChains();
 		ensure_equals("client chain onboard", count, 3);
 		lldebugs << "** request should have been sent." << llendl;
 
 		// pump for long enough the the client socket closes, and the
 		// server socket should not be closed yet.
-		elapsed = pump_loop(mPump,0.2f);
+		pump_loop(mPump,0.2f);
 		count = mPump->runningChains();
 		ensure_equals("client chain timed out ", count, 2);
 		lldebugs << "** client chain should be closed." << llendl;
 
 		// At this point, the socket should be closed by the timeout
-		elapsed = pump_loop(mPump,1.0f);
+		pump_loop(mPump,1.0f);
 		count = mPump->runningChains();
 		ensure_equals("accepted socked close", count, 1);
 		lldebugs << "** Sleeper should have timed out.." << llendl;
diff --git a/indra/test/llstreamtools_tut.cpp b/indra/test/llstreamtools_tut.cpp
index a93f2e8f65..0f6436f0f4 100644
--- a/indra/test/llstreamtools_tut.cpp
+++ b/indra/test/llstreamtools_tut.cpp
@@ -385,16 +385,15 @@ namespace tut
 		std::string expected_result;
 		std::string actual_result;
 		std::istringstream is;
-		bool ret;
 
 		is.clear();
 		is.str(str = "  First Second \t \r  \n Third  Fourth-ShouldThisBePartOfFourth  Fifth\n");
 		actual_result = "";
-		ret = get_word(actual_result, is); // First
+		get_word(actual_result, is); // First
 		actual_result = "";
-		ret = get_word(actual_result, is); // Second
+		get_word(actual_result, is); // Second
 		actual_result = "";
-		ret = get_word(actual_result, is); // Third
+		get_word(actual_result, is); // Third
 
 		// the current implementation of get_word seems inconsistent with
 		// skip_to_next_word. skip_to_next_word treats any character other
@@ -403,22 +402,22 @@ namespace tut
 		// carriage  return ('\r'), horizontal tab ('\t'), and vertical tab ('\v')
 		// as delimiters 
 		actual_result = "";
-		ret = get_word(actual_result, is); // will copy Fourth-ShouldThisBePartOfFourth
+		get_word(actual_result, is); // will copy Fourth-ShouldThisBePartOfFourth
 
 		actual_result = "";
-		ret = get_word(actual_result, is); // will copy Fifth
+		get_word(actual_result, is); // will copy Fifth
 
 		is.clear();
 		is.str(str = "  First Second \t \r  \n Third  Fourth_ShouldThisBePartOfFourth Fifth\n");
-		ret = skip_to_next_word(is);  // should now point to First
-		ret = skip_to_next_word(is);  // should now point to Second
-		ret = skip_to_next_word(is);  // should now point to Third
-		ret = skip_to_next_word(is);  // should now point to Fourth
-		ret = skip_to_next_word(is);  // should now point to ShouldThisBePartOfFourth
+		skip_to_next_word(is);  // should now point to First
+		skip_to_next_word(is);  // should now point to Second
+		skip_to_next_word(is);  // should now point to Third
+		skip_to_next_word(is);  // should now point to Fourth
+		skip_to_next_word(is);  // should now point to ShouldThisBePartOfFourth
 		expected_result = "";
 		// will copy ShouldThisBePartOfFourth, the fifth word, 
 		// while using get_word above five times result in getting "Fifth"
-		ret = get_word(expected_result, is); 
+		get_word(expected_result, is); 
 		ensure_equals("get_word: skip_to_next_word compatibility", actual_result, expected_result);
 	}
 
@@ -480,39 +479,38 @@ namespace tut
 		std::string expected_result;
 		std::string actual_result;
 		std::istringstream is;
-		bool ret;
 
 		is.clear();
 		is.str(str = "First Second \t \r\n Third  Fourth-ShouldThisBePartOfFourth  IsThisFifth\n");
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = "First Second \t \r\n";
 		ensure_equals("get_line: 1", actual_result, expected_result);
 
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = " Third  Fourth-ShouldThisBePartOfFourth  IsThisFifth\n";
 		ensure_equals("get_line: 2", actual_result, expected_result);
 
 		is.clear();
 		is.str(str = "\nFirst Line.\n\nSecond Line.\n");
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = "\n";
 		ensure_equals("get_line: First char as newline", actual_result, expected_result);
 
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = "First Line.\n";
 		ensure_equals("get_line: 3", actual_result, expected_result);
 
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = "\n";
 		ensure_equals("get_line: 4", actual_result, expected_result);
 
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = "Second Line.\n";
 		ensure_equals("get_line: 5", actual_result, expected_result);
 	}	
@@ -544,13 +542,12 @@ namespace tut
 		std::string expected_result;
 		std::string actual_result;
 		std::istringstream is;
-		bool ret;
 
 		// need to be check if this test case is wrong or the implementation is wrong.
 		is.clear();
 		is.str(str = "Should not skip lone \r.\r\n");
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = "Should not skip lone \r.\r\n";
 		ensure_equals("get_line: carriage return skipped even though not followed by newline", actual_result, expected_result);
 	}
@@ -563,12 +560,11 @@ namespace tut
 		std::string expected_result;
 		std::string actual_result;
 		std::istringstream is;
-		bool ret;
 
 		is.clear();
 		is.str(str = "\n");
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = "\n";
 		ensure_equals("get_line: Just newline", actual_result, expected_result);
 	}
@@ -582,36 +578,35 @@ namespace tut
 		std::string expected_result;
 		std::string actual_result;
 		std::istringstream is;
-		bool ret;
 
 		is.clear();
 		is.str(str = "First Line.\nSecond Line.\n");
 		actual_result = "";
-		ret = get_line(actual_result, is, 255);
+		get_line(actual_result, is, 255);
 		expected_result = "First Line.\n";
 		ensure_equals("get_line: Basic Operation", actual_result, expected_result);
 
 		actual_result = "";
-		ret = get_line(actual_result, is, sizeof("Second")-1);
+		get_line(actual_result, is, sizeof("Second")-1);
 		expected_result = "Second\n";
 		ensure_equals("get_line: Insufficient length 1", actual_result, expected_result);
 
 		actual_result = "";
-		ret = get_line(actual_result, is, 255);
+		get_line(actual_result, is, 255);
 		expected_result = " Line.\n";
 		ensure_equals("get_line: Remainder after earlier insufficient length", actual_result, expected_result);
 
 		is.clear();
 		is.str(str = "One Line only with no newline with limited length");
 		actual_result = "";
-		ret = get_line(actual_result, is, sizeof("One Line only with no newline with limited length")-1);
+		get_line(actual_result, is, sizeof("One Line only with no newline with limited length")-1);
 		expected_result = "One Line only with no newline with limited length\n";
 		ensure_equals("get_line: No newline with limited length", actual_result, expected_result);
 
 		is.clear();
 		is.str(str = "One Line only with no newline");
 		actual_result = "";
-		ret = get_line(actual_result, is, 255);
+		get_line(actual_result, is, 255);
 		expected_result = "One Line only with no newline";
 		ensure_equals("get_line: No newline", actual_result, expected_result);
 	}
diff --git a/indra/test/lltemplatemessagebuilder_tut.cpp b/indra/test/lltemplatemessagebuilder_tut.cpp
index 6e1c82bb24..6c0b70edd2 100644
--- a/indra/test/lltemplatemessagebuilder_tut.cpp
+++ b/indra/test/lltemplatemessagebuilder_tut.cpp
@@ -937,7 +937,7 @@ namespace tut
 		// build message with single block
 		LLMessageTemplate messageTemplate = defaultTemplate();
 		messageTemplate.addBlock(defaultBlock(MVT_U32, 4, MBT_SINGLE));
-		U32 outValue, outValue2, inValue = 0xbbbbbbbb;
+		U32 outValue, inValue = 0xbbbbbbbb;
 		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
 		builder->addU32(_PREHASH_Test0, inValue);
 		const U32 bufferSize = 1024;
@@ -962,7 +962,6 @@ namespace tut
 		memset(buffer, 0xcc, bufferSize);
 		reader->getString(_PREHASH_Test1, _PREHASH_Test0, bufferSize, 
 						  outBuffer);
-		outValue2 = reader->getNumberOfBlocks(_PREHASH_Test1);
 		ensure_equals("Ensure present value ", outValue, inValue);
 		ensure_equals("Ensure unchanged buffer ", strlen(outBuffer), 0);
 		delete reader;
-- 
cgit v1.2.3


From 5ade41c09d08ac8fe3438df2b0cede0e1d82342b Mon Sep 17 00:00:00 2001
From: Oz Linden <oz@lindenlab.com>
Date: Thu, 31 Jan 2013 09:34:00 -0500
Subject: disable timing sensitive check in the pipe and pump fitness test

---
 indra/test/io.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/test')

diff --git a/indra/test/io.cpp b/indra/test/io.cpp
index ce747f667d..406e2d7bef 100644
--- a/indra/test/io.cpp
+++ b/indra/test/io.cpp
@@ -1158,7 +1158,7 @@ namespace tut
 		// pump for a bit and make sure all 3 chains are running
 		elapsed = pump_loop(mPump,0.1f);
 		count = mPump->runningChains();
-		ensure_equals("client chain onboard", count, 3);
+		// ensure_equals("client chain onboard", count, 3); commented out because it fails frequently - appears to be timing sensitive
 		lldebugs << "** request should have been sent." << llendl;
 
 		// pump for long enough the the client socket closes, and the
-- 
cgit v1.2.3


From 8a2c30b388a190e24d9c886fdaa9a7b83179f194 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 19 Dec 2012 06:40:44 -0500
Subject: MAINT-1986: in TeamCity, do not reload saved hashmap_test data. Rev
 b7fd7c95c571 allows a developer to debug a failure in hashmap_test 1. Once
 the test fails, rerunning that test will replay the same failure to try to
 permit debugging it. But that behavior is extremely undesirable under
 TeamCity! In a TeamCity run, don't even check for saved data file.

---
 indra/test/lluuidhashmap_tut.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/lluuidhashmap_tut.cpp b/indra/test/lluuidhashmap_tut.cpp
index 408bc3faf1..9712a613f4 100644
--- a/indra/test/lluuidhashmap_tut.cpp
+++ b/indra/test/lluuidhashmap_tut.cpp
@@ -117,9 +117,10 @@ namespace tut
 		std::string savefile(gDirUtilp->add(tempdir, "lluuidhashmap_tut.save.txt"));
 		const int numElementsToCheck = 32*256*32;
 		std::vector<LLUUID> idList;
-		if (gDirUtilp->fileExists(savefile))
+		if ((! getenv("TEAMCITY_PROJECT_NAME")) && gDirUtilp->fileExists(savefile))
 		{
-			// We have saved data from a previous failed run. Reload that data.
+			// This is not a TeamCity build, and we have saved data from a
+			// previous failed run. Reload that data.
 			std::ifstream inf(savefile.c_str());
 			if (! inf.is_open())
 			{
@@ -139,8 +140,8 @@ namespace tut
 		}
 		else
 		{
-			// savefile does not exist (normal case): regenerate idList from
-			// scratch.
+			// This is a TeamCity build, or (normal case) savefile does not
+			// exist: regenerate idList from scratch.
 			for (int i = 0; i < numElementsToCheck; ++i)
 			{
 				LLUUID id;
-- 
cgit v1.2.3


From 19233999edfd143d0e7f8e3743dc07455d206172 Mon Sep 17 00:00:00 2001
From: Oz Linden <oz@lindenlab.com>
Date: Thu, 31 Jan 2013 09:34:00 -0500
Subject: disable timing sensitive check in the pipe and pump fitness test

---
 indra/test/io.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/test')

diff --git a/indra/test/io.cpp b/indra/test/io.cpp
index ce747f667d..406e2d7bef 100644
--- a/indra/test/io.cpp
+++ b/indra/test/io.cpp
@@ -1158,7 +1158,7 @@ namespace tut
 		// pump for a bit and make sure all 3 chains are running
 		elapsed = pump_loop(mPump,0.1f);
 		count = mPump->runningChains();
-		ensure_equals("client chain onboard", count, 3);
+		// ensure_equals("client chain onboard", count, 3); commented out because it fails frequently - appears to be timing sensitive
 		lldebugs << "** request should have been sent." << llendl;
 
 		// pump for long enough the the client socket closes, and the
-- 
cgit v1.2.3


From 46ab23c94be164cb174a97bde11cc38067f9edd0 Mon Sep 17 00:00:00 2001
From: prep <prep@lindenlab.com>
Date: Mon, 11 Mar 2013 18:02:16 -0400
Subject: llinventory merge fixes

---
 indra/test/llpermissions_tut.cpp | 4 ++--
 indra/test/llsaleinfo_tut.cpp    | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/llpermissions_tut.cpp b/indra/test/llpermissions_tut.cpp
index dff8bca53f..bc2c87ba46 100644
--- a/indra/test/llpermissions_tut.cpp
+++ b/indra/test/llpermissions_tut.cpp
@@ -457,9 +457,9 @@ namespace tut
 		perm.initMasks(base, ownerp, everyone, groupp, next);
 
 		std::ostringstream ostream;
-		perm.exportStream(ostream);
+		perm.exportLegacyStream(ostream);
 		std::istringstream istream(ostream.str());
-		perm1.importStream(istream);
+		perm1.importLegacyStream(istream);
 
 		ensure_equals("exportStream()/importStream():failed to export and import the data ", perm1, perm);
 	}
diff --git a/indra/test/llsaleinfo_tut.cpp b/indra/test/llsaleinfo_tut.cpp
index d546803947..2689eaa15e 100644
--- a/indra/test/llsaleinfo_tut.cpp
+++ b/indra/test/llsaleinfo_tut.cpp
@@ -146,13 +146,13 @@ namespace tut
 		LLSaleInfo llsaleinfo(LLSaleInfo::FS_ORIGINAL, sale_price);
 		
 		std::ostringstream ostream;
-		llsaleinfo.exportStream(ostream);
+		llsaleinfo.exportLegacyStream(ostream);
 		
 		std::istringstream istream(ostream.str());
 		LLSaleInfo llsaleinfo1;
 		U32 perm_mask = 0;
 		BOOL has_perm_mask = FALSE;
-		llsaleinfo1.importStream(istream, has_perm_mask, perm_mask);
+		llsaleinfo1.importLegacyStream(istream, has_perm_mask, perm_mask);
 					
 		ensure("importStream() fn failed ",
 			llsaleinfo.getSalePrice() == llsaleinfo1.getSalePrice() &&
-- 
cgit v1.2.3


From e8b8a12b7365c17cf0326be365b78bcb1da1bfac Mon Sep 17 00:00:00 2001
From: Graham Madarasz <graham@lindenlab.com>
Date: Tue, 12 Mar 2013 10:48:05 -0700
Subject: Mods to make compile on gcc 4.6.3 work mo betta

---
 indra/test/io.cpp                           | 1 +
 indra/test/llstreamtools_tut.cpp            | 8 +++++++-
 indra/test/lltemplatemessagebuilder_tut.cpp | 2 ++
 3 files changed, 10 insertions(+), 1 deletion(-)

(limited to 'indra/test')

diff --git a/indra/test/io.cpp b/indra/test/io.cpp
index ce747f667d..7f26ac6724 100644
--- a/indra/test/io.cpp
+++ b/indra/test/io.cpp
@@ -1141,6 +1141,7 @@ namespace tut
 		ensure("Connected to server", connected);
 		lldebugs << "connected" << llendl;
 		F32 elapsed = pump_loop(mPump,0.1f);
+		(void)elapsed;
 		count = mPump->runningChains();
 		ensure_equals("server chain onboard", count, 2);
 		lldebugs << "** Client is connected." << llendl;
diff --git a/indra/test/llstreamtools_tut.cpp b/indra/test/llstreamtools_tut.cpp
index a93f2e8f65..68e56b5ee2 100644
--- a/indra/test/llstreamtools_tut.cpp
+++ b/indra/test/llstreamtools_tut.cpp
@@ -386,15 +386,17 @@ namespace tut
 		std::string actual_result;
 		std::istringstream is;
 		bool ret;
-
 		is.clear();
 		is.str(str = "  First Second \t \r  \n Third  Fourth-ShouldThisBePartOfFourth  Fifth\n");
 		actual_result = "";
 		ret = get_word(actual_result, is); // First
+		(void)ret;
 		actual_result = "";
 		ret = get_word(actual_result, is); // Second
+		(void)ret;
 		actual_result = "";
 		ret = get_word(actual_result, is); // Third
+		(void)ret;
 
 		// the current implementation of get_word seems inconsistent with
 		// skip_to_next_word. skip_to_next_word treats any character other
@@ -486,6 +488,7 @@ namespace tut
 		is.str(str = "First Second \t \r\n Third  Fourth-ShouldThisBePartOfFourth  IsThisFifth\n");
 		actual_result = "";
 		ret = get_line(actual_result, is);
+		(void)ret;
 		expected_result = "First Second \t \r\n";
 		ensure_equals("get_line: 1", actual_result, expected_result);
 
@@ -551,6 +554,7 @@ namespace tut
 		is.str(str = "Should not skip lone \r.\r\n");
 		actual_result = "";
 		ret = get_line(actual_result, is);
+		(void)ret;
 		expected_result = "Should not skip lone \r.\r\n";
 		ensure_equals("get_line: carriage return skipped even though not followed by newline", actual_result, expected_result);
 	}
@@ -569,6 +573,7 @@ namespace tut
 		is.str(str = "\n");
 		actual_result = "";
 		ret = get_line(actual_result, is);
+		(void)ret;
 		expected_result = "\n";
 		ensure_equals("get_line: Just newline", actual_result, expected_result);
 	}
@@ -588,6 +593,7 @@ namespace tut
 		is.str(str = "First Line.\nSecond Line.\n");
 		actual_result = "";
 		ret = get_line(actual_result, is, 255);
+		(void)ret;
 		expected_result = "First Line.\n";
 		ensure_equals("get_line: Basic Operation", actual_result, expected_result);
 
diff --git a/indra/test/lltemplatemessagebuilder_tut.cpp b/indra/test/lltemplatemessagebuilder_tut.cpp
index 6e1c82bb24..0aad3cbc15 100644
--- a/indra/test/lltemplatemessagebuilder_tut.cpp
+++ b/indra/test/lltemplatemessagebuilder_tut.cpp
@@ -958,11 +958,13 @@ namespace tut
 		reader->validateMessage(buffer, builtSize, LLHost());
 		reader->readMessage(buffer, LLHost());
 		reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outValue);
+		(void)outValue;
 		char outBuffer[bufferSize];
 		memset(buffer, 0xcc, bufferSize);
 		reader->getString(_PREHASH_Test1, _PREHASH_Test0, bufferSize, 
 						  outBuffer);
 		outValue2 = reader->getNumberOfBlocks(_PREHASH_Test1);
+		(void)outValue2;
 		ensure_equals("Ensure present value ", outValue, inValue);
 		ensure_equals("Ensure unchanged buffer ", strlen(outBuffer), 0);
 		delete reader;
-- 
cgit v1.2.3


From bf6182daa8b4d7cea79310547f71d7a3155e17b0 Mon Sep 17 00:00:00 2001
From: Graham Madarasz <graham@lindenlab.com>
Date: Fri, 29 Mar 2013 07:50:08 -0700
Subject: Update Mac and Windows breakpad builds to latest

---
 indra/test/CMakeLists.txt                   |   0
 indra/test/blowfish.1.bin                   |   0
 indra/test/blowfish.2.bin                   | Bin
 indra/test/blowfish.digits.txt              |   0
 indra/test/catch_and_store_what_in.h        |   0
 indra/test/debug.h                          |   0
 indra/test/io.cpp                           |   0
 indra/test/llapp_tut.cpp                    |   0
 indra/test/llassetuploadqueue_tut.cpp       |   0
 indra/test/llblowfish_tut.cpp               |   0
 indra/test/llbuffer_tut.cpp                 |   0
 indra/test/lldatapacker_tut.cpp             |   0
 indra/test/lldoubledispatch_tut.cpp         |   0
 indra/test/llevents_tut.cpp                 |   0
 indra/test/llhttpdate_tut.cpp               |   0
 indra/test/llhttpnode_tut.cpp               |   0
 indra/test/lliohttpserver_tut.cpp           |   0
 indra/test/llmessageconfig_tut.cpp          |   0
 indra/test/llmessagetemplateparser_tut.cpp  |   0
 indra/test/llpermissions_tut.cpp            |   0
 indra/test/llpipeutil.cpp                   |   0
 indra/test/llpipeutil.h                     |   0
 indra/test/llsaleinfo_tut.cpp               |   0
 indra/test/llscriptresource_tut.cpp         |   0
 indra/test/llsd_new_tut.cpp                 |   0
 indra/test/llsdmessagebuilder_tut.cpp       |   0
 indra/test/llsdmessagereader_tut.cpp        |   0
 indra/test/llsdtraits.h                     |   0
 indra/test/llsdutil_tut.cpp                 |   0
 indra/test/llservicebuilder_tut.cpp         |   0
 indra/test/llstreamtools_tut.cpp            |   0
 indra/test/lltemplatemessagebuilder_tut.cpp |   0
 indra/test/lltimestampcache_tut.cpp         |   0
 indra/test/lltranscode_tut.cpp              |   0
 indra/test/lltut.cpp                        |   0
 indra/test/lltut.h                          |   0
 indra/test/lluserrelations_tut.cpp          |   0
 indra/test/lluuidhashmap_tut.cpp            |   0
 indra/test/llxorcipher_tut.cpp              |   0
 indra/test/manageapr.h                      |   0
 indra/test/message_tut.cpp                  |   0
 indra/test/mock_http_client.cpp             |   0
 indra/test/mock_http_client.h               |   0
 indra/test/namedtempfile.h                  |   0
 indra/test/prim_linkability_tut.cpp         |   0
 indra/test/test.cpp                         |   0
 indra/test/test.h                           |   0
 indra/test/test_llmanifest.py               |   0
 48 files changed, 0 insertions(+), 0 deletions(-)
 mode change 100644 => 100755 indra/test/CMakeLists.txt
 mode change 100644 => 100755 indra/test/blowfish.1.bin
 mode change 100644 => 100755 indra/test/blowfish.2.bin
 mode change 100644 => 100755 indra/test/blowfish.digits.txt
 mode change 100644 => 100755 indra/test/catch_and_store_what_in.h
 mode change 100644 => 100755 indra/test/debug.h
 mode change 100644 => 100755 indra/test/io.cpp
 mode change 100644 => 100755 indra/test/llapp_tut.cpp
 mode change 100644 => 100755 indra/test/llassetuploadqueue_tut.cpp
 mode change 100644 => 100755 indra/test/llblowfish_tut.cpp
 mode change 100644 => 100755 indra/test/llbuffer_tut.cpp
 mode change 100644 => 100755 indra/test/lldatapacker_tut.cpp
 mode change 100644 => 100755 indra/test/lldoubledispatch_tut.cpp
 mode change 100644 => 100755 indra/test/llevents_tut.cpp
 mode change 100644 => 100755 indra/test/llhttpdate_tut.cpp
 mode change 100644 => 100755 indra/test/llhttpnode_tut.cpp
 mode change 100644 => 100755 indra/test/lliohttpserver_tut.cpp
 mode change 100644 => 100755 indra/test/llmessageconfig_tut.cpp
 mode change 100644 => 100755 indra/test/llmessagetemplateparser_tut.cpp
 mode change 100644 => 100755 indra/test/llpermissions_tut.cpp
 mode change 100644 => 100755 indra/test/llpipeutil.cpp
 mode change 100644 => 100755 indra/test/llpipeutil.h
 mode change 100644 => 100755 indra/test/llsaleinfo_tut.cpp
 mode change 100644 => 100755 indra/test/llscriptresource_tut.cpp
 mode change 100644 => 100755 indra/test/llsd_new_tut.cpp
 mode change 100644 => 100755 indra/test/llsdmessagebuilder_tut.cpp
 mode change 100644 => 100755 indra/test/llsdmessagereader_tut.cpp
 mode change 100644 => 100755 indra/test/llsdtraits.h
 mode change 100644 => 100755 indra/test/llsdutil_tut.cpp
 mode change 100644 => 100755 indra/test/llservicebuilder_tut.cpp
 mode change 100644 => 100755 indra/test/llstreamtools_tut.cpp
 mode change 100644 => 100755 indra/test/lltemplatemessagebuilder_tut.cpp
 mode change 100644 => 100755 indra/test/lltimestampcache_tut.cpp
 mode change 100644 => 100755 indra/test/lltranscode_tut.cpp
 mode change 100644 => 100755 indra/test/lltut.cpp
 mode change 100644 => 100755 indra/test/lltut.h
 mode change 100644 => 100755 indra/test/lluserrelations_tut.cpp
 mode change 100644 => 100755 indra/test/lluuidhashmap_tut.cpp
 mode change 100644 => 100755 indra/test/llxorcipher_tut.cpp
 mode change 100644 => 100755 indra/test/manageapr.h
 mode change 100644 => 100755 indra/test/message_tut.cpp
 mode change 100644 => 100755 indra/test/mock_http_client.cpp
 mode change 100644 => 100755 indra/test/mock_http_client.h
 mode change 100644 => 100755 indra/test/namedtempfile.h
 mode change 100644 => 100755 indra/test/prim_linkability_tut.cpp
 mode change 100644 => 100755 indra/test/test.cpp
 mode change 100644 => 100755 indra/test/test.h
 mode change 100644 => 100755 indra/test/test_llmanifest.py

(limited to 'indra/test')

diff --git a/indra/test/CMakeLists.txt b/indra/test/CMakeLists.txt
old mode 100644
new mode 100755
diff --git a/indra/test/blowfish.1.bin b/indra/test/blowfish.1.bin
old mode 100644
new mode 100755
diff --git a/indra/test/blowfish.2.bin b/indra/test/blowfish.2.bin
old mode 100644
new mode 100755
diff --git a/indra/test/blowfish.digits.txt b/indra/test/blowfish.digits.txt
old mode 100644
new mode 100755
diff --git a/indra/test/catch_and_store_what_in.h b/indra/test/catch_and_store_what_in.h
old mode 100644
new mode 100755
diff --git a/indra/test/debug.h b/indra/test/debug.h
old mode 100644
new mode 100755
diff --git a/indra/test/io.cpp b/indra/test/io.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llapp_tut.cpp b/indra/test/llapp_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llassetuploadqueue_tut.cpp b/indra/test/llassetuploadqueue_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llblowfish_tut.cpp b/indra/test/llblowfish_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llbuffer_tut.cpp b/indra/test/llbuffer_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/lldatapacker_tut.cpp b/indra/test/lldatapacker_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/lldoubledispatch_tut.cpp b/indra/test/lldoubledispatch_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llevents_tut.cpp b/indra/test/llevents_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llhttpdate_tut.cpp b/indra/test/llhttpdate_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llhttpnode_tut.cpp b/indra/test/llhttpnode_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/lliohttpserver_tut.cpp b/indra/test/lliohttpserver_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llmessageconfig_tut.cpp b/indra/test/llmessageconfig_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llmessagetemplateparser_tut.cpp b/indra/test/llmessagetemplateparser_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llpermissions_tut.cpp b/indra/test/llpermissions_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llpipeutil.cpp b/indra/test/llpipeutil.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llpipeutil.h b/indra/test/llpipeutil.h
old mode 100644
new mode 100755
diff --git a/indra/test/llsaleinfo_tut.cpp b/indra/test/llsaleinfo_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llscriptresource_tut.cpp b/indra/test/llscriptresource_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llsd_new_tut.cpp b/indra/test/llsd_new_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llsdmessagebuilder_tut.cpp b/indra/test/llsdmessagebuilder_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llsdmessagereader_tut.cpp b/indra/test/llsdmessagereader_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llsdtraits.h b/indra/test/llsdtraits.h
old mode 100644
new mode 100755
diff --git a/indra/test/llsdutil_tut.cpp b/indra/test/llsdutil_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llservicebuilder_tut.cpp b/indra/test/llservicebuilder_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llstreamtools_tut.cpp b/indra/test/llstreamtools_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/lltemplatemessagebuilder_tut.cpp b/indra/test/lltemplatemessagebuilder_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/lltimestampcache_tut.cpp b/indra/test/lltimestampcache_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/lltranscode_tut.cpp b/indra/test/lltranscode_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/lltut.cpp b/indra/test/lltut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/lltut.h b/indra/test/lltut.h
old mode 100644
new mode 100755
diff --git a/indra/test/lluserrelations_tut.cpp b/indra/test/lluserrelations_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/lluuidhashmap_tut.cpp b/indra/test/lluuidhashmap_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/llxorcipher_tut.cpp b/indra/test/llxorcipher_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/manageapr.h b/indra/test/manageapr.h
old mode 100644
new mode 100755
diff --git a/indra/test/message_tut.cpp b/indra/test/message_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/mock_http_client.cpp b/indra/test/mock_http_client.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/mock_http_client.h b/indra/test/mock_http_client.h
old mode 100644
new mode 100755
diff --git a/indra/test/namedtempfile.h b/indra/test/namedtempfile.h
old mode 100644
new mode 100755
diff --git a/indra/test/prim_linkability_tut.cpp b/indra/test/prim_linkability_tut.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/test.cpp b/indra/test/test.cpp
old mode 100644
new mode 100755
diff --git a/indra/test/test.h b/indra/test/test.h
old mode 100644
new mode 100755
diff --git a/indra/test/test_llmanifest.py b/indra/test/test_llmanifest.py
old mode 100644
new mode 100755
-- 
cgit v1.2.3


From b7235f1a4492bf4365d241e239eb49fb3ae8bb3e Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 22 Apr 2013 14:35:07 -0400
Subject: MAINT-2612: Remove no-longer-valid unused-var warning suppressions.
 Somehow viewer-cat acquired a lot of source lines (in several different
 files) of the form:     (void)somevar; where ?somevar? was not declared.
 Apparently someone introduced an unused declaration of ?somevar?, encountered
 unused-variable warnings, introduced the (void) casts to suppress those
 warnings, then deleted the declarations -- without deleting the (void) casts.
 It seems worth noting that the resulting code should not have compiled
 successfully on any platform.

---
 indra/test/io.cpp                           | 1 -
 indra/test/llstreamtools_tut.cpp            | 7 -------
 indra/test/lltemplatemessagebuilder_tut.cpp | 1 -
 3 files changed, 9 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/io.cpp b/indra/test/io.cpp
index 62e516accb..47a67deed0 100644
--- a/indra/test/io.cpp
+++ b/indra/test/io.cpp
@@ -1141,7 +1141,6 @@ namespace tut
 		ensure("Connected to server", connected);
 		lldebugs << "connected" << llendl;
 		pump_loop(mPump,0.1f);
-		(void)elapsed;
 		count = mPump->runningChains();
 		ensure_equals("server chain onboard", count, 2);
 		lldebugs << "** Client is connected." << llendl;
diff --git a/indra/test/llstreamtools_tut.cpp b/indra/test/llstreamtools_tut.cpp
index a9bb15d911..354c3dfe10 100644
--- a/indra/test/llstreamtools_tut.cpp
+++ b/indra/test/llstreamtools_tut.cpp
@@ -389,13 +389,10 @@ namespace tut
 		is.str(str = "  First Second \t \r  \n Third  Fourth-ShouldThisBePartOfFourth  Fifth\n");
 		actual_result = "";
 		get_word(actual_result, is); // First
-		(void)ret;
 		actual_result = "";
 		get_word(actual_result, is); // Second
-		(void)ret;
 		actual_result = "";
 		get_word(actual_result, is); // Third
-		(void)ret;
 
 		// the current implementation of get_word seems inconsistent with
 		// skip_to_next_word. skip_to_next_word treats any character other
@@ -486,7 +483,6 @@ namespace tut
 		is.str(str = "First Second \t \r\n Third  Fourth-ShouldThisBePartOfFourth  IsThisFifth\n");
 		actual_result = "";
 		get_line(actual_result, is);
-		(void)ret;
 		expected_result = "First Second \t \r\n";
 		ensure_equals("get_line: 1", actual_result, expected_result);
 
@@ -551,7 +547,6 @@ namespace tut
 		is.str(str = "Should not skip lone \r.\r\n");
 		actual_result = "";
 		get_line(actual_result, is);
-		(void)ret;
 		expected_result = "Should not skip lone \r.\r\n";
 		ensure_equals("get_line: carriage return skipped even though not followed by newline", actual_result, expected_result);
 	}
@@ -569,7 +564,6 @@ namespace tut
 		is.str(str = "\n");
 		actual_result = "";
 		get_line(actual_result, is);
-		(void)ret;
 		expected_result = "\n";
 		ensure_equals("get_line: Just newline", actual_result, expected_result);
 	}
@@ -588,7 +582,6 @@ namespace tut
 		is.str(str = "First Line.\nSecond Line.\n");
 		actual_result = "";
 		get_line(actual_result, is, 255);
-		(void)ret;
 		expected_result = "First Line.\n";
 		ensure_equals("get_line: Basic Operation", actual_result, expected_result);
 
diff --git a/indra/test/lltemplatemessagebuilder_tut.cpp b/indra/test/lltemplatemessagebuilder_tut.cpp
index 3d3edab102..dde70f98c8 100644
--- a/indra/test/lltemplatemessagebuilder_tut.cpp
+++ b/indra/test/lltemplatemessagebuilder_tut.cpp
@@ -963,7 +963,6 @@ namespace tut
 		memset(buffer, 0xcc, bufferSize);
 		reader->getString(_PREHASH_Test1, _PREHASH_Test0, bufferSize, 
 						  outBuffer);
-		(void)outValue2;
 		ensure_equals("Ensure present value ", outValue, inValue);
 		ensure_equals("Ensure unchanged buffer ", strlen(outBuffer), 0);
 		delete reader;
-- 
cgit v1.2.3


From 806d09b1143894ad66cea2c228f467e8c39a8adf Mon Sep 17 00:00:00 2001
From: Graham Madarasz <graham@lindenlab.com>
Date: Tue, 30 Apr 2013 19:50:05 -0700
Subject: Merge 3.5.1 into Materials

---
 indra/test/CMakeLists.txt                   |  4 +++
 indra/test/io.cpp                           | 10 +++---
 indra/test/llpermissions_tut.cpp            | 10 +++---
 indra/test/llsaleinfo_tut.cpp               |  3 +-
 indra/test/llstreamtools_tut.cpp            | 53 +++++++++++++----------------
 indra/test/lltemplatemessagebuilder_tut.cpp |  3 +-
 6 files changed, 41 insertions(+), 42 deletions(-)

(limited to 'indra/test')

diff --git a/indra/test/CMakeLists.txt b/indra/test/CMakeLists.txt
index 816f1d7175..31e1d89c68 100644
--- a/indra/test/CMakeLists.txt
+++ b/indra/test/CMakeLists.txt
@@ -28,6 +28,10 @@ include_directories(
     ${GOOGLEMOCK_INCLUDE_DIRS}
     ${TUT_INCLUDE_DIR}
     )
+include_directories(SYSTEM
+    ${LLCOMMON_SYSTEM_INCLUDE_DIRS}
+    ${LLXML_SYSTEM_INCLUDE_DIRS}
+    )
 
 set(test_SOURCE_FILES
     io.cpp
diff --git a/indra/test/io.cpp b/indra/test/io.cpp
index 406e2d7bef..47a67deed0 100644
--- a/indra/test/io.cpp
+++ b/indra/test/io.cpp
@@ -1140,7 +1140,7 @@ namespace tut
 		bool connected = client->blockingConnect(server_host);
 		ensure("Connected to server", connected);
 		lldebugs << "connected" << llendl;
-		F32 elapsed = pump_loop(mPump,0.1f);
+		pump_loop(mPump,0.1f);
 		count = mPump->runningChains();
 		ensure_equals("server chain onboard", count, 2);
 		lldebugs << "** Client is connected." << llendl;
@@ -1156,20 +1156,20 @@ namespace tut
 		chain.clear();
 
 		// pump for a bit and make sure all 3 chains are running
-		elapsed = pump_loop(mPump,0.1f);
+		pump_loop(mPump,0.1f);
 		count = mPump->runningChains();
-		// ensure_equals("client chain onboard", count, 3); commented out because it fails frequently - appears to be timing sensitive
+		ensure_equals("client chain onboard", count, 3);
 		lldebugs << "** request should have been sent." << llendl;
 
 		// pump for long enough the the client socket closes, and the
 		// server socket should not be closed yet.
-		elapsed = pump_loop(mPump,0.2f);
+		pump_loop(mPump,0.2f);
 		count = mPump->runningChains();
 		ensure_equals("client chain timed out ", count, 2);
 		lldebugs << "** client chain should be closed." << llendl;
 
 		// At this point, the socket should be closed by the timeout
-		elapsed = pump_loop(mPump,1.0f);
+		pump_loop(mPump,1.0f);
 		count = mPump->runningChains();
 		ensure_equals("accepted socked close", count, 1);
 		lldebugs << "** Sleeper should have timed out.." << llendl;
diff --git a/indra/test/llpermissions_tut.cpp b/indra/test/llpermissions_tut.cpp
index bf6766424c..bc2c87ba46 100644
--- a/indra/test/llpermissions_tut.cpp
+++ b/indra/test/llpermissions_tut.cpp
@@ -407,7 +407,7 @@ namespace tut
 		LLFILE* fp = LLFile::fopen("linden_file.dat","w+");
 		if(!fp)
 		{
-			llerrs << "file coudnt be opened\n" << llendl;
+			llerrs << "file couldn't be opened\n" << llendl;
 			return;
 		}
 		LLPermissions perm,perm1;
@@ -425,15 +425,15 @@ namespace tut
 
 		perm.initMasks(base, ownerp, everyone, groupp, next);
 
-		perm.exportFile(fp);
+		ensure("Permissions export failed", perm.exportFile(fp));
 		fclose(fp);	
 		fp = LLFile::fopen("linden_file.dat","r+");
 		if(!fp)
 		{
-			llerrs << "file coudnt be opened\n" << llendl;
+			llerrs << "file couldn't be opened\n" << llendl;
 			return;
 		}
-		perm1.importFile(fp);
+		ensure("Permissions import failed", perm1.importFile(fp));
 		fclose(fp);
 		ensure_equals("exportFile()/importFile():failed to export and import the data ", perm1, perm);	
 }
@@ -461,7 +461,7 @@ namespace tut
 		std::istringstream istream(ostream.str());
 		perm1.importLegacyStream(istream);
 
-		ensure_equals("exportLegacyStream()/importLegacyStream():failed to export and import the data ", perm1, perm);
+		ensure_equals("exportStream()/importStream():failed to export and import the data ", perm1, perm);
 	}
 
 	template<> template<>
diff --git a/indra/test/llsaleinfo_tut.cpp b/indra/test/llsaleinfo_tut.cpp
index 09fca2abba..2488af1d7f 100644
--- a/indra/test/llsaleinfo_tut.cpp
+++ b/indra/test/llsaleinfo_tut.cpp
@@ -154,7 +154,8 @@ namespace tut
 		BOOL has_perm_mask = FALSE;
 		llsaleinfo1.importLegacyStream(istream, has_perm_mask, perm_mask);
 					
-		ensure("importLegacyStream() fn failed ", llsaleinfo.getSalePrice() == llsaleinfo1.getSalePrice() &&
+		ensure("importStream() fn failed ",
+			llsaleinfo.getSalePrice() == llsaleinfo1.getSalePrice() &&
 										       llsaleinfo.getSaleType() == llsaleinfo1.getSaleType());		
 	}
 
diff --git a/indra/test/llstreamtools_tut.cpp b/indra/test/llstreamtools_tut.cpp
index a93f2e8f65..0f6436f0f4 100644
--- a/indra/test/llstreamtools_tut.cpp
+++ b/indra/test/llstreamtools_tut.cpp
@@ -385,16 +385,15 @@ namespace tut
 		std::string expected_result;
 		std::string actual_result;
 		std::istringstream is;
-		bool ret;
 
 		is.clear();
 		is.str(str = "  First Second \t \r  \n Third  Fourth-ShouldThisBePartOfFourth  Fifth\n");
 		actual_result = "";
-		ret = get_word(actual_result, is); // First
+		get_word(actual_result, is); // First
 		actual_result = "";
-		ret = get_word(actual_result, is); // Second
+		get_word(actual_result, is); // Second
 		actual_result = "";
-		ret = get_word(actual_result, is); // Third
+		get_word(actual_result, is); // Third
 
 		// the current implementation of get_word seems inconsistent with
 		// skip_to_next_word. skip_to_next_word treats any character other
@@ -403,22 +402,22 @@ namespace tut
 		// carriage  return ('\r'), horizontal tab ('\t'), and vertical tab ('\v')
 		// as delimiters 
 		actual_result = "";
-		ret = get_word(actual_result, is); // will copy Fourth-ShouldThisBePartOfFourth
+		get_word(actual_result, is); // will copy Fourth-ShouldThisBePartOfFourth
 
 		actual_result = "";
-		ret = get_word(actual_result, is); // will copy Fifth
+		get_word(actual_result, is); // will copy Fifth
 
 		is.clear();
 		is.str(str = "  First Second \t \r  \n Third  Fourth_ShouldThisBePartOfFourth Fifth\n");
-		ret = skip_to_next_word(is);  // should now point to First
-		ret = skip_to_next_word(is);  // should now point to Second
-		ret = skip_to_next_word(is);  // should now point to Third
-		ret = skip_to_next_word(is);  // should now point to Fourth
-		ret = skip_to_next_word(is);  // should now point to ShouldThisBePartOfFourth
+		skip_to_next_word(is);  // should now point to First
+		skip_to_next_word(is);  // should now point to Second
+		skip_to_next_word(is);  // should now point to Third
+		skip_to_next_word(is);  // should now point to Fourth
+		skip_to_next_word(is);  // should now point to ShouldThisBePartOfFourth
 		expected_result = "";
 		// will copy ShouldThisBePartOfFourth, the fifth word, 
 		// while using get_word above five times result in getting "Fifth"
-		ret = get_word(expected_result, is); 
+		get_word(expected_result, is); 
 		ensure_equals("get_word: skip_to_next_word compatibility", actual_result, expected_result);
 	}
 
@@ -480,39 +479,38 @@ namespace tut
 		std::string expected_result;
 		std::string actual_result;
 		std::istringstream is;
-		bool ret;
 
 		is.clear();
 		is.str(str = "First Second \t \r\n Third  Fourth-ShouldThisBePartOfFourth  IsThisFifth\n");
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = "First Second \t \r\n";
 		ensure_equals("get_line: 1", actual_result, expected_result);
 
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = " Third  Fourth-ShouldThisBePartOfFourth  IsThisFifth\n";
 		ensure_equals("get_line: 2", actual_result, expected_result);
 
 		is.clear();
 		is.str(str = "\nFirst Line.\n\nSecond Line.\n");
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = "\n";
 		ensure_equals("get_line: First char as newline", actual_result, expected_result);
 
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = "First Line.\n";
 		ensure_equals("get_line: 3", actual_result, expected_result);
 
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = "\n";
 		ensure_equals("get_line: 4", actual_result, expected_result);
 
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = "Second Line.\n";
 		ensure_equals("get_line: 5", actual_result, expected_result);
 	}	
@@ -544,13 +542,12 @@ namespace tut
 		std::string expected_result;
 		std::string actual_result;
 		std::istringstream is;
-		bool ret;
 
 		// need to be check if this test case is wrong or the implementation is wrong.
 		is.clear();
 		is.str(str = "Should not skip lone \r.\r\n");
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = "Should not skip lone \r.\r\n";
 		ensure_equals("get_line: carriage return skipped even though not followed by newline", actual_result, expected_result);
 	}
@@ -563,12 +560,11 @@ namespace tut
 		std::string expected_result;
 		std::string actual_result;
 		std::istringstream is;
-		bool ret;
 
 		is.clear();
 		is.str(str = "\n");
 		actual_result = "";
-		ret = get_line(actual_result, is);
+		get_line(actual_result, is);
 		expected_result = "\n";
 		ensure_equals("get_line: Just newline", actual_result, expected_result);
 	}
@@ -582,36 +578,35 @@ namespace tut
 		std::string expected_result;
 		std::string actual_result;
 		std::istringstream is;
-		bool ret;
 
 		is.clear();
 		is.str(str = "First Line.\nSecond Line.\n");
 		actual_result = "";
-		ret = get_line(actual_result, is, 255);
+		get_line(actual_result, is, 255);
 		expected_result = "First Line.\n";
 		ensure_equals("get_line: Basic Operation", actual_result, expected_result);
 
 		actual_result = "";
-		ret = get_line(actual_result, is, sizeof("Second")-1);
+		get_line(actual_result, is, sizeof("Second")-1);
 		expected_result = "Second\n";
 		ensure_equals("get_line: Insufficient length 1", actual_result, expected_result);
 
 		actual_result = "";
-		ret = get_line(actual_result, is, 255);
+		get_line(actual_result, is, 255);
 		expected_result = " Line.\n";
 		ensure_equals("get_line: Remainder after earlier insufficient length", actual_result, expected_result);
 
 		is.clear();
 		is.str(str = "One Line only with no newline with limited length");
 		actual_result = "";
-		ret = get_line(actual_result, is, sizeof("One Line only with no newline with limited length")-1);
+		get_line(actual_result, is, sizeof("One Line only with no newline with limited length")-1);
 		expected_result = "One Line only with no newline with limited length\n";
 		ensure_equals("get_line: No newline with limited length", actual_result, expected_result);
 
 		is.clear();
 		is.str(str = "One Line only with no newline");
 		actual_result = "";
-		ret = get_line(actual_result, is, 255);
+		get_line(actual_result, is, 255);
 		expected_result = "One Line only with no newline";
 		ensure_equals("get_line: No newline", actual_result, expected_result);
 	}
diff --git a/indra/test/lltemplatemessagebuilder_tut.cpp b/indra/test/lltemplatemessagebuilder_tut.cpp
index 6e1c82bb24..6c0b70edd2 100644
--- a/indra/test/lltemplatemessagebuilder_tut.cpp
+++ b/indra/test/lltemplatemessagebuilder_tut.cpp
@@ -937,7 +937,7 @@ namespace tut
 		// build message with single block
 		LLMessageTemplate messageTemplate = defaultTemplate();
 		messageTemplate.addBlock(defaultBlock(MVT_U32, 4, MBT_SINGLE));
-		U32 outValue, outValue2, inValue = 0xbbbbbbbb;
+		U32 outValue, inValue = 0xbbbbbbbb;
 		LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
 		builder->addU32(_PREHASH_Test0, inValue);
 		const U32 bufferSize = 1024;
@@ -962,7 +962,6 @@ namespace tut
 		memset(buffer, 0xcc, bufferSize);
 		reader->getString(_PREHASH_Test1, _PREHASH_Test0, bufferSize, 
 						  outBuffer);
-		outValue2 = reader->getNumberOfBlocks(_PREHASH_Test1);
 		ensure_equals("Ensure present value ", outValue, inValue);
 		ensure_equals("Ensure unchanged buffer ", strlen(outBuffer), 0);
 		delete reader;
-- 
cgit v1.2.3


From 2a03e8f9fb24bb68b79e34bcfa9a45d3e377b0b8 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Fri, 20 Sep 2013 16:44:39 -0700
Subject: MAINT-3172 fix rendering regressions from release mergedown

---
 indra/test/llstreamtools_tut.cpp | 1 +
 1 file changed, 1 insertion(+)

(limited to 'indra/test')

diff --git a/indra/test/llstreamtools_tut.cpp b/indra/test/llstreamtools_tut.cpp
index 354c3dfe10..0f6436f0f4 100755
--- a/indra/test/llstreamtools_tut.cpp
+++ b/indra/test/llstreamtools_tut.cpp
@@ -385,6 +385,7 @@ namespace tut
 		std::string expected_result;
 		std::string actual_result;
 		std::istringstream is;
+
 		is.clear();
 		is.str(str = "  First Second \t \r  \n Third  Fourth-ShouldThisBePartOfFourth  Fifth\n");
 		actual_result = "";
-- 
cgit v1.2.3