22 files changed, 935 insertions, 86 deletions

diff --git a/OpenSim/Tests/Common/Helpers/BaseRequestHandlerHelpers.cs b/OpenSim/Tests/Common/Helpers/BaseRequestHandlerHelpers.cs
index 49c99c5..82ecf9a 100644
--- a/OpenSim/Tests/Common/Helpers/BaseRequestHandlerHelpers.cs
+++ b/OpenSim/Tests/Common/Helpers/BaseRequestHandlerHelpers.cs
@@ -32,7 +32,6 @@ using NUnit.Framework;
 using OpenSim.Framework;
 using OpenSim.Framework.Servers;
 using OpenSim.Framework.Servers.HttpServer;
-using OpenSim.Tests.Common.Mock;
 
 namespace OpenSim.Tests.Common
 {
diff --git a/OpenSim/Tests/Common/Helpers/ClientStackHelpers.cs b/OpenSim/Tests/Common/Helpers/ClientStackHelpers.cs
new file mode 100644
index 0000000..33cd8a2
--- /dev/null
+++ b/OpenSim/Tests/Common/Helpers/ClientStackHelpers.cs
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Region.ClientStack.LindenUDP;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Tests.Common
+{
+    /// <summary>
+    /// This class adds full UDP client classes and associated scene presence to scene.
+    /// </summary>
+    /// <remarks>
+    /// This is used for testing client stack code.  For testing other code, use SceneHelper methods instead since
+    /// they operate without the burden of setting up UDP structures which should be unnecessary for testing scene
+    /// code.
+    /// </remarks>
+    public static class ClientStackHelpers
+    {
+        public static ScenePresence AddChildClient(
+            Scene scene, LLUDPServer udpServer, UUID agentId, UUID sessionId, uint circuitCode)
+        {           
+            IPEndPoint testEp = new IPEndPoint(IPAddress.Loopback, 999);
+
+            UseCircuitCodePacket uccp = new UseCircuitCodePacket();
+
+            UseCircuitCodePacket.CircuitCodeBlock uccpCcBlock
+                = new UseCircuitCodePacket.CircuitCodeBlock();
+            uccpCcBlock.Code = circuitCode;
+            uccpCcBlock.ID = agentId;
+            uccpCcBlock.SessionID = sessionId;
+            uccp.CircuitCode = uccpCcBlock;
+
+            byte[] uccpBytes = uccp.ToBytes();
+            UDPPacketBuffer upb = new UDPPacketBuffer(testEp, uccpBytes.Length);
+            upb.DataLength = uccpBytes.Length;  // God knows why this isn't set by the constructor.
+            Buffer.BlockCopy(uccpBytes, 0, upb.Data, 0, uccpBytes.Length);
+
+            AgentCircuitData acd = new AgentCircuitData();
+            acd.AgentID = agentId;
+            acd.SessionID = sessionId;
+
+            scene.AuthenticateHandler.AddNewCircuit(circuitCode, acd);
+
+            udpServer.PacketReceived(upb);
+
+            return scene.GetScenePresence(agentId);
+        }
+
+        public static TestLLUDPServer AddUdpServer(Scene scene)
+        {
+            return AddUdpServer(scene, new IniConfigSource());
+        }
+
+        public static TestLLUDPServer AddUdpServer(Scene scene, IniConfigSource configSource)
+        {
+            uint port = 0;
+            AgentCircuitManager acm = scene.AuthenticateHandler;
+
+            TestLLUDPServer udpServer = new TestLLUDPServer(IPAddress.Any, ref port, 0, false, configSource, acm);
+            udpServer.AddScene(scene);
+
+            return udpServer;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Tests/Common/Helpers/EntityTransferHelpers.cs b/OpenSim/Tests/Common/Helpers/EntityTransferHelpers.cs
index 84de47f..e6adcf7 100644
--- a/OpenSim/Tests/Common/Helpers/EntityTransferHelpers.cs
+++ b/OpenSim/Tests/Common/Helpers/EntityTransferHelpers.cs
@@ -43,7 +43,6 @@ using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.CoreModules.Framework;
 using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Mock;
 
 namespace OpenSim.Tests.Common
 {
diff --git a/OpenSim/Tests/Common/Helpers/SceneHelpers.cs b/OpenSim/Tests/Common/Helpers/SceneHelpers.cs
index d36e42e..9ed3eae 100644
--- a/OpenSim/Tests/Common/Helpers/SceneHelpers.cs
+++ b/OpenSim/Tests/Common/Helpers/SceneHelpers.cs
@@ -30,6 +30,7 @@ using System.Net;
 using System.Collections.Generic;
 using Nini.Config;
 using OpenMetaverse;
+using OpenSim.Data.Null;
 using OpenSim.Framework;
 using OpenSim.Framework.Communications;
 using OpenSim.Framework.Console;
@@ -48,7 +49,6 @@ using OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid;
 using OpenSim.Region.CoreModules.ServiceConnectorsOut.UserAccounts;
 using OpenSim.Region.CoreModules.ServiceConnectorsOut.Presence;
 using OpenSim.Services.Interfaces;
-using OpenSim.Tests.Common.Mock;
 using GridRegion = OpenSim.Services.Interfaces.GridRegion;
 
 namespace OpenSim.Tests.Common
@@ -63,9 +63,9 @@ namespace OpenSim.Tests.Common
         /// </summary>
         public SceneManager SceneManager { get; private set; }
 
+        public ISimulationDataService SimDataService { get; private set; }
+
         private AgentCircuitManager m_acm = new AgentCircuitManager();
-        private ISimulationDataService m_simDataService
-            = OpenSim.Server.Base.ServerUtils.LoadPlugin<ISimulationDataService>("OpenSim.Tests.Common.dll", null);
         private IEstateDataService m_estateDataService = null;
 
         private LocalAssetServicesConnector m_assetService;
@@ -96,6 +96,9 @@ namespace OpenSim.Tests.Common
             m_presenceService.PostInitialise();
 
             m_cache = cache;
+
+            SimDataService 
+                = OpenSim.Server.Base.ServerUtils.LoadPlugin<ISimulationDataService>("OpenSim.Tests.Common.dll", null);
         }
 
         /// <summary>
@@ -115,6 +118,11 @@ namespace OpenSim.Tests.Common
             return SetupScene(name, id, x, y, new IniConfigSource());
         }
 
+        public TestScene SetupScene(string name, UUID id, uint x, uint y, IConfigSource configSource)
+        {
+            return SetupScene(name, id, x, y, Constants.RegionSize, Constants.RegionSize, configSource);
+        }
+
         /// <summary>
         /// Set up a scene.
         /// </summary>
@@ -122,10 +130,12 @@ namespace OpenSim.Tests.Common
         /// <param name="id">ID of the region</param>
         /// <param name="x">X co-ordinate of the region</param>
         /// <param name="y">Y co-ordinate of the region</param>
+        /// <param name="sizeX">X size of scene</param>
+        /// <param name="sizeY">Y size of scene</param>
         /// <param name="configSource"></param>
         /// <returns></returns>
         public TestScene SetupScene(
-            string name, UUID id, uint x, uint y, IConfigSource configSource)
+            string name, UUID id, uint x, uint y, uint sizeX, uint sizeY, IConfigSource configSource)
         {
             Console.WriteLine("Setting up test scene {0}", name);
 
@@ -135,18 +145,29 @@ namespace OpenSim.Tests.Common
             RegionInfo regInfo = new RegionInfo(x, y, new IPEndPoint(IPAddress.Loopback, 9000), "127.0.0.1");
             regInfo.RegionName = name;
             regInfo.RegionID = id;
+            regInfo.RegionSizeX = sizeX;
+            regInfo.RegionSizeY = sizeY;
 
             SceneCommunicationService scs = new SceneCommunicationService();
 
             PhysicsPluginManager physicsPluginManager = new PhysicsPluginManager();
             physicsPluginManager.LoadPluginsFromAssembly("Physics/OpenSim.Region.Physics.BasicPhysicsPlugin.dll");
+<<<<<<< HEAD
+            Vector3 regionExtent = new Vector3( regInfo.RegionSizeX, regInfo.RegionSizeY, regInfo.RegionSizeZ);
+            PhysicsScene physicsScene 
+=======
             Vector3 regionExtent = new Vector3(regInfo.RegionSizeX, regInfo.RegionSizeY, regInfo.RegionSizeZ);
             PhysicsScene physicsScene
+>>>>>>> avn/ubitvar
                 = physicsPluginManager.GetPhysicsScene(
                     "basicphysics", "ZeroMesher", new IniConfigSource(), "test", regionExtent);
 
             TestScene testScene = new TestScene(
+<<<<<<< HEAD
+                regInfo, m_acm, physicsScene, scs, SimDataService, m_estateDataService, configSource, null);
+=======
                 regInfo, m_acm, physicsScene, scs, m_simDataService, m_estateDataService, configSource, null);
+>>>>>>> avn/ubitvar
 
             INonSharedRegionModule godsModule = new GodsModule();
             godsModule.Initialise(new IniConfigSource());
@@ -189,7 +210,11 @@ namespace OpenSim.Tests.Common
             testScene.SetModuleInterfaces();
 
             testScene.LandChannel = new TestLandChannel(testScene);
+<<<<<<< HEAD
+            testScene.LoadWorldMap();           
+=======
             testScene.LoadWorldMap();
+>>>>>>> avn/ubitvar
 
             testScene.RegionInfo.EstateSettings = new EstateSettings();
             testScene.LoginsEnabled = true;
@@ -299,6 +324,11 @@ namespace OpenSim.Tests.Common
         /// <param name="testScene"></param>
         private static LocalPresenceServicesConnector StartPresenceService()
         {
+            // Unfortunately, some services share data via statics, so we need to null every time to stop interference
+            // between tests.
+            // This is a massive non-obvious pita.
+            NullPresenceData.Instance = null;
+
             IConfigSource config = new IniConfigSource();
             config.AddConfig("Modules");
             config.AddConfig("PresenceService");
@@ -546,7 +576,7 @@ namespace OpenSim.Tests.Common
             string reason;
 
             // Stage 1: tell the scene to expect a new user connection
-            if (!scene.NewUserConnection(agentData, (uint)tf, out reason))
+            if (!scene.NewUserConnection(agentData, (uint)tf, null, out reason))
                 Console.WriteLine("NewUserConnection failed: " + reason);
 
             // Stage 2: add the new client as a child agent to the scene
@@ -557,7 +587,11 @@ namespace OpenSim.Tests.Common
 
         public static ScenePresence AddChildScenePresence(Scene scene, UUID agentId)
         {
-            AgentCircuitData acd = GenerateAgentData(agentId);
+            return AddChildScenePresence(scene, GenerateAgentData(agentId));
+        }
+
+        public static ScenePresence AddChildScenePresence(Scene scene, AgentCircuitData acd)
+        {
             acd.child = true;
 
             // XXX: ViaLogin may not be correct for child agents
@@ -589,6 +623,32 @@ namespace OpenSim.Tests.Common
             //part.UpdatePrimFlags(false, false, true);
             //part.ObjectFlags |= (uint)PrimFlags.Phantom;
 
+            scene.AddNewSceneObject(so, true);
+
+            return so;
+        }
+
+        /// <summary>
+        /// Add a test object
+        /// </summary>
+        /// <param name="scene"></param>
+        /// <param name="parts">
+        /// The number of parts that should be in the scene object
+        /// </param>
+        /// <param name="ownerId"></param>
+        /// <param name="partNamePrefix">
+        /// The prefix to be given to part names.  This will be suffixed with "Part<part no>"
+        /// (e.g. mynamePart1 for the root part)
+        /// </param>
+        /// <param name="uuidTail">
+        /// The hexadecimal last part of the UUID for parts created.  A UUID of the form "00000000-0000-0000-0000-{0:XD12}"
+        /// will be given to the root part, and incremented for each part thereafter.
+        /// </param>
+        /// <returns></returns>
+        public static SceneObjectGroup AddSceneObject(Scene scene, int parts, UUID ownerId, string partNamePrefix, int uuidTail)
+        {
+            SceneObjectGroup so = CreateSceneObject(parts, ownerId, partNamePrefix, uuidTail);
+
             scene.AddNewSceneObject(so, false);
 
             return so;
diff --git a/OpenSim/Tests/Common/Helpers/TaskInventoryHelpers.cs b/OpenSim/Tests/Common/Helpers/TaskInventoryHelpers.cs
index bb4b55f..3a3b33a 100644
--- a/OpenSim/Tests/Common/Helpers/TaskInventoryHelpers.cs
+++ b/OpenSim/Tests/Common/Helpers/TaskInventoryHelpers.cs
@@ -43,7 +43,7 @@ namespace OpenSim.Tests.Common
         /// <summary>
         /// Add a notecard item to the given part.
         /// </summary>
-        /// <param name="scene"></param>
+        /// <param name="assetService"></param>
         /// <param name="part"></param>
         /// <param name="itemName"></param>
         /// <param name="itemIDFrag">UUID or UUID stem</param>
@@ -51,16 +51,16 @@ namespace OpenSim.Tests.Common
         /// <param name="text">The tex to put in the notecard.</param>
         /// <returns>The item that was added</returns>
         public static TaskInventoryItem AddNotecard(
-            Scene scene, SceneObjectPart part, string itemName, string itemIDStem, string assetIDStem, string text)
+            IAssetService assetService, SceneObjectPart part, string itemName, string itemIDStem, string assetIDStem, string text)
         {
             return AddNotecard(
-                scene, part, itemName, TestHelpers.ParseStem(itemIDStem), TestHelpers.ParseStem(assetIDStem), text);
+                assetService, part, itemName, TestHelpers.ParseStem(itemIDStem), TestHelpers.ParseStem(assetIDStem), text);
         }
 
         /// <summary>
         /// Add a notecard item to the given part.
         /// </summary>
-        /// <param name="scene"></param>
+        /// <param name="assetService"></param>
         /// <param name="part"></param>
         /// <param name="itemName"></param>
         /// <param name="itemID"></param>
@@ -68,7 +68,7 @@ namespace OpenSim.Tests.Common
         /// <param name="text">The tex to put in the notecard.</param>
         /// <returns>The item that was added</returns>
         public static TaskInventoryItem AddNotecard(
-            Scene scene, SceneObjectPart part, string itemName, UUID itemID, UUID assetID, string text)
+            IAssetService assetService, SceneObjectPart part, string itemName, UUID itemID, UUID assetID, string text)
         {
             AssetNotecard nc = new AssetNotecard();
             nc.BodyText = text;
@@ -76,7 +76,7 @@ namespace OpenSim.Tests.Common
 
             AssetBase ncAsset
                 = AssetHelpers.CreateAsset(assetID, AssetType.Notecard, nc.AssetData, UUID.Zero);
-            scene.AssetService.Store(ncAsset);
+            assetService.Store(ncAsset);
 
             TaskInventoryItem ncItem 
                 = new TaskInventoryItem 
@@ -94,12 +94,12 @@ namespace OpenSim.Tests.Common
         /// TODO: Accept input for item and asset IDs to avoid mysterious script failures that try to use any of these
         /// functions more than once in a test.
         /// </remarks>
-        /// <param name="scene"></param>
+        /// <param name="assetService"></param>
         /// <param name="part"></param>
         /// <returns>The item that was added</returns>
-        public static TaskInventoryItem AddScript(Scene scene, SceneObjectPart part)
+        public static TaskInventoryItem AddScript(IAssetService assetService, SceneObjectPart part)
         {
-            return AddScript(scene, part, "scriptItem", "default { state_entry() { llSay(0, \"Hello World\"); } }");
+            return AddScript(assetService, part, "scriptItem", "default { state_entry() { llSay(0, \"Hello World\"); } }");
         }
 
         /// <summary>
@@ -109,30 +109,47 @@ namespace OpenSim.Tests.Common
         /// TODO: Accept input for item and asset IDs so that we have completely replicatable regression tests rather
         /// than a random component.
         /// </remarks>
-        /// <param name="scene"></param>
+        /// <param name="assetService"></param>
         /// <param name="part"></param>
         /// <param name="scriptName">Name of the script to add</param>
         /// <param name="scriptSource">LSL script source</param>
         /// <returns>The item that was added</returns>
         public static TaskInventoryItem AddScript(
-            Scene scene, SceneObjectPart part, string scriptName, string scriptSource)
+            IAssetService assetService, SceneObjectPart part, string scriptName, string scriptSource)
+        {
+            return AddScript(assetService, part, UUID.Random(), UUID.Random(), scriptName, scriptSource);
+        }
+                
+        /// <summary>
+        /// Add a simple script to the given part.
+        /// </summary>
+        /// <remarks>
+        /// TODO: Accept input for item and asset IDs so that we have completely replicatable regression tests rather
+        /// than a random component.
+        /// </remarks>
+        /// <param name="assetService"></param>
+        /// <param name="part"></param>
+        /// <param name="itemId">Item UUID for the script</param>
+        /// <param name="assetId">Asset UUID for the script</param>
+        /// <param name="scriptName">Name of the script to add</param>
+        /// <param name="scriptSource">LSL script source</param>
+        /// <returns>The item that was added</returns>
+        public static TaskInventoryItem AddScript(
+            IAssetService assetService, SceneObjectPart part, UUID itemId, UUID assetId, string scriptName, string scriptSource)
         {
             AssetScriptText ast = new AssetScriptText();
             ast.Source = scriptSource;
             ast.Encode();
 
-            UUID assetUuid = UUID.Random();
-            UUID itemUuid = UUID.Random();
-
             AssetBase asset
-                = AssetHelpers.CreateAsset(assetUuid, AssetType.LSLText, ast.AssetData, UUID.Zero);
-            scene.AssetService.Store(asset);
+                = AssetHelpers.CreateAsset(assetId, AssetType.LSLText, ast.AssetData, UUID.Zero);
+            assetService.Store(asset);
             TaskInventoryItem item
                 = new TaskInventoryItem 
-                    { Name = scriptName, AssetID = assetUuid, ItemID = itemUuid,
-                      Type = (int)AssetType.LSLText, InvType = (int)InventoryType.LSL };
+            { Name = scriptName, AssetID = assetId, ItemID = itemId,
+                Type = (int)AssetType.LSLText, InvType = (int)InventoryType.LSL };
             part.Inventory.AddInventoryItem(item, true);
-            
+
             return item;
         }
 
@@ -144,28 +161,50 @@ namespace OpenSim.Tests.Common
         /// functions more than once in a test.
         /// </remarks>
         ///
-        /// <param name="scene"></param>
+        /// <param name="assetService"></param>
         /// <param name="sop"></param>
         /// <param name="itemName"></param>
-        /// <param name="id"></param>
-        /// <param name="userId"></param>
+        /// <param name="itemId"></param>
+        /// <param name="soToAdd"></param>
+        /// <param name="soAssetId"></param>
         public static TaskInventoryItem AddSceneObject(
-            Scene scene, SceneObjectPart sop, string itemName, UUID id, UUID userId)
+            IAssetService assetService, SceneObjectPart sop, string itemName, UUID itemId, SceneObjectGroup soToAdd, UUID soAssetId)
         {
-            SceneObjectGroup taskSceneObject = SceneHelpers.CreateSceneObject(1, UUID.Zero);
-            AssetBase taskSceneObjectAsset = AssetHelpers.CreateAsset(0x10, taskSceneObject);
-            scene.AssetService.Store(taskSceneObjectAsset);
+            AssetBase taskSceneObjectAsset = AssetHelpers.CreateAsset(soAssetId, soToAdd);
+            assetService.Store(taskSceneObjectAsset);
             TaskInventoryItem taskSceneObjectItem
                 = new TaskInventoryItem
-                    { Name = itemName,
-                      AssetID = taskSceneObjectAsset.FullID,
-                      ItemID = id,
-                      OwnerID = userId,
-                      Type = (int)AssetType.Object,
-                      InvType = (int)InventoryType.Object };
+            { Name = itemName,
+                AssetID = taskSceneObjectAsset.FullID,
+                ItemID = itemId,
+                OwnerID = soToAdd.OwnerID,
+                Type = (int)AssetType.Object,
+                InvType = (int)InventoryType.Object };
             sop.Inventory.AddInventoryItem(taskSceneObjectItem, true);
 
             return taskSceneObjectItem;
         }
