merge

8 files changed, 1228 insertions, 29 deletions

diff --git a/indra/newview/tests/llagentaccess_test.cpp b/indra/newview/tests/llagentaccess_test.cpp
index 42872d85fb..e08193f785 100644
--- a/indra/newview/tests/llagentaccess_test.cpp
+++ b/indra/newview/tests/llagentaccess_test.cpp
@@ -29,6 +29,8 @@
  * COMPLETENESS OR PERFORMANCE.
  * $/LicenseInfo$
  */
+
+#include "linden_common.h"
 #include "../test/lltut.h"
 
 #include "../llagentaccess.h"
diff --git a/indra/newview/tests/llcapabilitylistener_test.cpp b/indra/newview/tests/llcapabilitylistener_test.cpp
index f66ae9404f..b965379c9c 100644
--- a/indra/newview/tests/llcapabilitylistener_test.cpp
+++ b/indra/newview/tests/llcapabilitylistener_test.cpp
@@ -24,9 +24,9 @@
 #include "../test/lltut.h"
 #include "../llcapabilityprovider.h"
 #include "lluuid.h"
-#include "llerrorcontrol.h"
 #include "tests/networkio.h"
 #include "tests/commtest.h"
+#include "tests/wrapllerrs.h"
 #include "stringize.h"
 
 #if defined(LL_WINDOWS)
@@ -104,28 +104,6 @@ namespace tut
     typedef llcapears_group::object llcapears_object;
     llcapears_group llsdmgr("llcapabilitylistener");
 
