Merge branch 'mccabe-plugins' into plugins_merge

Conflicts:
	linden/doc/contributions.txt
	linden/indra/cmake/GStreamer.cmake
	linden/indra/cmake/LLMedia.cmake
	linden/indra/cmake/OPENAL.cmake
	linden/indra/llmedia/CMakeLists.txt
	linden/indra/llprimitive/material_codes.h
	linden/indra/newview/chatbar_as_cmdline.cpp
	linden/indra/newview/llappviewer.cpp
	linden/indra/newview/llfloatertos.cpp
	linden/indra/newview/llstartup.cpp
	linden/indra/newview/llviewerwindow.cpp
	linden/indra/newview/llvoavatar.cpp
	linden/indra/newview/pipeline.cpp
	linden/indra/newview/pipeline.h
	linden/indra/newview/viewer_manifest.py
	linden/install.xml

11 files changed, 1164 insertions, 0 deletions

diff --git a/linden/indra/llmessage/tests/commtest.h b/linden/indra/llmessage/tests/commtest.h
new file mode 100644
index 0000000..cf1461e
--- /dev/null
+++ b/linden/indra/llmessage/tests/commtest.h
@@ -0,0 +1,83 @@
+/**
+ * @file   commtest.h
+ * @author Nat Goodspeed
+ * @date   2009-01-09
+ * @brief  
+ * 
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * 
+ * Copyright (c) 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$
+ */
+
+#if ! defined(LL_COMMTEST_H)
+#define LL_COMMTEST_H
+
+#include "networkio.h"
+#include "llevents.h"
+#include "llsd.h"
+#include "llhost.h"
+#include "stringize.h"
+#include <string>
+
+/**
+ * This struct is shared by a couple of standalone comm tests (ADD_COMM_BUILD_TEST).
+ */
+struct commtest_data
+{
+    NetworkIO& netio;
+    LLEventPumps& pumps;
+    LLEventStream replyPump, errorPump;
+    LLSD result;
+    bool success;
+    LLHost host;
+    std::string server;
+
+    commtest_data():
+        netio(NetworkIO::instance()),
+        pumps(LLEventPumps::instance()),
+        replyPump("reply"),
+        errorPump("error"),
+        success(false),
+        host("127.0.0.1", 8000),
+        server(STRINGIZE("http://" << host.getString() << "/"))
+    {
+        replyPump.listen("self", boost::bind(&commtest_data::outcome, this, _1, true));
+        errorPump.listen("self", boost::bind(&commtest_data::outcome, this, _1, false));
+    }
+
+    bool outcome(const LLSD& _result, bool _success)
+    {
+//      std::cout << "commtest_data::outcome(" << _result << ", " << _success << ")\n";
+        result = _result;
+        success = _success;
+        // Break the wait loop in NetworkIO::pump(), otherwise devs get
+        // irritated at making the big monolithic test executable take longer
+        pumps.obtain("done").post(success);
+        return false;
+    }
+};
+
+#endif /* ! defined(LL_COMMTEST_H) */
diff --git a/linden/indra/llmessage/tests/llcurl_stub.cpp b/linden/indra/llmessage/tests/llcurl_stub.cpp
new file mode 100644
index 0000000..c73a565
--- /dev/null
+++ b/linden/indra/llmessage/tests/llcurl_stub.cpp
@@ -0,0 +1,100 @@
+/**
+ * @file llcurl_stub.cpp
+ * @brief stub class to allow unit testing
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-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 "llcurl.h"
+
+LLCurl::Responder::Responder() : mReferenceCount(0)
+{
+}
+
+void LLCurl::Responder::completed(U32 status, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const &reason,
+                                                                  LLSD const& mContent)
+{
+        if (isGoodStatus(status))
+        {
+                result(mContent);
+        }
+        else
+        {
+                error(status, reason, mContent);
+        }
+}
+
+void LLCurl::Responder::completedHeader(unsigned,
+                                                                                std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&,
+                                                                                LLSD const&)
+{
+}
+
+void LLCurl::Responder::completedRaw(unsigned,
+                                                                         std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&,
+                                                                         LLChannelDescriptors const&,
+                                                                         boost::shared_ptr<LLBufferArray> const&)
+{
+}
+
+void LLCurl::Responder::error(unsigned,
+                                                          std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&,
+                                                          LLSD const&)
+{
+}
+
+LLCurl::Responder::~Responder ()
+{
+}
+
+void LLCurl::Responder::error(unsigned,
+                                                          std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)
+{
+}
+
+void LLCurl::Responder::result(LLSD const&)
+{
+}
+
+namespace boost
+{
+        void intrusive_ptr_add_ref(LLCurl::Responder* p)
+        {
+                ++p->mReferenceCount;
+        }
+
+        void intrusive_ptr_release(LLCurl::Responder* p)
+        {
+                if(p && 0 == --p->mReferenceCount)
+                {
+                        delete p;
+                }
+        }
+};
+
diff --git a/linden/indra/llmessage/tests/llhttpclientadapter_test.cpp b/linden/indra/llmessage/tests/llhttpclientadapter_test.cpp
new file mode 100644
index 0000000..7065c9d
--- /dev/null
+++ b/linden/indra/llmessage/tests/llhttpclientadapter_test.cpp
@@ -0,0 +1,170 @@
+/** 
+ * @file 
+ * @brief 
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-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 "llhttpclientadapter.h"
+
+#include "../test/lltut.h"
+#include "llhttpclient.h"
+#include "llcurl_stub.cpp"
+
+float const HTTP_REQUEST_EXPIRY_SECS = 1.0F;
+
+std::vector<std::string> get_urls;
+std::vector<boost::intrusive_ptr<LLCurl::Responder> > get_responders;
+void LLHTTPClient::get(const std::string& url, boost::intrusive_ptr<LLCurl::Responder> responder, const LLSD& headers, const F32 timeout)
+{
+        get_urls.push_back(url);
+        get_responders.push_back(responder);
+}
+
+std::vector<std::string> put_urls;
+std::vector<LLSD> put_body;
+std::vector<boost::intrusive_ptr<LLCurl::Responder> > put_responders;
+
+void LLHTTPClient::put(const std::string& url, const LLSD& body, boost::intrusive_ptr<LLCurl::Responder> responder, const LLSD& headers, const F32 timeout)
+{
+        put_urls.push_back(url);
+        put_responders.push_back(responder);
+        put_body.push_back(body);
+
+}
+
+
+namespace tut
+{
+        struct LLHTTPClientAdapterData
+        {
+                LLHTTPClientAdapterData()
+                {
+                        get_urls.clear();
+                        get_responders.clear();
+                        put_urls.clear();
+                        put_responders.clear();
+                        put_body.clear();
+                }
+        };
+
+        typedef test_group<LLHTTPClientAdapterData> factory;
+        typedef factory::object object;
+}
+
+namespace
+{
+        tut::factory tf("LLHTTPClientAdapterData test");
+}
+
+namespace tut
+{
+        // Ensure we can create the object
+        template<> template<>
+        void object::test<1>()
+        {
+                LLHTTPClientAdapter adapter;
+        }
+
+        // Does the get pass the appropriate arguments to the LLHTTPClient
+        template<> template<>
+        void object::test<2>()
+        {
+                LLHTTPClientAdapter adapter;
+
+                boost::intrusive_ptr<LLCurl::Responder> responder = new LLCurl::Responder();
+
+                adapter.get("Made up URL", responder);
+                ensure_equals(get_urls.size(), 1);
+                ensure_equals(get_urls[0], "Made up URL");
+        }
+
+        // Ensure the responder matches the one passed to get
+        template<> template<>
+        void object::test<3>()
+        {
+                LLHTTPClientAdapter adapter;
+                boost::intrusive_ptr<LLCurl::Responder> responder = new LLCurl::Responder();
+
+                adapter.get("Made up URL", responder);
+
+                ensure_equals(get_responders.size(), 1);
+                ensure_equals(get_responders[0].get(), responder.get());
+        }
+        
+        // Ensure the correct url is used in the put
+        template<> template<>
+        void object::test<4>()
+        {
+                LLHTTPClientAdapter adapter;
+
+                boost::intrusive_ptr<LLCurl::Responder> responder = new LLCurl::Responder();
+
+                LLSD body;
+                body["TestBody"] = "Foobar";
+
+                adapter.put("Made up URL", body, responder);
+                ensure_equals(put_urls.size(), 1);
+                ensure_equals(put_urls[0], "Made up URL");
+        }
+
+        // Ensure the correct responder is used by put
+        template<> template<>
+        void object::test<5>()
+        {
+                LLHTTPClientAdapter adapter;
+
+                boost::intrusive_ptr<LLCurl::Responder> responder = new LLCurl::Responder();
+
+                LLSD body;
+                body["TestBody"] = "Foobar";
+
+                adapter.put("Made up URL", body, responder);
+
+                ensure_equals(put_responders.size(), 1);
+                ensure_equals(put_responders[0].get(), responder.get());
+        }
+
+        // Ensure the message body is passed through the put properly
+        template<> template<>
+        void object::test<6>()
+        {
+                LLHTTPClientAdapter adapter;
+
+                boost::intrusive_ptr<LLCurl::Responder> responder = new LLCurl::Responder();
+
+                LLSD body;
+                body["TestBody"] = "Foobar";
+
+                adapter.put("Made up URL", body, responder);
+
+                ensure_equals(put_body.size(), 1);
+                ensure_equals(put_body[0]["TestBody"].asString(), "Foobar");
+        }
+}
+
diff --git a/linden/indra/llmessage/tests/lltemplatemessagedispatcher_test.cpp b/linden/indra/llmessage/tests/lltemplatemessagedispatcher_test.cpp
new file mode 100644
index 0000000..d57f17f
--- /dev/null
+++ b/linden/indra/llmessage/tests/lltemplatemessagedispatcher_test.cpp
@@ -0,0 +1,165 @@
+/**
+ * @file lltrustedmessageservice_test.cpp
+ * @brief LLTrustedMessageService unit tests
+ *
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * 
+ * Copyright (c) 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 "lltemplatemessagedispatcher.h"
+#include "lltut.h"
+
+#include "llhttpnode.h"
+#include "llhost.h"
+#include "message.h"
+#include "llsd.h"
+
+#include "llhost.cpp" // Needed for copy operator
+#include "net.cpp" // Needed by LLHost.
+
+LLMessageSystem * gMessageSystem = NULL;
+
+// sensor test doubles
+bool gClearRecvWasCalled = false;
+void LLMessageSystem::clearReceiveState(void) 
+{ 
+        gClearRecvWasCalled = true; 
+}
+
+char gUdpDispatchedData[MAX_BUFFER_SIZE];
+bool gUdpDispatchWasCalled = false;
+BOOL LLTemplateMessageReader::readMessage(const U8* data,class LLHost const &) 
+{ 
+        gUdpDispatchWasCalled = true;
+        strcpy(gUdpDispatchedData, reinterpret_cast<const char*>(data));
+        return  true;
+}
+
+BOOL gValidateMessage = FALSE;
+BOOL LLTemplateMessageReader::validateMessage(const U8*, S32 buffer_size, LLHost const &sender, bool trusted) 
+{ 
+        return gValidateMessage;
+}
+
+LLHost host;
+const LLHost& LLMessageSystem::getSender() const 
+{ 
+        return host; 
+}
+
+const char* gBinaryTemplateData = "BINARYTEMPLATEDATA";
+void fillVector(std::vector<U8>& vector_data, const char* data)
+{
+        vector_data.resize(strlen(data) + 1);
+        strcpy(reinterpret_cast<char*>(&vector_data[0]), data);
+}
+
+namespace tut
+{
+                static LLTemplateMessageReader::message_template_number_map_t numberMap;
+
+                struct LLTemplateMessageDispatcherData
+                {
+                        LLTemplateMessageDispatcherData()
+                        {
+                                mMessageName = "MessageName";
+                                gUdpDispatchWasCalled = false;
+                                gClearRecvWasCalled = false;
+                                gValidateMessage = FALSE;
+                                mMessage["body"]["binary-template-data"] = std::vector<U8>();
+                        }
+
+                        LLSD mMessage;
+                        LLHTTPNode::ResponsePtr mResponsePtr;
+                        std::string mMessageName;
+                };
+
+        typedef test_group<LLTemplateMessageDispatcherData> factory;
+        typedef factory::object object;
+}
+
+namespace
+{
+        tut::factory tf("LLTemplateMessageDispatcher test");
+}
+
+namespace tut
+{
+        // does an empty message stop processing?
+        template<> template<>
+        void object::test<1>()
+        {
+                LLTemplateMessageReader* pReader = NULL;
+                LLTemplateMessageDispatcher t(*pReader);
+                t.dispatch(mMessageName, mMessage, mResponsePtr);
+                ensure(! gUdpDispatchWasCalled);
+                ensure(! gClearRecvWasCalled);
+        }
+
+        // does the disaptch invoke the udp send method?
+        template<> template<>
+        void object::test<2>()
+        {
+                LLTemplateMessageReader* pReader = NULL;
+                LLTemplateMessageDispatcher t(*pReader);
+                gValidateMessage = TRUE;
+                std::vector<U8> vector_data;
+                fillVector(vector_data, gBinaryTemplateData);           
+                mMessage["body"]["binary-template-data"] = vector_data;
+                t.dispatch(mMessageName, mMessage, mResponsePtr);
+                ensure("udp dispatch was called", gUdpDispatchWasCalled);
+        }
+
+        // what if the message wasn't valid? We would hope the message gets cleared!
+        template<> template<>
+        void object::test<3>()
+        {
+                LLTemplateMessageReader* pReader = NULL;
+                LLTemplateMessageDispatcher t(*pReader);
+                std::vector<U8> vector_data;
+                fillVector(vector_data, gBinaryTemplateData);
+                mMessage["body"]["binary-template-data"] = vector_data;
+                gValidateMessage = FALSE;
+                t.dispatch(mMessageName, mMessage, mResponsePtr);
+                ensure("clear received message was called", gClearRecvWasCalled);
+        }
+
+        // is the binary data passed through correctly?
+        template<> template<>
+        void object::test<4>()
+        {
+                LLTemplateMessageReader* pReader = NULL;
+                LLTemplateMessageDispatcher t(*pReader);
+                gValidateMessage = TRUE;
+                std::vector<U8> vector_data;
+                fillVector(vector_data, gBinaryTemplateData);
+                mMessage["body"]["binary-template-data"] = vector_data;
+                t.dispatch(mMessageName, mMessage, mResponsePtr);
+                ensure("data couriered correctly", strcmp(gBinaryTemplateData, gUdpDispatchedData) == 0);
+        }
+}
+
diff --git a/linden/indra/llmessage/tests/lltesthttpclientadapter.cpp b/linden/indra/llmessage/tests/lltesthttpclientadapter.cpp
new file mode 100644
index 0000000..6361f1c
--- /dev/null
+++ b/linden/indra/llmessage/tests/lltesthttpclientadapter.cpp
@@ -0,0 +1,67 @@
+/** 
+ * @file 
+ * @brief 
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-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 "lltesthttpclientadapter.h"
+
+LLTestHTTPClientAdapter::LLTestHTTPClientAdapter()
+{
+}
+
+LLTestHTTPClientAdapter::~LLTestHTTPClientAdapter()
+{
+}
+
+void LLTestHTTPClientAdapter::get(const std::string& url, LLCurl::ResponderPtr responder)
+{
+        mGetUrl.push_back(url);
+        mGetResponder.push_back(responder);
+}
+
+void LLTestHTTPClientAdapter::put(const std::string& url, const LLSD& body, LLCurl::ResponderPtr responder)
+{
+        mPutUrl.push_back(url);
+        mPutBody.push_back(body);
+        mPutResponder.push_back(responder);
+}
+
+U32 LLTestHTTPClientAdapter::putCalls() const 
+{ 
+        return mPutUrl.size(); 
+}
+
+void LLTestHTTPClientAdapter::get(const std::string& url, LLCurl::ResponderPtr responder, const LLSD& headers)
+{
+        mGetUrl.push_back(url);
+        mGetHeaders.push_back(headers);
+        mGetResponder.push_back(responder);
+}
+
+
diff --git a/linden/indra/llmessage/tests/lltesthttpclientadapter.h b/linden/indra/llmessage/tests/lltesthttpclientadapter.h
new file mode 100644
index 0000000..ac2afa8
--- /dev/null
+++ b/linden/indra/llmessage/tests/lltesthttpclientadapter.h
@@ -0,0 +1,63 @@
+/** 
+ * @file 
+ * @brief 
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-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$
+ */
+
+/* Macro Definitions */
+#ifndef LL_LLTESTHTTPCLIENTADAPTER_H
+#define LL_LLTESTHTTPCLIENTADAPTER_H
+
+
+#include "linden_common.h"
+#include "llhttpclientinterface.h"
+
+class LLTestHTTPClientAdapter : public LLHTTPClientInterface
+{
+public:
+        LLTestHTTPClientAdapter();
+        virtual ~LLTestHTTPClientAdapter();
+        virtual void get(const std::string& url, LLCurl::ResponderPtr responder);
+        virtual void get(const std::string& url, LLCurl::ResponderPtr responder, const LLSD& headers);
+
+        virtual void put(const std::string& url, const LLSD& body, LLCurl::ResponderPtr responder);
+        U32 putCalls() const;
+
+        std::vector<LLSD> mPutBody;
+        std::vector<LLSD> mGetHeaders;
+        std::vector<std::string> mPutUrl;
+        std::vector<std::string> mGetUrl;
+        std::vector<LLCurl::ResponderPtr> mPutResponder;
+        std::vector<LLCurl::ResponderPtr> mGetResponder;
+};
+
+
+
+#endif //LL_LLSIMULATORPRESENCESENDER_H
+
diff --git a/linden/indra/llmessage/tests/lltestmessagesender.cpp b/linden/indra/llmessage/tests/lltestmessagesender.cpp
new file mode 100644
index 0000000..5e8a87f
--- /dev/null
+++ b/linden/indra/llmessage/tests/lltestmessagesender.cpp
@@ -0,0 +1,44 @@
+/** 
+ * @file 
+ * @brief 
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-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 "lltestmessagesender.h"
+
+LLTestMessageSender::~LLTestMessageSender()
+{
+}
+
+
+S32 LLTestMessageSender::sendMessage(const LLHost& host, LLStoredMessagePtr message)
+{
+        mSendHosts.push_back(host);
+        mSendMessages.push_back(message);
+        return 0;
+}
diff --git a/linden/indra/llmessage/tests/lltestmessagesender.h b/linden/indra/llmessage/tests/lltestmessagesender.h
new file mode 100644
index 0000000..f57210e
--- /dev/null
+++ b/linden/indra/llmessage/tests/lltestmessagesender.h
@@ -0,0 +1,57 @@
+/** 
+ * @file 
+ * @brief 
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-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$
+ */
+
+/* Macro Definitions */
+#ifndef LL_LLTESTMESSAGESENDER_H
+#define LL_LLTESTMESSAGESENDER_H
+
+
+#include "linden_common.h"
+#include "llmessagesenderinterface.h"
+#include <vector>
+
+
+
+class LLTestMessageSender : public LLMessageSenderInterface
+{
+public:
+        virtual ~LLTestMessageSender();
+        virtual S32 sendMessage(const LLHost& host, LLStoredMessagePtr message);
+
+        std::vector<LLHost> mSendHosts;
+        std::vector<LLStoredMessagePtr> mSendMessages;
+};
+
+
+
+#endif //LL_LLTESTMESSAGESENDER_H
+
diff --git a/linden/indra/llmessage/tests/lltrustedmessageservice_test.cpp b/linden/indra/llmessage/tests/lltrustedmessageservice_test.cpp
new file mode 100644
index 0000000..0a3da4b
--- /dev/null
+++ b/linden/indra/llmessage/tests/lltrustedmessageservice_test.cpp
@@ -0,0 +1,146 @@
+/**
+ * @file lltrustedmessageservice_test.cpp
+ * @brief LLTrustedMessageService unit tests
+ *
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * 
+ * Copyright (c) 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 "lltrustedmessageservice.h"
+#include "../test/lltut.h"
+
+#include "llhost.cpp" // LLHost is a value type for test purposes.
+#include "net.cpp" // Needed by LLHost.
+
+#include "message.h"
+#include "llmessageconfig.h"
+
+LLMessageSystem* gMessageSystem = NULL;
+
+LLMessageConfig::SenderTrust
+LLMessageConfig::getSenderTrustedness(const std::string& msg_name)
+{
+        return LLMessageConfig::NOT_SET;
+}
+
+void LLMessageSystem::receivedMessageFromTrustedSender()
+{
+}
+
+bool LLMessageSystem::isTrustedSender(const LLHost& host) const
+{
+        return false;
+}
+
+bool LLMessageSystem::isTrustedMessage(const std::string& name) const
+{
+        return false;
+}
+
+bool messageDispatched = false;
+bool messageDispatchedAsBinary = false;
+LLSD lastLLSD;
+std::string lastMessageName;
+
+void LLMessageSystem::dispatch(const std::string& msg_name,
+                                                           const LLSD& message,
+                                                           LLHTTPNode::ResponsePtr responsep)
+{
+        messageDispatched = true;
+        lastLLSD = message;
+        lastMessageName = msg_name;
+}
+
+void LLMessageSystem::dispatchTemplate(const std::string& msg_name,
+                                                 const LLSD& message,
+                                                 LLHTTPNode::ResponsePtr responsep)
+{
+        lastLLSD = message;
+        lastMessageName = msg_name;
+        messageDispatchedAsBinary = true;
+}
+
+namespace tut
+{
+            struct LLTrustedMessageServiceData
+                {
+                        LLTrustedMessageServiceData()
+                        {
+                                LLSD emptyLLSD;
+                                lastLLSD = emptyLLSD;
+                                lastMessageName = "uninitialised message name";
+                                messageDispatched = false;
+                                messageDispatchedAsBinary = false;
+                        }
+                };
+
+        typedef test_group<LLTrustedMessageServiceData> factory;
+        typedef factory::object object;
+}
+
+namespace
+{
+        tut::factory tf("LLTrustedMessageServiceData test");
+}
+
+namespace tut
+{
+        // characterisation tests
+
+        // 1) test that messages get forwarded with names etc. as current behaviour (something like LLMessageSystem::dispatch(name, data...)
+
+        // test llsd messages are sent as normal using LLMessageSystem::dispatch() (eventually)
+        template<> template<>
+        void object::test<1>()
+        {
+                LLHTTPNode::ResponsePtr response;
+                LLSD input;
+                LLSD context;
+                LLTrustedMessageService adapter;
+                adapter.post(response, context, input);
+                // test original ting got called wit nowt, ya get me blood?
+                ensure_equals(messageDispatched, true);
+                ensure(lastLLSD.has("body"));
+        }
+
+        // test that llsd wrapped binary-template-data messages are 
+        // sent via LLMessageSystem::binaryDispatch() or similar
+        template<> template<>
+        void object::test<2>()
+        {
+                LLHTTPNode::ResponsePtr response;
+                LLSD input;
+                input["binary-template-data"] = "10001010110"; //make me a message here.
+                LLSD context;
+                LLTrustedMessageService adapter;
+
+                adapter.post(response, context, input);
+                ensure("check template-binary-data message was dispatched as binary", messageDispatchedAsBinary);
+                ensure_equals(lastLLSD["body"]["binary-template-data"].asString(),  "10001010110");
+                // test somit got called with "10001010110" (something like LLMessageSystem::dispatchTemplate(blah))
+        }
+}
diff --git a/linden/indra/llmessage/tests/networkio.h b/linden/indra/llmessage/tests/networkio.h
new file mode 100644
index 0000000..0ebe369
--- /dev/null
+++ b/linden/indra/llmessage/tests/networkio.h
@@ -0,0 +1,116 @@
+/**
+ * @file   networkio.h
+ * @author Nat Goodspeed
+ * @date   2009-01-09
+ * @brief  
+ * 
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * 
+ * Copyright (c) 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$
+ */
+
+#if ! defined(LL_NETWORKIO_H)
+#define LL_NETWORKIO_H
+
+#include "llmemory.h"               // LLSingleton
+#include "llapr.h"
+#include "llares.h"
+#include "llpumpio.h"
+#include "llhttpclient.h"
+
+/*****************************************************************************
+*   NetworkIO
+*****************************************************************************/
+// Doing this initialization in a class constructor makes sense. But we don't
+// want to redo it for each different test. Nor do we want to do it at static-
+// init time. Use the lazy, on-demand initialization we get from LLSingleton.
+class NetworkIO: public LLSingleton<NetworkIO>
+{
+public:
+    NetworkIO():
+        mServicePump(NULL),
+        mDone(false)
+    {
+        ll_init_apr();
+        if (! gAPRPoolp)
+        {
+            throw std::runtime_error("Can't initialize APR");
+        }
+
+        // Create IO Pump to use for HTTP Requests.
+        mServicePump = new LLPumpIO(gAPRPoolp);
+        LLHTTPClient::setPump(*mServicePump);
+        if (ll_init_ares() == NULL || !gAres->isInitialized())
+        {
+            throw std::runtime_error("Can't start DNS resolver");
+        }
+
+        // You can interrupt pump() without waiting the full timeout duration
+        // by posting an event to the LLEventPump named "done".
+        LLEventPumps::instance().obtain("done").listen("self",
+                                                       boost::bind(&NetworkIO::done, this, _1));
+    }
+
+    bool pump(F32 timeout=10)
+    {
+        // Reset the done flag so we don't pop out prematurely
+        mDone = false;
+        // Evidently the IO structures underlying LLHTTPClient need to be
+        // "pumped". Do some stuff normally performed in the viewer's main
+        // loop.
+        LLTimer timer;
+        while (timer.getElapsedTimeF32() < timeout)
+        {
+            if (mDone)
+            {
+//              std::cout << "NetworkIO::pump(" << timeout << "): breaking loop after "
+//                        << timer.getElapsedTimeF32() << " seconds\n";
+                return true;
+            }
+            pumpOnce();
+        }
+        return false;
+    }
+
+    void pumpOnce()
+    {
+        gAres->process();
+        mServicePump->pump();
+        mServicePump->callback();
+    }
+
+    bool done(const LLSD&)
+    {
+        mDone = true;
+        return false;
+    }
+
+private:
+    LLPumpIO* mServicePump;
+    bool mDone;
+};
+
+#endif /* ! defined(LL_NETWORKIO_H) */
diff --git a/linden/indra/llmessage/tests/test_llsdmessage_peer.py b/linden/indra/llmessage/tests/test_llsdmessage_peer.py
new file mode 100644
index 0000000..655169d
--- /dev/null
+++ b/linden/indra/llmessage/tests/test_llsdmessage_peer.py
@@ -0,0 +1,153 @@
+#!/usr/bin/python
+"""\
+@file   test_llsdmessage_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-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$
+"""
+
+import os
+import sys
+from threading import Thread
+from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
+mydir = os.path.dirname(__file__)       # expected to be .../indra/llmessage/tests/
+sys.path.insert(0, os.path.join(mydir, os.pardir, os.pardir, "lib", "python"))
+from indra.util.fastest_elementtree import parse as xml_parse
+from indra.base import llsd
+
+def debug(*args):
+    sys.stdout.writelines(args)
+    sys.stdout.flush()
+# comment out the line below to enable debug output
+debug = lambda *args: None
+
+class TestHTTPRequestHandler(BaseHTTPRequestHandler):
+    """This subclass of BaseHTTPRequestHandler is to receive and echo
+    LLSD-flavored messages sent by the C++ LLHTTPClient.
+    """
+    def read(self):
+        # The following logic is adapted from the library module
+        # SimpleXMLRPCServer.py.
+        # Get arguments by reading body of request.
+        # We read this in chunks to avoid straining
+        # socket.read(); around the 10 or 15Mb mark, some platforms
+        # begin to have problems (bug #792570).
+        try:
+            size_remaining = int(self.headers["content-length"])
+        except (KeyError, ValueError):
+            return ""
+        max_chunk_size = 10*1024*1024
+        L = []
+        while size_remaining:
+            chunk_size = min(size_remaining, max_chunk_size)
+            chunk = self.rfile.read(chunk_size)
+            L.append(chunk)
+            size_remaining -= len(chunk)
+        return ''.join(L)
+        # end of swiped read() logic
+
+    def read_xml(self):
+        # This approach reads the entire POST data into memory first
+        return llsd.parse(self.read())
+##         # This approach attempts to stream in the LLSD XML from self.rfile,
+##         # assuming that the underlying XML parser reads its input file
+##         # incrementally. Unfortunately I haven't been able to make it work.
+##         tree = xml_parse(self.rfile)
+##         debug("Finished raw parse\n")
+##         debug("parsed XML tree %s\n" % tree)
+##         debug("parsed root node %s\n" % tree.getroot())
+##         debug("root node tag %s\n" % tree.getroot().tag)
+##         return llsd.to_python(tree.getroot())
+
+    def do_GET(self):
+        # Of course, don't attempt to read data.
+        self.answer(dict(reply="success", status=500,
+                         reason="Your GET operation requested failure"))
+
+    def do_POST(self):
+        # Read the provided POST data.
+        self.answer(self.read_xml())
+
+    def answer(self, data):
+        if "fail" not in self.path:
+            response = llsd.format_xml(data.get("reply", llsd.LLSD("success")))
+            self.send_response(200)
+            self.send_header("Content-type", "application/llsd+xml")
+            self.send_header("Content-Length", str(len(response)))
+            self.end_headers()
+            self.wfile.write(response)
+        else:                           # fail requested
+            status = data.get("status", 500)
+            reason = data.get("reason",
+                               self.responses.get(status,
+                                                  ("fail requested",
+                                                   "Your request specified failure status %s "
+                                                   "without providing a reason" % status))[1])
+            self.send_error(status, reason)
+
+    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 TestHTTPServer(Thread):
+    def run(self):
+        httpd = HTTPServer(('127.0.0.1', 8000), TestHTTPRequestHandler)
+        debug("Starting HTTP server...\n")
+        httpd.serve_forever()
+
+def main(*args):
+    # Start HTTP server thread. Note that this and all other comm server
+    # threads should be daemon threads: we'll let them run "forever,"
+    # confident that the whole process will terminate when the main thread
+    # terminates, which will be when the test executable child process
+    # terminates.
+    httpThread = TestHTTPServer(name="httpd")
+    httpThread.setDaemon(True)
+    httpThread.start()
+    # choice of os.spawnv():
+    # - [v vs. l] pass a list of args vs. individual arguments,
+    # - [no p] don't use the PATH because we specifically want to invoke the
+    #   executable passed as our first arg,
+    # - [no e] child should inherit this process's environment.
+    debug("Running %s...\n" % (" ".join(args)))
+    sys.stdout.flush()
+    rc = os.spawnv(os.P_WAIT, args[0], args)
+    debug("%s returned %s\n" % (args[0], rc))
+    return rc
+
+if __name__ == "__main__":
+    sys.exit(main(*sys.argv[1:]))