+
+        /// <summary>
+        /// Add a scene object item to the given part.
+        /// </summary>
+        /// <remarks>
+        /// TODO: Accept input for item and asset IDs to avoid mysterious script failures that try to use any of these
+        /// functions more than once in a test.
+        /// </remarks>
+        ///
+        /// <param name="assetService"></param>
+        /// <param name="sop"></param>
+        /// <param name="itemName"></param>
+        /// <param name="id"></param>
+        /// <param name="userId"></param>
+        public static TaskInventoryItem AddSceneObject(
+            IAssetService assetService, SceneObjectPart sop, string itemName, UUID itemId, UUID userId)
+        {
+            SceneObjectGroup taskSceneObject = SceneHelpers.CreateSceneObject(1, userId);
+
+            return TaskInventoryHelpers.AddSceneObject(
+                assetService, sop, itemName, itemId, taskSceneObject, TestHelpers.ParseTail(0x10));
+        }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Tests/Common/Helpers/UserInventoryHelpers.cs b/OpenSim/Tests/Common/Helpers/UserInventoryHelpers.cs
index b3b75af..5a36332 100644
--- a/OpenSim/Tests/Common/Helpers/UserInventoryHelpers.cs
+++ b/OpenSim/Tests/Common/Helpers/UserInventoryHelpers.cs
@@ -102,7 +102,7 @@ namespace OpenSim.Tests.Common
         {
             return AddInventoryItem(
                 scene, itemName, itemId, itemType, asset, userId, 
-                scene.InventoryService.GetFolderForType(userId, (AssetType)asset.Type).Name);
+                scene.InventoryService.GetFolderForType(userId, (FolderType)asset.Type).Name);
         }
 
         /// <summary>