-    struct CaptureError: public LLError::OverrideFatalFunction
-    {
-        CaptureError():
-            LLError::OverrideFatalFunction(boost::bind(&CaptureError::operator(), this, _1))
-        {
-            LLError::setPrintLocation(false);
-        }
-
-        struct FatalException: public std::runtime_error
-        {
-            FatalException(const std::string& what): std::runtime_error(what) {}
-        };
-
-        void operator()(const std::string& message)
-        {
-            error = message;
-            throw FatalException(message);
-        }
-
-        std::string error;
-    };
-
     template<> template<>
     void llcapears_object::test<1>()
     {
@@ -137,10 +115,10 @@ namespace tut
         std::string threw;
         try
         {
-            CaptureError capture;
+            WrapLL_ERRS capture;
             regionPump.post(request);
         }
-        catch (const CaptureError::FatalException& e)
+        catch (const WrapLL_ERRS::FatalException& e)
         {
             threw = e.what();
         }
@@ -184,10 +162,10 @@ namespace tut
         std::string threw;
         try
         {
-            CaptureError capture;
+            WrapLL_ERRS capture;
             regionPump.post(request);
         }
-        catch (const CaptureError::FatalException& e)
+        catch (const WrapLL_ERRS::FatalException& e)
         {
             threw = e.what();
         }
@@ -246,10 +224,10 @@ namespace tut
         std::string threw;
         try
         {
-            CaptureError capture;
+            WrapLL_ERRS capture;
             regionPump.post(request);
         }
-        catch (const CaptureError::FatalException& e)
+        catch (const WrapLL_ERRS::FatalException& e)
         {
             threw = e.what();
         }
diff --git a/indra/newview/tests/lldateutil_test.cpp b/indra/newview/tests/lldateutil_test.cpp
index 30e39a3bcf..ed753b6ff7 100644
--- a/indra/newview/tests/lldateutil_test.cpp
+++ b/indra/newview/tests/lldateutil_test.cpp
@@ -28,6 +28,9 @@
  * COMPLETENESS OR PERFORMANCE.
  * $/LicenseInfo$
  */
+
+#include "linden_common.h"
+
 #include "../test/lltut.h"
 
 #include "../lldateutil.h"
diff --git a/indra/newview/tests/lllogininstance_test.cpp b/indra/newview/tests/lllogininstance_test.cpp
new file mode 100644
index 0000000000..009be35f64
--- /dev/null
+++ b/indra/newview/tests/lllogininstance_test.cpp
@@ -0,0 +1,423 @@
+/**

+ * @file   lllogininstance_test.cpp

+ * @brief  Test for lllogininstance.cpp.

+ * 

+ * $LicenseInfo:firstyear=2008&license=internal$

+ * Copyright (c) 2008, Linden Research, Inc.

+ * $/LicenseInfo$

+ */

+

+// Precompiled header

+#include "../llviewerprecompiledheaders.h"

+// Own header

+#include "../lllogininstance.h"

+// STL headers

+// std headers

+// external library headers

+// other Linden headers

+#include "../test/lltut.h"

+#include "llevents.h"

+

+#if defined(LL_WINDOWS)

+#pragma warning(disable: 4355)      // using 'this' in base-class ctor initializer expr

+#endif

+

+// Constants

+const std::string VIEWERLOGIN_URI("viewerlogin_uri");

+const std::string VIEWERLOGIN_GRIDLABEL("viewerlogin_grid");

+

+const std::string APPVIEWER_SERIALNUMBER("appviewer_serialno");

+

+// Link seams.

+

+//-----------------------------------------------------------------------------

+static LLEventStream gTestPump("test_pump");

+

+#include "lllogin.h"

+static std::string gLoginURI;

+static LLSD gLoginCreds;

+static bool gDisconnectCalled = false;

+class LLLogin::Impl

+{

+};

+LLLogin::LLLogin() {}

+LLLogin::~LLLogin() {}

+LLEventPump& LLLogin::getEventPump() { return gTestPump; }

+void LLLogin::connect(const std::string& uri, const LLSD& credentials) 

+{

+	gLoginURI = uri;

+	gLoginCreds = credentials;

+}

+

+void LLLogin::disconnect() 

+{

+	gDisconnectCalled = true;

+}

+

+//-----------------------------------------------------------------------------

+#include "../llviewernetwork.h"

+unsigned char gMACAddress[MAC_ADDRESS_BYTES] = {'1','2','3','4','5','6'};		/* Flawfinder: ignore */

+

+LLViewerLogin::LLViewerLogin() {}

+LLViewerLogin::~LLViewerLogin() {}

+void LLViewerLogin::getLoginURIs(std::vector<std::string>& uris) const 

+{

+	uris.push_back(VIEWERLOGIN_URI);

+}

+std::string LLViewerLogin::getGridLabel() const { return VIEWERLOGIN_GRIDLABEL; }

+

+//-----------------------------------------------------------------------------

+#include "../llviewercontrol.h"

+LLControlGroup gSavedSettings("Global");

+std::string gCurrentVersion = "invalid_version";

+

+LLControlGroup::LLControlGroup(const std::string& name) :

+	LLInstanceTracker<LLControlGroup, std::string>(name){}

+LLControlGroup::~LLControlGroup() {}

+void LLControlGroup::setBOOL(const std::string& name, BOOL val) {}

+BOOL LLControlGroup::getBOOL(const std::string& name) { return FALSE; }

+U32 LLControlGroup::saveToFile(const std::string& filename, BOOL nondefault_only) { return 1; }

+void LLControlGroup::setString(const std::string& name, const std::string& val) {}

+std::string LLControlGroup::getString(const std::string& name) { return "test_string"; }

+BOOL LLControlGroup::declareBOOL(const std::string& name, BOOL initial_val, const std::string& comment, BOOL persist) { return TRUE; }

+BOOL LLControlGroup::declareString(const std::string& name, const std::string &initial_val, const std::string& comment, BOOL persist) { return TRUE; }

+

+#include "lluicolortable.h"

+void LLUIColorTable::saveUserSettings(void)const {}

+

+//-----------------------------------------------------------------------------

+#include "../llurlsimstring.h"

+LLURLSimString LLURLSimString::sInstance;

+bool LLURLSimString::parse() { return true; }

+

+//-----------------------------------------------------------------------------

+#include "llnotifications.h"

+#include "llfloaterreg.h"

+static std::string gTOSType;

+static LLEventPump * gTOSReplyPump = NULL;

+

+//static

+LLFloater* LLFloaterReg::showInstance(const std::string& name, const LLSD& key, BOOL focus)

+{

+	gTOSType = name;

+	gTOSReplyPump = &LLEventPumps::instance().obtain(key["reply_pump"]);

+	return NULL;

+}

+

+//-----------------------------------------------------------------------------

+// LLNotifications

+class MockNotifications : public LLNotificationsInterface

+{

+	boost::function<void (const LLSD&, const LLSD&)> mResponder;

+	int mAddedCount;

+

+public: 

+	MockNotifications() :

+		mResponder(0),

+		mAddedCount(0)

+	{

+	}

+

+	virtual ~MockNotifications() {}

+

+	/* virtual */ LLNotificationPtr add(

+					const std::string& name,

+					const LLSD& substitutions,

+					const LLSD& payload, 

+					LLNotificationFunctorRegistry::ResponseFunctor functor)

+	{

+		mResponder = functor;

+		mAddedCount++;

+		return LLNotificationPtr((LLNotification*)NULL);

+	}

+

+	void sendYesResponse()

+	{

+		LLSD notification;

+		LLSD response;

+		response = 1;

+		mResponder(notification, response);

+	}

+

+	void sendNoResponse()

+	{

+		LLSD notification;

+		LLSD response;

+		response = 2;

+		mResponder(notification, response);

+	}

+

+	void sendBogusResponse()

+	{

+		LLSD notification;

+		LLSD response;

+		response = 666;

+		mResponder(notification, response);

+	}

+

+	int addedCount() { return mAddedCount; }

+};

+

+S32 LLNotification::getSelectedOption(const LLSD& notification, const LLSD& response)

+{

+	return response.asInteger();

+}

+

+// misc

+std::string xml_escape_string(const std::string& in)

+{

+	return in;

+}

+

+/*****************************************************************************

+*   TUT

+*****************************************************************************/

+namespace tut

+{

+    struct lllogininstance_data

+    {

+		lllogininstance_data() : logininstance(LLLoginInstance::getInstance())

+		{

+			// Global initialization

+			gLoginURI.clear();

+			gLoginCreds.clear();

+			gDisconnectCalled = false;

+

+			gTOSType = ""; // Set to invalid value.

+			gTOSReplyPump = 0; // clear the callback.

+

+

+			gSavedSettings.declareBOOL("NoInventoryLibrary", FALSE, "", FALSE);

+			gSavedSettings.declareBOOL("ConnectAsGod", FALSE, "", FALSE);

+			gSavedSettings.declareBOOL("UseDebugMenus", FALSE, "", FALSE);

+			gSavedSettings.declareBOOL("ForceMandatoryUpdate", FALSE, "", FALSE);

+			gSavedSettings.declareString("ClientSettingsFile", "test_settings.xml", "", FALSE);

+			gSavedSettings.declareString("VersionChannelName", "test_version_string", "", FALSE);

+			gSavedSettings.declareString("NextLoginLocation", "", "", FALSE);

+			gSavedSettings.declareBOOL("LoginLastLocation", FALSE, "", FALSE);

+

+			credentials["first"] = "testfirst";

+			credentials["last"] = "testlast";

+			credentials["passwd"] = "testpass";

+

+			logininstance->setNotificationsInterface(&notifications);

+		}

+

+		LLLoginInstance* logininstance;

+		LLSD credentials;

+		MockNotifications notifications;

+    };

+

+    typedef test_group<lllogininstance_data> lllogininstance_group;

+    typedef lllogininstance_group::object lllogininstance_object;

+    lllogininstance_group llsdmgr("lllogininstance");

+

+    template<> template<>

+    void lllogininstance_object::test<1>()

+    {

+		set_test_name("Test Simple Success And Disconnect");

+

+		// Test default connect.

+		logininstance->connect(credentials);

+

+		ensure_equals("Default connect uri", gLoginURI, VIEWERLOGIN_URI); 

+

+		// Dummy success response.

+		LLSD response;

+		response["state"] = "online";

+		response["change"] = "connect";

+		response["progress"] = 1.0;

+		response["transfer_rate"] = 7;

+		response["data"] = "test_data";

+

+		gTestPump.post(response);

+

+		ensure("Success response", logininstance->authSuccess());

+		ensure_equals("Test Response Data", logininstance->getResponse().asString(), "test_data");

+

+		logininstance->disconnect();

+

+		ensure_equals("Called Login Module Disconnect", gDisconnectCalled, true);

+

+		response.clear();

+		response["state"] = "offline";

+		response["change"] = "disconnect";

+		response["progress"] = 0.0;

+		response["transfer_rate"] = 0;

+		response["data"] = "test_data";

+

+		gTestPump.post(response);

+

+		ensure("Disconnected", !(logininstance->authSuccess()));

+    }

+

+    template<> template<>

+    void lllogininstance_object::test<2>()

+    {

+		set_test_name("Test User TOS/Critical message Interaction");

+

+		const std::string test_uri = "testing-uri";

+

+		// Test default connect.

+		logininstance->connect(test_uri, credentials);

+

+		// connect should call LLLogin::connect to init gLoginURI and gLoginCreds.

+		ensure_equals("Default connect uri", gLoginURI, "testing-uri"); 

+		ensure_equals("Default for agree to tos", gLoginCreds["params"]["agree_to_tos"].asBoolean(), false);

+		ensure_equals("Default for read critical", gLoginCreds["params"]["read_critical"].asBoolean(), false);

+

+		// TOS failure response.

+		LLSD response;

+		response["state"] = "offline";

+		response["change"] = "fail.login";

+		response["progress"] = 0.0;

+		response["transfer_rate"] = 7;

+		response["data"]["reason"] = "tos";

+		gTestPump.post(response);

+

+		ensure_equals("TOS Dialog type", gTOSType, "message_tos");

+		ensure("TOS callback given", gTOSReplyPump != 0);

+		gTOSReplyPump->post(false); // Call callback denying TOS.

+		ensure("No TOS, failed auth", logininstance->authFailure());

+

+		// Start again.

+		logininstance->connect(test_uri, credentials);

+		gTestPump.post(response); // Fail for tos again.

+		gTOSReplyPump->post(true); // Accept tos, should reconnect w/ agree_to_tos.

+		ensure_equals("Accepted agree to tos", gLoginCreds["params"]["agree_to_tos"].asBoolean(), true);

+		ensure("Incomplete login status", !logininstance->authFailure() && !logininstance->authSuccess());

+	

+		// Fail connection, attempt connect again.

+		// The new request should have reset agree to tos to default.

+		response["data"]["reason"] = "key"; // bad creds.

+		gTestPump.post(response);

+		ensure("TOS auth failure", logininstance->authFailure());

+

+		logininstance->connect(test_uri, credentials);

+		ensure_equals("Reset to default for agree to tos", gLoginCreds["params"]["agree_to_tos"].asBoolean(), false);

+

+		// Critical Message failure response.

+		logininstance->connect(test_uri, credentials);

+		response["data"]["reason"] = "critical"; // Change response to "critical message"

+		gTestPump.post(response);

+

+		ensure_equals("TOS Dialog type", gTOSType, "message_critical");

+		ensure("TOS callback given", gTOSReplyPump != 0);

+		gTOSReplyPump->post(true); 

+		ensure_equals("Accepted read critical message", gLoginCreds["params"]["read_critical"].asBoolean(), true);

+		ensure("Incomplete login status", !logininstance->authFailure() && !logininstance->authSuccess());

+

+		// Fail then attempt new connection

+		response["data"]["reason"] = "key"; // bad creds.

+		gTestPump.post(response);

+		ensure("TOS auth failure", logininstance->authFailure());

+		logininstance->connect(test_uri, credentials);

+		ensure_equals("Default for agree to tos", gLoginCreds["params"]["read_critical"].asBoolean(), false);

+	}

+

+    template<> template<>

+    void lllogininstance_object::test<3>()

+    {

+		set_test_name("Test Mandatory Update User Accepts");

+

+		// Part 1 - Mandatory Update, with User accepts response.

+		// Test connect with update needed.

+		logininstance->connect(credentials);

+

+		ensure_equals("Default connect uri", gLoginURI, VIEWERLOGIN_URI); 

+

+		// Update needed failure response.

+		LLSD response;

+		response["state"] = "offline";

+		response["change"] = "fail.login";

+		response["progress"] = 0.0;

+		response["transfer_rate"] = 7;

+		response["data"]["reason"] = "update";

+		gTestPump.post(response);

+

+		ensure_equals("Notification added", notifications.addedCount(), 1);

+

+		notifications.sendYesResponse();

+

+		ensure("Disconnected", !(logininstance->authSuccess()));

+	}

+

+	template<> template<>

+    void lllogininstance_object::test<4>()

+    {

+		set_test_name("Test Mandatory Update User Decline");

+

+		// Test connect with update needed.

+		logininstance->connect(credentials);

+

+		ensure_equals("Default connect uri", gLoginURI, VIEWERLOGIN_URI); 

+

+		// Update needed failure response.

+		LLSD response;

+		response["state"] = "offline";

+		response["change"] = "fail.login";

+		response["progress"] = 0.0;

+		response["transfer_rate"] = 7;

+		response["data"]["reason"] = "update";

+		gTestPump.post(response);

+

+		ensure_equals("Notification added", notifications.addedCount(), 1);

+		notifications.sendNoResponse();

+

+		ensure("Disconnected", !(logininstance->authSuccess()));

+	}

+

+	template<> template<>

+    void lllogininstance_object::test<6>()

+    {

+		set_test_name("Test Optional Update User Accept");

+

+		// Part 3 - Mandatory Update, with bogus response.

+		// Test connect with update needed.

+		logininstance->connect(credentials);

+

+		ensure_equals("Default connect uri", gLoginURI, VIEWERLOGIN_URI); 

+

+		// Update needed failure response.

+		LLSD response;

+		response["state"] = "offline";

+		response["change"] = "fail.login";

+		response["progress"] = 0.0;

+		response["transfer_rate"] = 7;

+		response["data"]["reason"] = "optional";

+		gTestPump.post(response);

+

+		ensure_equals("Notification added", notifications.addedCount(), 1);

+		notifications.sendYesResponse();

+

+		ensure("Disconnected", !(logininstance->authSuccess()));

+	}

+

+	template<> template<>

+    void lllogininstance_object::test<7>()

+    {

+		set_test_name("Test Optional Update User Denies");

+

+		// Part 3 - Mandatory Update, with bogus response.

+		// Test connect with update needed.

+		logininstance->connect(credentials);

+

+		ensure_equals("Default connect uri", gLoginURI, VIEWERLOGIN_URI); 

+

+		// Update needed failure response.

+		LLSD response;

+		response["state"] = "offline";

+		response["change"] = "fail.login";

+		response["progress"] = 0.0;

+		response["transfer_rate"] = 7;

+		response["data"]["reason"] = "optional";

+		gTestPump.post(response);

+

+		ensure_equals("Notification added", notifications.addedCount(), 1);

+		notifications.sendNoResponse();

+

+		// User skips, should be reconnecting.

+		ensure_equals("reconnect uri", gLoginURI, VIEWERLOGIN_URI); 

+		ensure_equals("skipping optional update", gLoginCreds["params"]["skipoptional"].asBoolean(), true); 

+	}

+}

diff --git a/indra/newview/tests/llmediadataclient_test.cpp b/indra/newview/tests/llmediadataclient_test.cpp
new file mode 100644
index 0000000000..445ec7aa34
--- /dev/null
+++ b/indra/newview/tests/llmediadataclient_test.cpp
@@ -0,0 +1,501 @@
+/** 
+ * @file llmediadataclient_test.cpp
+ * @brief LLMediaDatClient tests
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+#include "../llviewerprecompiledheaders.h"
+ 
+#include <iostream>
+#include "../test/lltut.h"
+
+#include "llsdserialize.h"
+#include "llsdutil.h"
+#include "llerrorcontrol.h"
+#include "llhttpstatuscodes.h"
+
+#include "../llmediadataclient.h"
+#include "../llvovolume.h"
+
+#include "../../llprimitive/llmediaentry.cpp"
+#include "../../llprimitive/lltextureentry.cpp"
+#include "../../llmessage/tests/llcurl_stub.cpp"
+
+#if LL_WINDOWS
+#pragma warning (push)
+#pragma warning (disable : 4702) // boost::lexical_cast generates this warning
+#endif
+#include <boost/lexical_cast.hpp>
+#if LL_WINDOWS
+#pragma warning (pop)
+#endif
+
+#define VALID_OBJECT_ID   "3607d5c4-644b-4a8a-871a-8b78471af2a2"
+#define VALID_OBJECT_ID_1 "11111111-1111-1111-1111-111111111111"
+#define VALID_OBJECT_ID_2 "22222222-2222-2222-2222-222222222222"
+#define VALID_OBJECT_ID_3 "33333333-3333-3333-3333-333333333333"
+#define VALID_OBJECT_ID_4 "44444444-4444-4444-4444-444444444444"
+
+#define FAKE_OBJECT_MEDIA_CAP_URL "foo_ObjectMedia"
+#define FAKE_OBJECT_MEDIA_NAVIGATE_CAP_URL "foo_ObjectMediaNavigate"
+#define FAKE_OBJECT_MEDIA_CAP_URL_503 "foo_ObjectMedia_503"
+#define FAKE_OBJECT_MEDIA_NAVIGATE_CAP_URL_ERROR "foo_ObjectMediaNavigate_ERROR"
+
+#define MEDIA_DATA "\
+<array>														\
+<string>foo</string>										\
+<string>bar</string>										\
+<string>baz</string>										\
+</array>"
+
+#define _DATA_URLS(ID,DIST,INT,URL1,URL2) "					\
+<llsd>											\
+  <map>											\
+    <key>uuid</key>								\
+    <string>" ID "</string>						\
+    <key>distance</key>											\
+    <real>" DIST "</real>										\
+    <key>interest</key>											\
+    <real>" INT "</real>											\
+    <key>cap_urls</key>											\
+    <map>														\
+      <key>ObjectMedia</key>									\
+      <string>" URL1 "</string>			\
+      <key>ObjectMediaNavigate</key>							\
+      <string>" URL2 "</string>	\
+    </map>														\
+    <key>media_data</key>                                       \
+	" MEDIA_DATA "												\
+  </map>														\
+</llsd>"
+
+#define _DATA(ID,DIST,INT) _DATA_URLS(ID,DIST,INT,FAKE_OBJECT_MEDIA_CAP_URL,FAKE_OBJECT_MEDIA_NAVIGATE_CAP_URL)
+
+const char *DATA = _DATA(VALID_OBJECT_ID,"1.0","1.0");
+	
+#define STR(I) boost::lexical_cast<std::string>(I)
+
+#define LOG_TEST(N) LL_DEBUGS("LLMediaDataClient") << "\n" <<			\
+"================================================================================\n" << \
+"===================================== TEST " #N " ===================================\n" << \
+"================================================================================\n" << LL_ENDL;
+
+LLSD *gPostRecords = NULL;
+
+// stubs:
+void LLHTTPClient::post(
+		const std::string& url,
+		const LLSD& body,
+		LLHTTPClient::ResponderPtr responder,
+		const LLSD& headers,
+		const F32 timeout)
+{
+	LLSD record;
+	record["url"] = url;
+	record["body"] = body;
+	record["headers"] = headers;
+	record["timeout"] = timeout;
+	gPostRecords->append(record);
+	
+	// Magic URL that triggers a 503:
+	if ( url == FAKE_OBJECT_MEDIA_CAP_URL_503 )
+	{
+		responder->error(HTTP_SERVICE_UNAVAILABLE, "fake reason");
+	}
+	else if (url == FAKE_OBJECT_MEDIA_NAVIGATE_CAP_URL_ERROR) 
+	{
+		LLSD result;
+		LLSD error;
+		error["code"] = LLObjectMediaNavigateClient::ERROR_PERMISSION_DENIED_CODE;
+		result["error"] = error;
+		responder->result(result);
+	}
+	else {
+		responder->result(LLSD());
+	}
+}
+
+const F32 HTTP_REQUEST_EXPIRY_SECS = 60.0f;
+
+class LLMediaDataClientObjectTest : public LLMediaDataClientObject
+{
+public:
+	LLMediaDataClientObjectTest(const char *data) 
+		{
+			std::istringstream d(data);
+			LLSDSerialize::fromXML(mRep, d);
+			mNumBounceBacks = 0;
+            
+           // std::cout << ll_pretty_print_sd(mRep) << std::endl;
+           // std::cout << "ID: " << getID() << std::endl;
+		}
+	LLMediaDataClientObjectTest(const LLSD &rep) 
+		: mRep(rep), mNumBounceBacks(0) {}
+	~LLMediaDataClientObjectTest()
+		{ LL_DEBUGS("LLMediaDataClient") << "~LLMediaDataClientObjectTest" << LL_ENDL; }
+	
+	virtual U8 getMediaDataCount() const 
+		{ return mRep["media_data"].size(); }
+	virtual LLSD getMediaDataLLSD(U8 index) const
+		{ return mRep["media_data"][(LLSD::Integer)index]; }
+	virtual LLUUID getID() const 
+		{ return mRep["uuid"]; }
+	virtual void mediaNavigateBounceBack(U8 index)
+		{
+			mNumBounceBacks++;
+		}
+	
+	virtual bool hasMedia() const
+		{ return mRep.has("media_data"); }
+	
+	virtual void updateObjectMediaData(LLSD const &media_data_array)
+		{ mRep["media_data"] = media_data_array; }
+	
+	virtual F64 getDistanceFromAvatar() const
+		{ return (LLSD::Real)mRep["distance"]; }
+	
+	virtual F64 getTotalMediaInterest() const
+		{ return (LLSD::Real)mRep["interest"]; }
+
+	virtual std::string getCapabilityUrl(const std::string &name) const 
+		{ return mRep["cap_urls"][name]; }
+
+	int getNumBounceBacks() const
+		{ return mNumBounceBacks; }
+	
+private:
+	LLSD mRep;
+	int mNumBounceBacks;
+};
+
+// This special timer delay should ensure that the timer will fire on the very
+// next pump, no matter what (though this does make an assumption about the
+// implementation of LLEventTimer::updateClass()):
+const F32 NO_PERIOD = -1000.0f;
+
+static void pump_timers()
+{
+	LLEventTimer::updateClass();
+}
+
+namespace tut
+{
+    struct mediadataclient
+    {
+		mediadataclient() {
+			gPostRecords = &mLLSD;
+			
+ 			//LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
+ 			//LLError::setClassLevel("LLMediaDataClient", LLError::LEVEL_DEBUG);
+			//LLError::setTagLevel("MediaOnAPrim", LLError::LEVEL_DEBUG);
+		}
+		LLSD mLLSD;
+    };
+    
+	typedef test_group<mediadataclient> mediadataclient_t;
+	typedef mediadataclient_t::object mediadataclient_object_t;
+	tut::mediadataclient_t tut_mediadataclient("mediadataclient");
+    
+    void ensure(const std::string &msg, int value, int expected)
+    {
+        std::string m = msg;
+        m += " value: " + STR(value);
+        m += ", expected: " + STR(expected);
+        ensure(m, value == expected);
+    }
+    
+    void ensure(const std::string &msg, const std::string & value, const std::string & expected)
+    {
+        std::string m = msg;
+        m += " value: " + value;
+        m += ", expected: " + expected;
+        ensure(m, value == expected);
+    }
+    
+    void ensure(const std::string &msg, const LLUUID & value, const LLUUID & expected)
+    {
+        std::string m = msg;
+        m += " value: " + value.asString();
+        m += ", expected: " + expected.asString();
+        ensure(m, value == expected);
+    }
+    
+    void ensure_llsd(const std::string &msg, const LLSD & value, const char *expected)
+    {
+        LLSD expected_llsd;
+        std::istringstream e(expected);
+        LLSDSerialize::fromXML(expected_llsd, e);
+   
+        std::string value_str = ll_pretty_print_sd(value);
+        std::string expected_str = ll_pretty_print_sd(expected_llsd);
+        std::string m = msg;
+        m += " value: " + value_str;
+        m += ", expected: " + expected_str;
+        ensure(m, value_str == expected_str);
+    }
+
+	//////////////////////////////////////////////////////////////////////////////////////////
+	
+	template<> template<>
+	void mediadataclient_object_t::test<1>()
+	{
+		//
+		// Test fetchMedia()
+		//
+		LOG_TEST(1);
+		
+		LLMediaDataClientObject::ptr_t o = new LLMediaDataClientObjectTest(DATA);
+		int num_refs_start = o->getNumRefs();
+		{
+			LLPointer<LLObjectMediaDataClient> mdc = new LLObjectMediaDataClient(NO_PERIOD,NO_PERIOD);
+			mdc->fetchMedia(o);
+
+			// Make sure no posts happened yet...
+			ensure("post records", gPostRecords->size(), 0);
+
+			::pump_timers();
+		
+			ensure("post records", gPostRecords->size(), 1);
+			ensure("post url", (*gPostRecords)[0]["url"], FAKE_OBJECT_MEDIA_CAP_URL);
+			ensure("post GET", (*gPostRecords)[0]["body"]["verb"], "GET");
+			ensure("post object id", (*gPostRecords)[0]["body"][LLTextureEntry::OBJECT_ID_KEY].asUUID(), LLUUID(VALID_OBJECT_ID));
+			ensure("queue empty", mdc->isEmpty());
+		}
+		
+		// Make sure everyone's destroyed properly
+		ensure("REF COUNT", o->getNumRefs(), num_refs_start);
+    }
+
+	//////////////////////////////////////////////////////////////////////////////////////////
+
+	template<> template<>
+	void mediadataclient_object_t::test<2>()
+	{
+		//
+		// Test updateMedia()
+		//
+		LOG_TEST(2);
+
+		LLMediaDataClientObject::ptr_t o = new LLMediaDataClientObjectTest(DATA);
+		{
+			// queue time w/ no delay ensures that ::pump_timers() will hit the tick()
+			LLPointer<LLObjectMediaDataClient> mdc = new LLObjectMediaDataClient(NO_PERIOD,NO_PERIOD);  
+			mdc->updateMedia(o);
+			ensure("post records", gPostRecords->size(), 0);
+			::pump_timers();
+		
+			ensure("post records", gPostRecords->size(), 1);
+			ensure("post url", (*gPostRecords)[0]["url"], FAKE_OBJECT_MEDIA_CAP_URL);
+			ensure("post UPDATE", (*gPostRecords)[0]["body"]["verb"], "UPDATE");
+			ensure("post object id", (*gPostRecords)[0]["body"][LLTextureEntry::OBJECT_ID_KEY].asUUID(), LLUUID(VALID_OBJECT_ID));
+			ensure_llsd("post data llsd", (*gPostRecords)[0]["body"][LLTextureEntry::OBJECT_MEDIA_DATA_KEY], 
+						"<llsd>" MEDIA_DATA "</llsd>");
+			ensure("queue empty", mdc->isEmpty());
+		}
+
+		ensure("REF COUNT", o->getNumRefs(), 1);
+	}
+
+	//////////////////////////////////////////////////////////////////////////////////////////
+
+    template<> template<>
+    void mediadataclient_object_t::test<3>()
+    {
+		//
+		// Test navigate()
+		//
+		LOG_TEST(3);
+
+		LLMediaDataClientObject::ptr_t o = new LLMediaDataClientObjectTest(DATA);
+		{		
+			LLPointer<LLObjectMediaNavigateClient> mdc = new LLObjectMediaNavigateClient(NO_PERIOD,NO_PERIOD);
+			const char *TEST_URL = "http://example.com";
+			mdc->navigate(o, 0, TEST_URL);
+			ensure("post records", gPostRecords->size(), 0);
+			::pump_timers();
+
+			// ensure no bounce back
+			ensure("bounce back", dynamic_cast<LLMediaDataClientObjectTest*>(static_cast<LLMediaDataClientObject*>(o))->getNumBounceBacks(), 0);
+		
+			ensure("post records", gPostRecords->size(), 1);
+			ensure("post url", (*gPostRecords)[0]["url"], FAKE_OBJECT_MEDIA_NAVIGATE_CAP_URL);
+			ensure("post object id", (*gPostRecords)[0]["body"][LLTextureEntry::OBJECT_ID_KEY].asUUID(), LLUUID(VALID_OBJECT_ID));
+			ensure("post data", (*gPostRecords)[0]["body"][LLTextureEntry::TEXTURE_INDEX_KEY], 0);
+			ensure("post data", (*gPostRecords)[0]["body"][LLMediaEntry::CURRENT_URL_KEY], TEST_URL);
+			ensure("queue empty", mdc->isEmpty());
+		}
+		ensure("REF COUNT", o->getNumRefs(), 1);
+    }
+	
+	//////////////////////////////////////////////////////////////////////////////////////////
+
+    template<> template<>
+    void mediadataclient_object_t::test<4>()
+    {
+		//
+		// Test queue ordering
+		//
+		LOG_TEST(4);
+
+		LLMediaDataClientObject::ptr_t o1 = new LLMediaDataClientObjectTest(
+			_DATA(VALID_OBJECT_ID_1,"3.0","1.0"));
+		LLMediaDataClientObject::ptr_t o2 = new LLMediaDataClientObjectTest(
+			_DATA(VALID_OBJECT_ID_2,"1.0","1.0"));
+		LLMediaDataClientObject::ptr_t o3 = new LLMediaDataClientObjectTest(
+			_DATA(VALID_OBJECT_ID_3,"2.0","1.0"));
+		{
+			LLPointer<LLObjectMediaDataClient> mdc = new LLObjectMediaDataClient(NO_PERIOD,NO_PERIOD);  
+			const char *ORDERED_OBJECT_IDS[] = { VALID_OBJECT_ID_2, VALID_OBJECT_ID_3, VALID_OBJECT_ID_1 };
+			mdc->fetchMedia(o1);
+			mdc->fetchMedia(o2);
+			mdc->fetchMedia(o3);
+
+			// Make sure no posts happened yet...
+			ensure("post records", gPostRecords->size(), 0);
+
+			// tick 3 times...
+			::pump_timers();
+			ensure("post records", gPostRecords->size(), 1);
+			::pump_timers();
+			ensure("post records", gPostRecords->size(), 2);
+			::pump_timers();
+			ensure("post records", gPostRecords->size(), 3);
+		
+			for( int i=0; i < 3; i++ )
+			{
+				ensure("[" + STR(i) + "] post url", (*gPostRecords)[i]["url"], FAKE_OBJECT_MEDIA_CAP_URL);
+				ensure("[" + STR(i) + "] post GET", (*gPostRecords)[i]["body"]["verb"], "GET");
+				ensure("[" + STR(i) + "] post object id", (*gPostRecords)[i]["body"][LLTextureEntry::OBJECT_ID_KEY].asUUID(), 
+					   LLUUID(ORDERED_OBJECT_IDS[i]));
+			}
+
+			ensure("queue empty", mdc->isEmpty());
+		}
+		ensure("refcount of o1", o1->getNumRefs(), 1);
+		ensure("refcount of o2", o2->getNumRefs(), 1);
+		ensure("refcount of o3", o3->getNumRefs(), 1);
+    }
+
+	//////////////////////////////////////////////////////////////////////////////////////////
+
+	template<> template<>
+	void mediadataclient_object_t::test<5>()
+	{
+		//
+		// Test fetchMedia() getting a 503 error
+		//
+		LOG_TEST(5);
+		
+		LLMediaDataClientObject::ptr_t o = new LLMediaDataClientObjectTest(
+			_DATA_URLS(VALID_OBJECT_ID,
+					   "1.0",
+					   "1.0",
+					   FAKE_OBJECT_MEDIA_CAP_URL_503,
+					   FAKE_OBJECT_MEDIA_NAVIGATE_CAP_URL));
+		int num_refs_start = o->getNumRefs();
+		{
+			const int NUM_RETRIES = 5;
+			LLPointer<LLObjectMediaDataClient> mdc = new LLObjectMediaDataClient(NO_PERIOD,NO_PERIOD,NUM_RETRIES);
+
+			// This should generate a retry
+			mdc->fetchMedia(o);
+
+			// Make sure no posts happened yet...
+			ensure("post records before", gPostRecords->size(), 0);
+
+			// Once, causes retry
+			// Second, fires retry timer
+			// Third, fires queue timer again
+			for (int i=0; i<NUM_RETRIES; ++i)
+			{
+				::pump_timers();  // Should pump (fire) the queue timer, causing a retry timer to be scheduled
+				// XXX This ensure is not guaranteed, because scheduling a timer might actually get it pumped in the same loop
+				//ensure("post records " + STR(i), gPostRecords->size(), i+1);
+				::pump_timers();  // Should pump (fire) the retry timer, scheduling the queue timer
+			}
+
+			// Do some extra pumps to make sure no other timer work occurs.
+			::pump_timers();
+			::pump_timers();
+			::pump_timers();
+			
+			// Make sure there were 2 posts
+			ensure("post records after", gPostRecords->size(), NUM_RETRIES);
+			for (int i=0; i<NUM_RETRIES; ++i)
+			{
+				ensure("[" + STR(i) + "] post url", (*gPostRecords)[i]["url"], FAKE_OBJECT_MEDIA_CAP_URL_503);
+				ensure("[" + STR(i) + "] post GET", (*gPostRecords)[i]["body"]["verb"], "GET");
+				ensure("[" + STR(i) + "] post object id", (*gPostRecords)[i]["body"][LLTextureEntry::OBJECT_ID_KEY].asUUID(), LLUUID(VALID_OBJECT_ID));
+			}
+			ensure("queue empty", mdc->isEmpty());
+		}
+		
+		// Make sure everyone's destroyed properly
+		ensure("REF COUNT", o->getNumRefs(), num_refs_start);
+    }
+
+    template<> template<>
+    void mediadataclient_object_t::test<6>()
+    {
+		//
+		// Test navigate() with a bounce back
+		//
+		LOG_TEST(6);
+
+		LLMediaDataClientObject::ptr_t o = new LLMediaDataClientObjectTest(
+			_DATA_URLS(VALID_OBJECT_ID,
+					   "1.0",
+					   "1.0",
+					   FAKE_OBJECT_MEDIA_CAP_URL,
+					   FAKE_OBJECT_MEDIA_NAVIGATE_CAP_URL_ERROR));
+		{		
+			LLPointer<LLObjectMediaNavigateClient> mdc = new LLObjectMediaNavigateClient(NO_PERIOD,NO_PERIOD);
+			const char *TEST_URL = "http://example.com";
+			mdc->navigate(o, 0, TEST_URL);
+			ensure("post records", gPostRecords->size(), 0);
+			::pump_timers();
+
+			// ensure bounce back
+			ensure("bounce back", 
+				   dynamic_cast<LLMediaDataClientObjectTest*>(static_cast<LLMediaDataClientObject*>(o))->getNumBounceBacks(),
+				   1);
+			
+			ensure("post records", gPostRecords->size(), 1);
+			ensure("post url", (*gPostRecords)[0]["url"], FAKE_OBJECT_MEDIA_NAVIGATE_CAP_URL_ERROR);
+			ensure("post object id", (*gPostRecords)[0]["body"][LLTextureEntry::OBJECT_ID_KEY].asUUID(), LLUUID(VALID_OBJECT_ID));
+			ensure("post data", (*gPostRecords)[0]["body"][LLTextureEntry::TEXTURE_INDEX_KEY], 0);
+			ensure("post data", (*gPostRecords)[0]["body"][LLMediaEntry::CURRENT_URL_KEY], TEST_URL);
+			ensure("queue empty", mdc->isEmpty());
+		}
+		ensure("REF COUNT", o->getNumRefs(), 1);
+    }
+
+	
+}
diff --git a/indra/newview/tests/llviewerhelputil_test.cpp b/indra/newview/tests/llviewerhelputil_test.cpp
index 40f7d532bc..988d28c301 100644
--- a/indra/newview/tests/llviewerhelputil_test.cpp
+++ b/indra/newview/tests/llviewerhelputil_test.cpp
@@ -30,6 +30,9 @@
  * COMPLETENESS OR PERFORMANCE.
  * $/LicenseInfo$
  */
+// Precompiled header
+#include "../llviewerprecompiledheaders.h"
+
 #include "../test/lltut.h"
 
 #include "../llviewerhelputil.h"
diff --git a/indra/newview/tests/llxmlrpclistener_test.cpp b/indra/newview/tests/llxmlrpclistener_test.cpp
new file mode 100644
index 0000000000..c94ba0a3e8
--- /dev/null
+++ b/indra/newview/tests/llxmlrpclistener_test.cpp
@@ -0,0 +1,230 @@
+/*
+ * @file   llxmlrpclistener_test.cpp
+ * @author Nat Goodspeed
+ * @date   2009-03-20
+ * @brief  Test for llxmlrpclistener.
+ * 
+ * $LicenseInfo:firstyear=2009&license=internal$
+ * Copyright (c) 2009, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+// Precompiled header
+#include "../llviewerprecompiledheaders.h"
+// associated header
+#include "../llxmlrpclistener.h"
+// STL headers
+#include <iomanip>
+// std headers
+// external library headers
+// other Linden headers
+#include "../test/lltut.h"
+#include "../llxmlrpctransaction.h"
+#include "llevents.h"
+#include "lleventfilter.h"
+#include "llsd.h"
+#include "llcontrol.h"
+#include "tests/wrapllerrs.h"
+
+LLControlGroup gSavedSettings("Global");
+
+/*****************************************************************************
+*   TUT
+*****************************************************************************/
+namespace tut
+{
+    struct data
+    {
+        data():
+            pumps(LLEventPumps::instance()),
+            uri("http://127.0.0.1:8000")
+        {
+            // These variables are required by machinery used by
+            // LLXMLRPCTransaction. The values reflect reality for this test
+            // executable; hopefully these values are correct.
+            gSavedSettings.declareBOOL("BrowserProxyEnabled", FALSE, "", FALSE); // don't persist
+            gSavedSettings.declareBOOL("NoVerifySSLCert", TRUE, "", FALSE); // don't persist
+        }
+
+        // LLEventPump listener signature
+        bool captureReply(const LLSD& r)
+        {
+            reply = r;
+            return false;
+        }
+
+        LLSD reply;
+        LLEventPumps& pumps;
+        std::string uri;
+    };
+    typedef test_group<data> llxmlrpclistener_group;
+    typedef llxmlrpclistener_group::object object;
+    llxmlrpclistener_group llxmlrpclistenergrp("llxmlrpclistener");
+
+    template<> template<>
+    void object::test<1>()
+    {
+        set_test_name("request validation");
+        WrapLL_ERRS capture;
+        LLSD request;
+        request["uri"] = uri;
+        std::string threw;
+        try
+        {
+            pumps.obtain("LLXMLRPCTransaction").post(request);
+        }
+        catch (const WrapLL_ERRS::FatalException& e)
+        {
+            threw = e.what();
+        }
+        ensure_contains("threw exception", threw, "missing params");
+        ensure_contains("identified missing", threw, "method");
+        ensure_contains("identified missing", threw, "reply");
+    }
+
+    template<> template<>
+    void object::test<2>()
+    {
+        set_test_name("param types validation");
+        WrapLL_ERRS capture;
+        LLSD request;
+        request["uri"] = uri;
+        request["method"] = "hello";
+        request["reply"] = "reply";
+        LLSD& params(request["params"]);
+        params["who"]["specifically"] = "world"; // LLXMLRPCListener only handles scalar params
+        std::string threw;
+        try
+        {
+            pumps.obtain("LLXMLRPCTransaction").post(request);
+        }
+        catch (const WrapLL_ERRS::FatalException& e)
+        {
+            threw = e.what();
+        }
+        ensure_contains("threw exception", threw, "unknown type");
+    }
+
+    template<> template<>
+    void object::test<3>()
+    {
+        set_test_name("success case");
+        LLSD request;
+        request["uri"] = uri;
+        request["method"] = "hello";
+        request["reply"] = "reply";
+        LLSD& params(request["params"]);
+        params["who"] = "world";
+        // Set up a timeout filter so we don't spin forever waiting.
+        LLEventTimeout watchdog;
+        // Connect the timeout filter to the reply pump.
+        LLTempBoundListener temp(
+            pumps.obtain("reply").
+            listen("watchdog", boost::bind(&LLEventTimeout::post, boost::ref(watchdog), _1)));
+        // Now connect our target listener to the timeout filter.
+        watchdog.listen("captureReply", boost::bind(&data::captureReply, this, _1));
+        // Kick off the request...
+        reply.clear();
+        pumps.obtain("LLXMLRPCTransaction").post(request);
+        // Set the timer
+        F32 timeout(10);
+        watchdog.eventAfter(timeout, LLSD().insert("timeout", 0));
+        // and pump "mainloop" until we get something, whether from
+        // LLXMLRPCListener or from the watchdog filter.
+        LLTimer timer;
+        F32 start = timer.getElapsedTimeF32();
+        LLEventPump& mainloop(pumps.obtain("mainloop"));
+        while (reply.isUndefined())
+        {
+            mainloop.post(LLSD());
+        }
+        ensure("timeout works", (timer.getElapsedTimeF32() - start) < (timeout + 1));
+        ensure_equals(reply["responses"]["hi_there"].asString(), "Hello, world!");
+    }
+
+    template<> template<>
+    void object::test<4>()
+    {
+        set_test_name("bogus method");
+        LLSD request;
+        request["uri"] = uri;
+        request["method"] = "goodbye";
+        request["reply"] = "reply";
+        LLSD& params(request["params"]);
+        params["who"] = "world";
+        // Set up a timeout filter so we don't spin forever waiting.
+        LLEventTimeout watchdog;
+        // Connect the timeout filter to the reply pump.
+        LLTempBoundListener temp(
+            pumps.obtain("reply").
+            listen("watchdog", boost::bind(&LLEventTimeout::post, boost::ref(watchdog), _1)));
+        // Now connect our target listener to the timeout filter.
+        watchdog.listen("captureReply", boost::bind(&data::captureReply, this, _1));
+        // Kick off the request...
+        reply.clear();
+        pumps.obtain("LLXMLRPCTransaction").post(request);
+        // Set the timer
+        F32 timeout(10);
+        watchdog.eventAfter(timeout, LLSD().insert("timeout", 0));
+        // and pump "mainloop" until we get something, whether from
+        // LLXMLRPCListener or from the watchdog filter.
+        LLTimer timer;
+        F32 start = timer.getElapsedTimeF32();
+        LLEventPump& mainloop(pumps.obtain("mainloop"));
+        while (reply.isUndefined())
+        {
+            mainloop.post(LLSD());
+        }
+        ensure("timeout works", (timer.getElapsedTimeF32() - start) < (timeout + 1));
+        ensure_equals("XMLRPC error", reply["status"].asString(), "XMLRPCError");
+    }
+
+    template<> template<>
+    void object::test<5>()
+    {
+        set_test_name("bad type");
+        LLSD request;
+        request["uri"] = uri;
+        request["method"] = "getdict";
+        request["reply"] = "reply";
+        (void)request["params"];
+        // Set up a timeout filter so we don't spin forever waiting.
+        LLEventTimeout watchdog;
+        // Connect the timeout filter to the reply pump.
+        LLTempBoundListener temp(
+            pumps.obtain("reply").
+            listen("watchdog", boost::bind(&LLEventTimeout::post, boost::ref(watchdog), _1)));
+        // Now connect our target listener to the timeout filter.
+        watchdog.listen("captureReply", boost::bind(&data::captureReply, this, _1));
+        // Kick off the request...
+        reply.clear();
+        pumps.obtain("LLXMLRPCTransaction").post(request);
+        // Set the timer
+        F32 timeout(10);
+        watchdog.eventAfter(timeout, LLSD().insert("timeout", 0));
+        // and pump "mainloop" until we get something, whether from
+        // LLXMLRPCListener or from the watchdog filter.
+        LLTimer timer;
+        F32 start = timer.getElapsedTimeF32();
+        LLEventPump& mainloop(pumps.obtain("mainloop"));
+        while (reply.isUndefined())
+        {
+            mainloop.post(LLSD());
+        }
+        ensure("timeout works", (timer.getElapsedTimeF32() - start) < (timeout + 1));
+        ensure_equals(reply["status"].asString(), "BadType");
+        ensure_contains("bad type", reply["responses"]["nested_dict"].asString(), "bad XMLRPC type");
+    }
+} // namespace tut
+
+/*****************************************************************************
+*   Resolve link errors: use real machinery here, since we intend to exchange
+*   actual XML with a peer process.
+*****************************************************************************/
+// Including llxmlrpctransaction.cpp drags in the static LLXMLRPCListener
+// instantiated there. That's why it works to post requests to the LLEventPump
+// named "LLXMLRPCTransaction".
+#include "../llxmlrpctransaction.cpp"
+#include "llcontrol.cpp"
+#include "llxmltree.cpp"
+#include "llxmlparser.cpp"
diff --git a/indra/newview/tests/test_llxmlrpc_peer.py b/indra/newview/tests/test_llxmlrpc_peer.py
new file mode 100644
index 0000000000..cb8f7d26c4
--- /dev/null
+++ b/indra/newview/tests/test_llxmlrpc_peer.py
@@ -0,0 +1,59 @@
+#!/usr/bin/python
+"""\
+@file   test_llxmlrpc_peer.py
+@author Nat Goodspeed
+@date   2008-10-09
+@brief  This script asynchronously runs the executable (with args) specified on
+        the command line, returning its result code. While that executable is
+        running, we provide dummy local services for use by C++ tests.
+
+$LicenseInfo:firstyear=2008&license=viewergpl$
+Copyright (c) 2008, Linden Research, Inc.
+$/LicenseInfo$
+"""
+
+import os
+import sys
+from threading import Thread
+from SimpleXMLRPCServer import SimpleXMLRPCServer
+
+mydir = os.path.dirname(__file__)       # expected to be .../indra/newview/tests/
+sys.path.insert(0, os.path.join(mydir, os.pardir, os.pardir, "lib", "python"))
+sys.path.insert(1, os.path.join(mydir, os.pardir, os.pardir, "llmessage", "tests"))
+from testrunner import run, debug
+
+class TestServer(SimpleXMLRPCServer):
+    def _dispatch(self, method, params):
+        try:
+            func = getattr(self, method)
+        except AttributeError:
+            raise Exception('method "%s" is not supported' % method)
+        else:
+            # LLXMLRPCListener constructs XMLRPC parameters that arrive as a
+            # 1-tuple containing a dict.
+            return func(**(params[0]))
+
+    def hello(self, who):
+        # LLXMLRPCListener expects a dict return.
+        return {"hi_there": "Hello, %s!" % who}
+
+    def getdict(self):
+        return dict(nested_dict=dict(a=17, b=5))
+
+    def log_request(self, code, size=None):
+        # For present purposes, we don't want the request splattered onto
+        # stderr, as it would upset devs watching the test run
+        pass
+
+    def log_error(self, format, *args):
+        # Suppress error output as well
+        pass
+
+class ServerRunner(Thread):
+    def run(self):
+        server = TestServer(('127.0.0.1', 8000))
+        debug("Starting XMLRPC server...\n")
+        server.serve_forever()
+
+if __name__ == "__main__":
+    sys.exit(run(server=ServerRunner(name="xmlrpc"), *sys.argv[1:]))