diff --git a/OpenSim/Tests/Common/Mock/BaseAssetRepository.cs b/OpenSim/Tests/Common/Mock/BaseAssetRepository.cs
index cfefd38..cb4fb80 100644
--- a/OpenSim/Tests/Common/Mock/BaseAssetRepository.cs
+++ b/OpenSim/Tests/Common/Mock/BaseAssetRepository.cs
@@ -25,11 +25,12 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+using System;
 using System.Collections.Generic;
 using OpenMetaverse;
 using OpenSim.Framework;
 
-namespace OpenSim.Tests.Common.Mock
+namespace OpenSim.Tests.Common
 {
     public class BaseAssetRepository
     {
@@ -37,7 +38,7 @@ namespace OpenSim.Tests.Common.Mock
 
         public AssetBase FetchAsset(UUID uuid) 
         {
-            if (ExistsAsset(uuid))
+            if (AssetsExist(new[] { uuid })[0])
                 return Assets[uuid];
             else
                 return null;
@@ -53,9 +54,9 @@ namespace OpenSim.Tests.Common.Mock
             CreateAsset(asset);
         }
 
-        public bool ExistsAsset(UUID uuid) 
-        { 
-            return Assets.ContainsKey(uuid); 
+        public bool[] AssetsExist(UUID[] uuids) 
+        {
+            return Array.ConvertAll(uuids, id => Assets.ContainsKey(id));
         }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Tests/Common/Mock/MockAssetDataPlugin.cs b/OpenSim/Tests/Common/Mock/MockAssetDataPlugin.cs
index 5bab62c..aaf61e7 100644
--- a/OpenSim/Tests/Common/Mock/MockAssetDataPlugin.cs
+++ b/OpenSim/Tests/Common/Mock/MockAssetDataPlugin.cs
@@ -31,7 +31,7 @@ using OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Data;
 
-namespace OpenSim.Tests.Common.Mock
+namespace OpenSim.Tests.Common
 {
     /// <summary>
     /// In memory asset data plugin for test purposes.  Could be another dll when properly filled out and when the
diff --git a/OpenSim/Tests/Common/Mock/MockGroupsServicesConnector.cs b/OpenSim/Tests/Common/Mock/MockGroupsServicesConnector.cs
index 3035cea..7f530d0 100644
--- a/OpenSim/Tests/Common/Mock/MockGroupsServicesConnector.cs
+++ b/OpenSim/Tests/Common/Mock/MockGroupsServicesConnector.cs
@@ -40,7 +40,7 @@ using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups;
 
-namespace OpenSim.Tests.Common.Mock
+namespace OpenSim.Tests.Common
 {
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
     public class MockGroupsServicesConnector : ISharedRegionModule, IGroupsServicesConnector
@@ -138,33 +138,28 @@ namespace OpenSim.Tests.Common.Mock
         {
         }
 
+        private XGroup GetXGroup(UUID groupID, string name)
+        {
+            XGroup group = m_data.GetGroup(groupID);
+
+
+            if (group == null)
+                m_log.DebugFormat("[MOCK GROUPS SERVICES CONNECTOR]: No group found with ID {0}", groupID);               
+
+            return group;
+        }
+
         public GroupRecord GetGroupRecord(UUID requestingAgentID, UUID groupID, string groupName)
         {
             m_log.DebugFormat(
                 "[MOCK GROUPS SERVICES CONNECTOR]: Processing GetGroupRecord() for groupID {0}, name {1}", 
                 groupID, groupName);
 
-            XGroup[] groups;
-            string field, val;
+            XGroup xg = GetXGroup(groupID, groupName);
 
-            if (groupID != UUID.Zero)
-            {
-                field = "groupID";
-                val = groupID.ToString();
-            }
-            else
-            {
-                field = "name";
-                val = groupName;
-            }
-
-            groups = m_data.GetGroups(field, val);
-
-            if (groups.Length == 0)
+            if (xg == null)
                 return null;
 
-            XGroup xg = groups[0];
-
             GroupRecord gr = new GroupRecord()
             {
                 GroupID = xg.groupID,
@@ -196,8 +191,25 @@ namespace OpenSim.Tests.Common.Mock
         {
         }
 
-        public void SetAgentGroupInfo(UUID requestingAgentID, UUID AgentID, UUID GroupID, bool AcceptNotices, bool ListInProfile)
+        public void SetAgentGroupInfo(UUID requestingAgentID, UUID agentID, UUID groupID, bool acceptNotices, bool listInProfile)
         {
+            m_log.DebugFormat(
+                "[MOCK GROUPS SERVICES CONNECTOR]: SetAgentGroupInfo, requestingAgentID {0}, agentID {1}, groupID {2}, acceptNotices {3}, listInProfile {4}", 
+                requestingAgentID, agentID, groupID, acceptNotices, listInProfile);
+
+            XGroup group = GetXGroup(groupID, null);
+
+            if (group == null)
+                return;
+
+            XGroupMember xgm = null;
+            if (!group.members.TryGetValue(agentID, out xgm))
+                return;
+
+            xgm.acceptNotices = acceptNotices;
+            xgm.listInProfile = listInProfile;
+
+            m_data.StoreGroup(group);
         }
 
         public void AddAgentToGroupInvite(UUID requestingAgentID, UUID inviteID, UUID groupID, UUID roleID, UUID agentID)
@@ -213,8 +225,27 @@ namespace OpenSim.Tests.Common.Mock
         {
         }
 
-        public void AddAgentToGroup(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)
+        public void AddAgentToGroup(UUID requestingAgentID, UUID agentID, UUID groupID, UUID roleID)
         {
+            m_log.DebugFormat(
+                "[MOCK GROUPS SERVICES CONNECTOR]: AddAgentToGroup, requestingAgentID {0}, agentID {1}, groupID {2}, roleID {3}", 
+                requestingAgentID, agentID, groupID, roleID);
+
+            XGroup group = GetXGroup(groupID, null);
+
+            if (group == null)
+                return;
+
+            XGroupMember groupMember = new XGroupMember()
+            {
+                agentID = agentID,
+                groupID = groupID,
+                roleID = roleID
+            };
+
+            group.members[agentID] = groupMember;
+
+            m_data.StoreGroup(group);
         }
 
         public void RemoveAgentFromGroup(UUID requestingAgentID, UUID AgentID, UUID GroupID)
@@ -259,9 +290,31 @@ namespace OpenSim.Tests.Common.Mock
             return null;
         }
 
-        public List<GroupMembersData> GetGroupMembers(UUID requestingAgentID, UUID GroupID)
+        public List<GroupMembersData> GetGroupMembers(UUID requestingAgentID, UUID groupID)
         {
-            return null;
+            m_log.DebugFormat(
+                "[MOCK GROUPS SERVICES CONNECTOR]: GetGroupMembers, requestingAgentID {0}, groupID {1}",
+                requestingAgentID, groupID);
+
+            List<GroupMembersData> groupMembers = new List<GroupMembersData>();
+
+            XGroup group = GetXGroup(groupID, null);
+
+            if (group == null)
+                return groupMembers;
+
+            foreach (XGroupMember xgm in group.members.Values)
+            {
+                GroupMembersData gmd = new GroupMembersData();
+                gmd.AgentID = xgm.agentID;
+                gmd.IsOwner = group.founderID == gmd.AgentID;
+                gmd.AcceptNotices = xgm.acceptNotices;
+                gmd.ListInProfile = xgm.listInProfile;
+
+                groupMembers.Add(gmd);
+            }
+
+            return groupMembers;
         }
 
         public List<GroupRoleMembersData> GetGroupRoleMembers(UUID requestingAgentID, UUID GroupID)
@@ -269,18 +322,93 @@ namespace OpenSim.Tests.Common.Mock
             return null;
         }
 
-        public List<GroupNoticeData> GetGroupNotices(UUID requestingAgentID, UUID GroupID)
+        public List<GroupNoticeData> GetGroupNotices(UUID requestingAgentID, UUID groupID)
         {
-            return null;
+            XGroup group = GetXGroup(groupID, null);
+
+            if (group == null)
+                return null;
+
+            List<GroupNoticeData> notices = new List<GroupNoticeData>();
+
+            foreach (XGroupNotice notice in group.notices.Values)
+            {
+                GroupNoticeData gnd = new GroupNoticeData()
+                {
+                    NoticeID = notice.noticeID,
+                    Timestamp = notice.timestamp,
+                    FromName = notice.fromName,
+                    Subject = notice.subject,
+                    HasAttachment = notice.hasAttachment,
+                    AssetType = (byte)notice.assetType
+                };
+
+                notices.Add(gnd);
+            }
+
+            return notices;
         }
         
         public GroupNoticeInfo GetGroupNotice(UUID requestingAgentID, UUID noticeID)
         {
+            m_log.DebugFormat(
+                "[MOCK GROUPS SERVICES CONNECTOR]: GetGroupNotices, requestingAgentID {0}, noticeID {1}",
+                requestingAgentID, noticeID);
+
+            // Yes, not an efficient way to do it.
+            Dictionary<UUID, XGroup> groups = m_data.GetGroups();
+
+            foreach (XGroup group in groups.Values)
+            {
+                if (group.notices.ContainsKey(noticeID))
+                {
+                    XGroupNotice n = group.notices[noticeID];
+
+                    GroupNoticeInfo gni = new GroupNoticeInfo();
+                    gni.GroupID = n.groupID;
+                    gni.Message = n.message;
+                    gni.BinaryBucket = n.binaryBucket;
+                    gni.noticeData.NoticeID = n.noticeID;
+                    gni.noticeData.Timestamp = n.timestamp;
+                    gni.noticeData.FromName = n.fromName;
+                    gni.noticeData.Subject = n.subject;
+                    gni.noticeData.HasAttachment = n.hasAttachment;
+                    gni.noticeData.AssetType = (byte)n.assetType;
+
+                    return gni;
+                }
+            }
+           
             return null;
         }
         
         public void AddGroupNotice(UUID requestingAgentID, UUID groupID, UUID noticeID, string fromName, string subject, string message, byte[] binaryBucket)
         {
+            m_log.DebugFormat(
+                "[MOCK GROUPS SERVICES CONNECTOR]: AddGroupNotice, requestingAgentID {0}, groupID {1}, noticeID {2}, fromName {3}, subject {4}, message {5}, binaryBucket.Length {6}", 
+                requestingAgentID, groupID, noticeID, fromName, subject, message, binaryBucket.Length);
+
+            XGroup group = GetXGroup(groupID, null);
+
+            if (group == null)
+                return;
+
+            XGroupNotice groupNotice = new XGroupNotice()
+            {
+                groupID = groupID,
+                noticeID = noticeID,
+                fromName = fromName,
+                subject = subject,
+                message = message,
+                timestamp = (uint)Util.UnixTimeSinceEpoch(),
+                hasAttachment = false,
+                assetType = 0,
+                binaryBucket = binaryBucket
+            };
+
+            group.notices[noticeID] = groupNotice;
+
+            m_data.StoreGroup(group);
         }
 
         public void ResetAgentGroupChatSessions(UUID agentID)
diff --git a/OpenSim/Tests/Common/Mock/MockScriptEngine.cs b/OpenSim/Tests/Common/Mock/MockScriptEngine.cs
index b444241..d7a144c 100644
--- a/OpenSim/Tests/Common/Mock/MockScriptEngine.cs
+++ b/OpenSim/Tests/Common/Mock/MockScriptEngine.cs
@@ -94,8 +94,10 @@ namespace OpenSim.Tests.Common
 
         public Type ReplaceableInterface { get { return null; } }
 
+#pragma warning disable 0067
         public event ScriptRemoved OnScriptRemoved;
         public event ObjectRemoved OnObjectRemoved;
+#pragma warning restore 0067
 
         public string GetXMLState (UUID itemID)
         {
@@ -262,5 +264,9 @@ namespace OpenSim.Tests.Common
         {
             PostedEvents.Clear();
         }
+
+        public void SleepScript(UUID itemID, int delay)
+        {
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Tests/Common/Mock/TestClient.cs b/OpenSim/Tests/Common/Mock/TestClient.cs
index 5daca1e..f034443 100644
--- a/OpenSim/Tests/Common/Mock/TestClient.cs
+++ b/OpenSim/Tests/Common/Mock/TestClient.cs
@@ -38,7 +38,7 @@ using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Framework.Client;
 
-namespace OpenSim.Tests.Common.Mock
+namespace OpenSim.Tests.Common
 {
     public class TestClient : IClientAPI, IClientCore
     {
@@ -62,12 +62,23 @@ namespace OpenSim.Tests.Common.Mock
         public event Action<RegionInfo, Vector3, Vector3> OnReceivedMoveAgentIntoRegion;
         public event Action<ulong, IPEndPoint> OnTestClientInformClientOfNeighbour;
         public event TestClientOnSendRegionTeleportDelegate OnTestClientSendRegionTeleport;
+
+        public event Action<ISceneEntity, PrimUpdateFlags> OnReceivedEntityUpdate;
+
+        public event OnReceivedChatMessageDelegate OnReceivedChatMessage;
         public event Action<GridInstantMessage> OnReceivedInstantMessage;
 
+        public event Action<UUID> OnReceivedSendRebakeAvatarTextures;
+
         public delegate void TestClientOnSendRegionTeleportDelegate(
             ulong regionHandle, byte simAccess, IPEndPoint regionExternalEndPoint,
             uint locationID, uint flags, string capsURL);
 
+        public delegate void OnReceivedChatMessageDelegate(
+            string message, byte type, Vector3 fromPos, string fromName,
+            UUID fromAgentID, UUID ownerID, byte source, byte audible);
+
+
 // disable warning: public events, part of the public API
 #pragma warning disable 67
 
@@ -472,6 +483,34 @@ namespace OpenSim.Tests.Common.Mock
         }
 
         /// <summary>
+        /// Trigger chat coming from this connection.
+        /// </summary>
+        /// <param name="channel"></param>
+        /// <param name="type"></param>
+        /// <param name="message"></param>
+        public bool Chat(int channel, ChatTypeEnum type, string message)
+        {
+            ChatMessage handlerChatFromClient = OnChatFromClient;
+
+            if (handlerChatFromClient != null)
+            {
+                OSChatMessage args = new OSChatMessage();
+                args.Channel = channel;
+                args.From = Name;
+                args.Message = message;
+                args.Type = type;
+
+                args.Scene = Scene;
+                args.Sender = this;
+                args.SenderUUID = AgentId;
+
+                handlerChatFromClient(this, args);
+            }
+
+            return true;
+        }
+
+        /// <summary>
         /// Attempt a teleport to the given region.
         /// </summary>
         /// <param name="regionHandle"></param>
@@ -572,6 +611,9 @@ namespace OpenSim.Tests.Common.Mock
             string message, byte type, Vector3 fromPos, string fromName,
             UUID fromAgentID, UUID ownerID, byte source, byte audible)
         {
+//            Console.WriteLine("mmm {0} {1} {2}", message, Name, AgentId);
+            if (OnReceivedChatMessage != null)
+                OnReceivedChatMessage(message, type, fromPos, fromName, fromAgentID, ownerID, source, audible);
         }
 
         public void SendInstantMessage(GridInstantMessage im)
@@ -713,6 +755,8 @@ namespace OpenSim.Tests.Common.Mock
 
         public void SendEntityUpdate(ISceneEntity entity, PrimUpdateFlags updateFlags)
         {
+            if (OnReceivedEntityUpdate != null)
+                OnReceivedEntityUpdate(entity, updateFlags);
         }
 
         public void ReprioritizeUpdates()
@@ -1260,6 +1304,8 @@ namespace OpenSim.Tests.Common.Mock
 
         public void SendRebakeAvatarTextures(UUID textureID)
         {
+            if (OnReceivedSendRebakeAvatarTextures != null)
+                OnReceivedSendRebakeAvatarTextures(textureID);
         }
         
         public void SendAvatarInterestsReply(UUID avatarID, uint wantMask, string wantText, uint skillsMask, string skillsText, string languages)
diff --git a/OpenSim/Tests/Common/Mock/TestHttpClientContext.cs b/OpenSim/Tests/Common/Mock/TestHttpClientContext.cs
new file mode 100644
index 0000000..5a55b09
--- /dev/null
+++ b/OpenSim/Tests/Common/Mock/TestHttpClientContext.cs
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using HttpServer;
+using OpenSim.Framework;
+
+namespace OpenSim.Tests.Common
+{
+    public class TestHttpClientContext: IHttpClientContext
+    {
+        /// <summary>
+        /// Bodies of responses from the server.
+        /// </summary>
+        public string ResponseBody
+        { 
+            get { return Encoding.UTF8.GetString(m_responseStream.ToArray()); }
+        }
+
+        public Byte[] ResponseBodyBytes
+        {
+            get{ return m_responseStream.ToArray(); }
+        }
+
+        private MemoryStream m_responseStream = new MemoryStream();
+
+        public bool IsSecured { get; set; }
+
+        public bool Secured 
+        { 
+            get { return IsSecured; }
+            set { IsSecured = value; }
+        }
+
+        public TestHttpClientContext(bool secured)
+        {
+            Secured = secured;
+        }
+
+        public void Disconnect(SocketError error) 
+        {
+//            Console.WriteLine("TestHttpClientContext.Disconnect Received disconnect with status {0}", error);
+        }
+
+        public void Respond(string httpVersion, HttpStatusCode statusCode, string reason, string body) {Console.WriteLine("x");}
+        public void Respond(string httpVersion, HttpStatusCode statusCode, string reason) {Console.WriteLine("xx");}
+        public void Respond(string body) { Console.WriteLine("xxx");}
+
+        public void Send(byte[] buffer) 
+        {
+            // Getting header data here
+//            Console.WriteLine("xxxx: Got {0}", Encoding.UTF8.GetString(buffer));
+        }
+
+        public void Send(byte[] buffer, int offset, int size) 
+        {
+//            Util.PrintCallStack();
+//
+//            Console.WriteLine(
+//                "TestHttpClientContext.Send(byte[], int, int) got offset={0}, size={1}, buffer={2}", 
+//                offset, size, Encoding.UTF8.GetString(buffer));
+
+            m_responseStream.Write(buffer, offset, size);
+        }
+
+        public void Respond(string httpVersion, HttpStatusCode statusCode, string reason, string body, string contentType) {Console.WriteLine("xxxxxx");}
+        public void Close() { }
+        public bool EndWhenDone { get { return false;} set { return;}}
+
+        public HTTPNetworkContext GiveMeTheNetworkStreamIKnowWhatImDoing()
+        {
+            return new HTTPNetworkContext();
+        }
+
+        public event EventHandler<DisconnectedEventArgs> Disconnected = delegate { };
+        /// <summary>
+        /// A request have been received in the context.
+        /// </summary>
+        public event EventHandler<RequestEventArgs> RequestReceived = delegate { };
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Tests/Common/Mock/TestHttpRequest.cs b/OpenSim/Tests/Common/Mock/TestHttpRequest.cs
new file mode 100644
index 0000000..b868895
--- /dev/null
+++ b/OpenSim/Tests/Common/Mock/TestHttpRequest.cs
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Specialized;
+using System.IO;
+using HttpServer;
+using HttpServer.FormDecoders;
+
+namespace OpenSim.Tests.Common
+{
+    public class TestHttpRequest: IHttpRequest
+    {
+        private string _uriPath;
+        public bool BodyIsComplete 
+        { 
+            get { return true; } 
+        }
+        public string[] AcceptTypes 
+        { 
+            get {return _acceptTypes; }
+        }
+        private string[] _acceptTypes;
+        public Stream Body 
+        { 
+            get { return _body; } 
+            set { _body = value;} 
+        }
+        private Stream _body;
+        public ConnectionType Connection 
+        { 
+            get { return _connection; }
+            set { _connection = value; }
+        }
+        private ConnectionType _connection;
+        public int ContentLength 
+        { 
+            get { return _contentLength; }
+            set { _contentLength = value; }
+        }
+        private int _contentLength;
+        public NameValueCollection Headers 
+        { 
+            get { return _headers; }
+        }
+        private NameValueCollection _headers = new NameValueCollection();
+
+        public string HttpVersion { get; set; }
+
+        public string Method 
+        { 
+            get { return _method; }
+            set { _method = value; }
+        }
+        private string _method = null;
+        public HttpInput QueryString 
+        { 
+            get { return _queryString;  }
+        }
+        private HttpInput _queryString = null;
+        public Uri Uri 
+        { 
+            get { return _uri; }
+            set { _uri = value; } 
+        }
+        private Uri _uri = null;
+        public string[] UriParts 
+        { 
+            get { return _uri.Segments; }
+        }
+        public HttpParam Param 
+        { 
+            get { return null; } 
+        }
+        public HttpForm Form 
+        { 
+            get { return null; } 
+        }
+        public bool IsAjax 
+        { 
+            get { return false; } 
+        }
+        public RequestCookies Cookies 
+        { 
+            get { return null; } 
+        }
+
+        public TestHttpRequest() 
+        {
+            HttpVersion = "HTTP/1.1";
+        }
+
+        public TestHttpRequest(string contentEncoding, string contentType, string userAgent, 
+                               string remoteAddr, string remotePort, string[] acceptTypes,
+                               ConnectionType connectionType, int contentLength, Uri uri) : base()
+        {
+            _headers["content-encoding"] = contentEncoding;
+            _headers["content-type"] = contentType;
+            _headers["user-agent"] = userAgent;
+            _headers["remote_addr"] = remoteAddr;
+            _headers["remote_port"] = remotePort;
+
+            _acceptTypes = acceptTypes;
+            _connection = connectionType;
+            _contentLength = contentLength;
+            _uri = uri;
+        }
+
+        public void DecodeBody(FormDecoderProvider providers) {}
+        public void SetCookies(RequestCookies cookies) {}
+        public void AddHeader(string name, string value)
+        {
+            _headers.Add(name, value);
+        }
+        public int AddToBody(byte[] bytes, int offset, int length) 
+        {
+            return 0;
+        }
+        public void Clear() {}
+
+        public object Clone()
+        {
+            TestHttpRequest clone = new TestHttpRequest();
+            clone._acceptTypes = _acceptTypes;
+            clone._connection = _connection;
+            clone._contentLength = _contentLength;
+            clone._uri = _uri;
+            clone._headers = new NameValueCollection(_headers);
+
+            return clone;
+        }
+        public IHttpResponse CreateResponse(IHttpClientContext context)
+        {
+            return new HttpResponse(context, this);
+        }
+        /// <summary>
+        /// Path and query (will be merged with the host header) and put in Uri
+        /// </summary>
+        /// <see cref="Uri"/>
+        public string UriPath
+        {
+            get { return _uriPath; }
+            set
+            {
+                _uriPath = value;
+               
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Tests/Common/Mock/TestHttpResponse.cs b/OpenSim/Tests/Common/Mock/TestHttpResponse.cs
new file mode 100644
index 0000000..ff47c10
--- /dev/null
+++ b/OpenSim/Tests/Common/Mock/TestHttpResponse.cs
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.IO;
+using System.Net;
+using System.Text;
+using HttpServer;
+
+namespace OpenSim.Tests.Common
+{
+    public class TestHttpResponse: IHttpResponse
+    {
+        public Stream Body 
+        {
+            get { return _body; }
+
+            set { _body = value; }
+        }
+        private Stream _body;
+
+        public string ProtocolVersion 
+        { 
+            get { return _protocolVersion; }
+            set { _protocolVersion = value; }
+        }
+        private string _protocolVersion;
+
+        public bool Chunked 
+        {
+            get { return _chunked; }
+
+            set { _chunked = value; }
+        }
+        private bool _chunked;
+
+        public ConnectionType Connection 
+        {
+            get { return _connection; }
+
+            set { _connection = value; }
+        }
+        private ConnectionType _connection;
+
+        public Encoding Encoding 
+        {
+            get { return _encoding; }
+
+            set { _encoding = value; }
+        }
+        private Encoding _encoding;
+
+        public int KeepAlive 
+        {
+            get { return _keepAlive; }
+
+            set { _keepAlive = value; }
+        }
+        private int _keepAlive;
+
+        public HttpStatusCode Status 
+        {
+            get { return _status; }
+
+            set { _status = value; }
+        }
+        private HttpStatusCode _status;
+
+        public string Reason 
+        {
+            get { return _reason; }
+
+            set { _reason = value; }
+        }
+        private string _reason;
+
+        public long ContentLength 
+        {
+            get { return _contentLength; }
+
+            set { _contentLength = value; }
+        }
+        private long _contentLength;
+
+        public string ContentType 
+        {
+            get { return _contentType; }
+
+            set { _contentType = value; }
+        }
+        private string _contentType;
+
+        public bool HeadersSent 
+        {
+            get { return _headersSent; }
+        }
+        private bool _headersSent;
+
+        public bool Sent 
+        {
+            get { return _sent; }
+        }
+        private bool _sent;
+
+        public ResponseCookies Cookies 
+        {
+            get { return _cookies; }
+        }
+        private ResponseCookies _cookies = null;
+
+        public TestHttpResponse()
+        {
+            _headersSent = false;
+            _sent = false;
+        }
+
+        public void AddHeader(string name, string value) {}
+
+        public void Send() 
+        {
+            if (!_headersSent) SendHeaders();
+            if (_sent) throw new InvalidOperationException("stuff already sent");
+            _sent = true;
+        }
+
+        public void SendBody(byte[] buffer, int offset, int count) 
+        {
+            if (!_headersSent) SendHeaders();
+            _sent = true;
+        }
+
+        public void SendBody(byte[] buffer) 
+        {
+            if (!_headersSent) SendHeaders();
+            _sent = true;
+        }
+
+        public void SendHeaders() 
+        {
+            if (_headersSent) throw new InvalidOperationException("headers already sent");
+            _headersSent = true;
+        }
+
+        public void Redirect(Uri uri) {}
+        public void Redirect(string url) {}
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Tests/Common/Mock/TestInventoryDataPlugin.cs b/OpenSim/Tests/Common/Mock/TestInventoryDataPlugin.cs
index fc44358..c97a765 100644
--- a/OpenSim/Tests/Common/Mock/TestInventoryDataPlugin.cs
+++ b/OpenSim/Tests/Common/Mock/TestInventoryDataPlugin.cs
@@ -33,7 +33,7 @@ using OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Data;
 
-namespace OpenSim.Tests.Common.Mock
+namespace OpenSim.Tests.Common
 {
     /// <summary>
     /// In memory inventory data plugin for test purposes.  Could be another dll when properly filled out and when the
@@ -185,7 +185,7 @@ namespace OpenSim.Tests.Common.Mock
 
         public void addInventoryItem(InventoryItemBase item) 
         {
-//            InventoryFolderBase folder = m_folders[item.Folder];
+            InventoryFolderBase folder = m_folders[item.Folder];
             
 //            m_log.DebugFormat(
 //                "[MOCK INV DB]: Adding inventory item {0} {1} in {2} {3}", item.Name, item.ID, folder.Name, folder.ID);
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLUDPServer.cs b/OpenSim/Tests/Common/Mock/TestLLUDPServer.cs
index 27b9e5b..26887c9 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLUDPServer.cs
+++ b/OpenSim/Tests/Common/Mock/TestLLUDPServer.cs
@@ -32,8 +32,9 @@ using System.Net.Sockets;
 using Nini.Config;
 using OpenMetaverse.Packets;
 using OpenSim.Framework;
+using OpenSim.Region.ClientStack.LindenUDP;
 
-namespace OpenSim.Region.ClientStack.LindenUDP.Tests
+namespace OpenSim.Tests.Common
 {
     /// <summary>
     /// This class enables regression testing of the LLUDPServer by allowing us to intercept outgoing data.
diff --git a/OpenSim/Tests/Common/Mock/TestLandChannel.cs b/OpenSim/Tests/Common/Mock/TestLandChannel.cs
index 8135bfc..23258ad 100644
--- a/OpenSim/Tests/Common/Mock/TestLandChannel.cs
+++ b/OpenSim/Tests/Common/Mock/TestLandChannel.cs
@@ -32,7 +32,7 @@ using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.CoreModules.World.Land;
 
-namespace OpenSim.Tests.Common.Mock
+namespace OpenSim.Tests.Common
 {
     /// <summary>
     /// Land channel for test purposes
diff --git a/OpenSim/Tests/Common/Mock/TestOSHttpRequest.cs b/OpenSim/Tests/Common/Mock/TestOSHttpRequest.cs
index e769d30..7b1d2b5 100644
--- a/OpenSim/Tests/Common/Mock/TestOSHttpRequest.cs
+++ b/OpenSim/Tests/Common/Mock/TestOSHttpRequest.cs
@@ -35,7 +35,7 @@ using System.Text;
 using System.Web;
 using OpenSim.Framework.Servers.HttpServer;
 
-namespace OpenSim.Tests.Common.Mock
+namespace OpenSim.Tests.Common
 {
     public class TestOSHttpRequest : IOSHttpRequest
     {
diff --git a/OpenSim/Tests/Common/Mock/TestOSHttpResponse.cs b/OpenSim/Tests/Common/Mock/TestOSHttpResponse.cs
index e10fe82..2e17f1e 100644
--- a/OpenSim/Tests/Common/Mock/TestOSHttpResponse.cs
+++ b/OpenSim/Tests/Common/Mock/TestOSHttpResponse.cs
@@ -32,7 +32,7 @@ using System.Text;
 using System.Web;
 using OpenSim.Framework.Servers.HttpServer;
 
-namespace OpenSim.Tests.Common.Mock
+namespace OpenSim.Tests.Common
 {
     public class TestOSHttpResponse : IOSHttpResponse
     {
diff --git a/OpenSim/Tests/Common/Mock/TestScene.cs b/OpenSim/Tests/Common/Mock/TestScene.cs
index 53a311e..e559871 100644
--- a/OpenSim/Tests/Common/Mock/TestScene.cs
+++ b/OpenSim/Tests/Common/Mock/TestScene.cs
@@ -34,8 +34,12 @@ using OpenSim.Region.Framework;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Physics.Manager;
+<<<<<<< HEAD
+using OpenSim.Services.Interfaces;
+=======
+>>>>>>> avn/ubitvar
 
-namespace OpenSim.Tests.Common.Mock
+namespace OpenSim.Tests.Common
 {
     public class TestScene : Scene
     {
diff --git a/OpenSim/Tests/Common/Mock/TestXInventoryDataPlugin.cs b/OpenSim/Tests/Common/Mock/TestXInventoryDataPlugin.cs
index 2be5524..2b272e6 100644
--- a/OpenSim/Tests/Common/Mock/TestXInventoryDataPlugin.cs
+++ b/OpenSim/Tests/Common/Mock/TestXInventoryDataPlugin.cs
@@ -35,7 +35,7 @@ using OpenSim.Framework;
 using OpenSim.Data;
 using OpenSim.Data.Null;
 
-namespace OpenSim.Tests.Common.Mock
+namespace OpenSim.Tests.Common
 {
     public class TestXInventoryDataPlugin : NullGenericDataHandler, IXInventoryData
     {
@@ -46,20 +46,33 @@ namespace OpenSim.Tests.Common.Mock
 
         public XInventoryItem[] GetItems(string[] fields, string[] vals)
         {
+//            Console.WriteLine(
+//                "Requesting items, fields {0}, vals {1}", string.Join(", ", fields), string.Join(", ", vals));
+
             List<XInventoryItem> origItems = Get<XInventoryItem>(fields, vals, m_allItems.Values.ToList());
 
-            return origItems.Select(i => i.Clone()).ToArray();
+            XInventoryItem[] items = origItems.Select(i => i.Clone()).ToArray();
+
+//            Console.WriteLine("Found {0} items", items.Length);
+//            Array.ForEach(items, i => Console.WriteLine("Found item {0} {1}", i.inventoryName, i.inventoryID));
+
+            return items;
         }
 
         public XInventoryFolder[] GetFolders(string[] fields, string[] vals)
         {
 //            Console.WriteLine(
-//                "Requesting folders, fields {0}, vals {1}", string.Join(",", fields), string.Join(",", vals));
+//                "Requesting folders, fields {0}, vals {1}", string.Join(", ", fields), string.Join(", ", vals));
 
             List<XInventoryFolder> origFolders
                 = Get<XInventoryFolder>(fields, vals, m_allFolders.Values.ToList());
 
-            return origFolders.Select(f => f.Clone()).ToArray();
+            XInventoryFolder[] folders = origFolders.Select(f => f.Clone()).ToArray();
+
+//            Console.WriteLine("Found {0} folders", folders.Length);
+//            Array.ForEach(folders, f => Console.WriteLine("Found folder {0} {1}", f.folderName, f.folderID));
+
+            return folders;
         }
 
         public bool StoreFolder(XInventoryFolder folder)
@@ -75,7 +88,9 @@ namespace OpenSim.Tests.Common.Mock
         {
             m_allItems[item.inventoryID] = item.Clone();
 
-//            Console.WriteLine("Added item {0} {1}, creator {2}, owner {3}", item.inventoryName, item.inventoryID, item.creatorID, item.avatarID);
+//            Console.WriteLine(
+//                "Added item {0} {1}, folder {2}, creator {3}, owner {4}", 
+//                item.inventoryName, item.inventoryID, item.parentFolderID, item.creatorID, item.avatarID);
 
             return true;
         }
diff --git a/OpenSim/Tests/Common/OpenSimTestCase.cs b/OpenSim/Tests/Common/OpenSimTestCase.cs
index 3c47faa..c1415af 100644
--- a/OpenSim/Tests/Common/OpenSimTestCase.cs
+++ b/OpenSim/Tests/Common/OpenSimTestCase.cs
@@ -27,6 +27,7 @@
 
 using System;
 using NUnit.Framework;
+using OpenSim.Framework;
 using OpenSim.Framework.Servers;
 
 namespace OpenSim.Tests.Common