Initial update to OpenSim 0.8.2.1 source code.

17 files changed, 1441 insertions, 119 deletions

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 4a15cf2..dddf75d 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/MockRegionDataPlugin.cs b/OpenSim/Tests/Common/Mock/MockRegionDataPlugin.cs
index ed29c39..5df8e04 100644
--- a/OpenSim/Tests/Common/Mock/MockRegionDataPlugin.cs
+++ b/OpenSim/Tests/Common/Mock/MockRegionDataPlugin.cs
@@ -69,11 +69,21 @@ namespace OpenSim.Data.Null
             m_store.StoreTerrain(terrain, regionID);
         }
 
+        public void StoreTerrain(TerrainData terrain, UUID regionID)
+        {
+            m_store.StoreTerrain(terrain, regionID);
+        }
+
         public double[,] LoadTerrain(UUID regionID)
         {
             return m_store.LoadTerrain(regionID);
         }
 
+        public TerrainData LoadTerrain(UUID regionID, int pSizeX, int pSizeY, int pSizeZ)
+        {
+            return m_store.LoadTerrain(regionID, pSizeX, pSizeY, pSizeZ);
+        }
+
         public void StoreLandObject(ILandObject Parcel)
         {
             m_store.StoreLandObject(Parcel);
@@ -154,7 +164,7 @@ namespace OpenSim.Data.Null
         protected Dictionary<UUID, SceneObjectPart> m_sceneObjectParts = new Dictionary<UUID, SceneObjectPart>();
         protected Dictionary<UUID, ICollection<TaskInventoryItem>> m_primItems 
             = new Dictionary<UUID, ICollection<TaskInventoryItem>>();
-        protected Dictionary<UUID, double[,]> m_terrains = new Dictionary<UUID, double[,]>();
+        protected Dictionary<UUID, TerrainData> m_terrains = new Dictionary<UUID, TerrainData>();
         protected Dictionary<UUID, LandData> m_landData = new Dictionary<UUID, LandData>();
         
         public void Initialise(string dbfile)
@@ -299,12 +309,17 @@ namespace OpenSim.Data.Null
             return new List<SceneObjectGroup>(objects.Values);
         }
 
-        public void StoreTerrain(double[,] ter, UUID regionID)
+        public void StoreTerrain(TerrainData ter, UUID regionID)
         {
             m_terrains[regionID] = ter;
         }
 
-        public double[,] LoadTerrain(UUID regionID)
+        public void StoreTerrain(double[,] ter, UUID regionID)
+        {
+            m_terrains[regionID] = new HeightmapTerrainData(ter);
+        }
+
+        public TerrainData LoadTerrain(UUID regionID, int pSizeX, int pSizeY, int pSizeZ)
         {
             if (m_terrains.ContainsKey(regionID))
                 return m_terrains[regionID];
@@ -312,6 +327,14 @@ namespace OpenSim.Data.Null
                 return null;
         }
 
+        public double[,] LoadTerrain(UUID regionID)
+        {
+            if (m_terrains.ContainsKey(regionID))
+                return m_terrains[regionID].GetDoubles();
+            else
+                return null;
+        }
+
         public void RemoveLandObject(UUID globalID)
         {
             if (m_landData.ContainsKey(globalID))
diff --git a/OpenSim/Tests/Common/Mock/MockScriptEngine.cs b/OpenSim/Tests/Common/Mock/MockScriptEngine.cs
new file mode 100644
index 0000000..d7a144c
--- /dev/null
+++ b/OpenSim/Tests/Common/Mock/MockScriptEngine.cs
@@ -0,0 +1,272 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.Reflection;
+using Nini.Config;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.ScriptEngine.Interfaces;
+using OpenSim.Region.ScriptEngine.Shared;
+
+namespace OpenSim.Tests.Common
+{
+    public class MockScriptEngine : INonSharedRegionModule, IScriptModule, IScriptEngine
+    {      
+        public IConfigSource ConfigSource { get; private set; }
+
+        public IConfig Config { get; private set; }
+
+        private Scene m_scene;
+
+        /// <summary>
+        /// Expose posted events to tests.
+        /// </summary>
+        public Dictionary<UUID, List<EventParams>> PostedEvents { get; private set; }
+
+        /// <summary>
+        /// A very primitive way of hooking text cose to a posed event.
+        /// </summary>
+        /// <remarks>
+        /// May be replaced with something that uses more original code in the future.
+        /// </remarks>
+        public event Action<UUID, EventParams> PostEventHook;
+
+        public void Initialise(IConfigSource source)
+        {
+            ConfigSource = source;
+
+            // Can set later on if required
+            Config = new IniConfig("MockScriptEngine", ConfigSource);
+
+            PostedEvents = new Dictionary<UUID, List<EventParams>>();
+        }
+
+        public void Close()
+        {
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            m_scene = scene;
+
+            m_scene.StackModuleInterface<IScriptModule>(this);
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+        }
+
+        public string Name { get { return "Mock Script Engine"; } }        
+        public string ScriptEngineName { get { return Name; } }
+
+        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)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public bool SetXMLState(UUID itemID, string xml)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public bool PostScriptEvent(UUID itemID, string name, object[] args)
+        {
+//            Console.WriteLine("Posting event {0} for {1}", name, itemID);
+
+            return PostScriptEvent(itemID, new EventParams(name, args, null));
+        }
+
+        public bool PostScriptEvent(UUID itemID, EventParams evParams)
+        {
+            List<EventParams> eventsForItem;
+
+            if (!PostedEvents.ContainsKey(itemID))
+            {
+                eventsForItem = new List<EventParams>();
+                PostedEvents.Add(itemID, eventsForItem);
+            }
+            else
+            {
+                eventsForItem = PostedEvents[itemID];
+            }
+
+            eventsForItem.Add(evParams);
+
+            if (PostEventHook != null)
+                PostEventHook(itemID, evParams);
+
+            return true;
+        }
+
+        public bool PostObjectEvent(uint localID, EventParams evParams)
+        {
+            return PostObjectEvent(m_scene.GetSceneObjectPart(localID), evParams);
+        }
+
+        public bool PostObjectEvent(UUID itemID, string name, object[] args)
+        {
+            return PostObjectEvent(m_scene.GetSceneObjectPart(itemID), new EventParams(name, args, null));
+        }
+
+        private bool PostObjectEvent(SceneObjectPart part, EventParams evParams)
+        {
+            foreach (TaskInventoryItem item in part.Inventory.GetInventoryItems(InventoryType.LSL))
+                PostScriptEvent(item.ItemID, evParams);
+
+            return true;
+        }
+
+        public void SuspendScript(UUID itemID)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public void ResumeScript(UUID itemID)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public ArrayList GetScriptErrors(UUID itemID)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public bool HasScript(UUID itemID, out bool running)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public bool GetScriptState(UUID itemID)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public void SaveAllState()
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public void StartProcessing()
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public float GetScriptExecutionTime(List<UUID> itemIDs)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public Dictionary<uint, float> GetObjectScriptsExecutionTimes()
+        {
+            throw new System.NotImplementedException ();
+        }
+       
+        public IScriptWorkItem QueueEventHandler(object parms)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public DetectParams GetDetectParams(UUID item, int number)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public void SetMinEventDelay(UUID itemID, double delay)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public int GetStartParameter(UUID itemID)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public void SetScriptState(UUID itemID, bool state)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public void SetState(UUID itemID, string newState)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public void ApiResetScript(UUID itemID)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public void ResetScript (UUID itemID)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public IScriptApi GetApi(UUID itemID, string name)
+        {
+            throw new System.NotImplementedException ();
+        }
+
+        public Scene World { get { return m_scene; } }
+
+        public IScriptModule ScriptModule { get { return this; } }
+
+        public string ScriptEnginePath { get { throw new System.NotImplementedException (); }}
+
+        public string ScriptClassName { get { throw new System.NotImplementedException (); } }
+
+        public string ScriptBaseClassName { get { throw new System.NotImplementedException (); } }
+
+        public string[] ScriptReferencedAssemblies { get { throw new System.NotImplementedException (); } }
+
+        public ParameterInfo[] ScriptBaseClassParameters { get { throw new System.NotImplementedException (); } }       
+
+        public void ClearPostedEvents()
+        {
+            PostedEvents.Clear();
+        }
+
+        public void SleepScript(UUID itemID, int delay)
+        {
+        }
+    }
+}
diff --git a/OpenSim/Tests/Common/Mock/TestClient.cs b/OpenSim/Tests/Common/Mock/TestClient.cs
index dde37ab..0e1bc8f 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
     {
@@ -46,12 +46,10 @@ namespace OpenSim.Tests.Common.Mock
 
         EventWaitHandle wh = new EventWaitHandle (false, EventResetMode.AutoReset, "Crossing");
 
-        private TestClient TeleportSceneClient;
-
         private Scene m_scene;
-        private SceneManager m_sceneManager;
 
         // Properties so that we can get at received data for test purposes
+        public List<uint> ReceivedKills { get; private set; }
         public List<UUID> ReceivedOfflineNotifications { get; private set; }
         public List<UUID> ReceivedOnlineNotifications { get; private set; }
         public List<UUID> ReceivedFriendshipTerminations { get; private set; }
@@ -60,6 +58,27 @@ namespace OpenSim.Tests.Common.Mock
         public List<ImagePacketPacket> SentImagePacketPackets { get; private set; }
         public List<ImageNotInDatabasePacket> SentImageNotInDatabasePackets { get; private set; }
 
+        // Test client specific events - for use by tests to implement some IClientAPI behaviour.
+        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
 
@@ -103,6 +122,7 @@ namespace OpenSim.Tests.Common.Mock
         public event Action<IClientAPI, bool> OnCompleteMovementToRegion;
         public event UpdateAgent OnPreAgentUpdate;
         public event UpdateAgent OnAgentUpdate;
+        public event UpdateAgent OnAgentCameraUpdate;
         public event AgentRequestSit OnAgentRequestSit;
         public event AgentSit OnAgentSit;
         public event AvatarPickerRequest OnAvatarPickerRequest;
@@ -193,6 +213,7 @@ namespace OpenSim.Tests.Common.Mock
         public event EstateCovenantRequest OnEstateCovenantRequest;
         public event EstateChangeInfo OnEstateChangeInfo;
         public event EstateManageTelehub OnEstateManageTelehub;
+        public event CachedTextureRequest OnCachedTextureRequest;
 
         public event ObjectDuplicateOnRay OnObjectDuplicateOnRay;
 
@@ -430,33 +451,21 @@ namespace OpenSim.Tests.Common.Mock
         /// <summary>
         /// Constructor
         /// </summary>
-        /// <remarks>
-        /// Can be used for a test where there is only one region or where there are multiple regions that are not
-        /// neighbours and where no teleporting takes place.  In other situations, the constructor that takes in a
-        /// scene manager should be used.
-        /// </remarks>
-        /// <param name="agentData"></param>
-        /// <param name="scene"></param>
-        public TestClient(AgentCircuitData agentData, Scene scene) : this(agentData, scene, null) {}
-
-        /// <summary>
-        /// Constructor
-        /// </summary>
         /// <param name="agentData"></param>
         /// <param name="scene"></param>
         /// <param name="sceneManager"></param>
-        public TestClient(AgentCircuitData agentData, Scene scene, SceneManager sceneManager)
+        public TestClient(AgentCircuitData agentData, Scene scene)
         {
             m_agentId = agentData.AgentID;
             m_firstName = agentData.firstname;
             m_lastName = agentData.lastname;
             m_circuitCode = agentData.circuitcode;
             m_scene = scene;
-            m_sceneManager = sceneManager;
             SessionId = agentData.SessionID;
             SecureSessionId = agentData.SecureSessionID;
             CapsSeedUrl = agentData.CapsPath;
 
+            ReceivedKills = new List<uint>();
             ReceivedOfflineNotifications = new List<UUID>();
             ReceivedOnlineNotifications = new List<UUID>();
             ReceivedFriendshipTerminations = new List<UUID>();
@@ -467,6 +476,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>
@@ -479,7 +516,20 @@ namespace OpenSim.Tests.Common.Mock
 
         public void CompleteMovement()
         {
-            OnCompleteMovementToRegion(this, true);
+            if (OnCompleteMovementToRegion != null)
+                OnCompleteMovementToRegion(this, true);
+        }
+
+        /// <summary>
+        /// Emulate sending an IM from the viewer to the simulator.
+        /// </summary>
+        /// <param name='im'></param>
+        public void HandleImprovedInstantMessage(GridInstantMessage im)
+        {
+            ImprovedInstantMessage handlerInstantMessage = OnInstantMessage;
+
+            if (handlerInstantMessage != null)
+                handlerInstantMessage(this, im);
         }
 
         public virtual void ActivateGesture(UUID assetId, UUID gestureId)
@@ -494,6 +544,11 @@ namespace OpenSim.Tests.Common.Mock
         {
         }
 
+        public void SendCachedTextureResponse(ISceneEntity avatar, int serial, List<CachedTextureResponseArg> cachedTextures)
+        {
+
+        }
+
         public virtual void Kick(string message)
         {
         }
@@ -508,22 +563,22 @@ namespace OpenSim.Tests.Common.Mock
 
         public virtual void SendAgentDataUpdate(UUID agentid, UUID activegroupid, string firstname, string lastname, ulong grouppowers, string groupname, string grouptitle)
         {
-
         }
 
-        public virtual void SendKillObject(ulong regionHandle, List<uint> localID)
+        public virtual void SendKillObject(List<uint> localID)
         {
+            ReceivedKills.AddRange(localID);
         }
 
         public virtual void SetChildAgentThrottle(byte[] throttle)
         {
         }
+
         public byte[] GetThrottlesPacked(float multiplier)
         {
             return new byte[0];
         }
 
-
         public virtual void SendAnimations(UUID[] animations, int[] seqs, UUID sourceAgentId, UUID[] objectIDs)
         {
         }
@@ -532,19 +587,23 @@ 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)
         {
-
+            if (OnReceivedInstantMessage != null)
+                OnReceivedInstantMessage(im);
         }
 
-        public void SendGenericMessage(string method, List<string> message)
+        public void SendGenericMessage(string method, UUID invoice, List<string> message)
         {
 
         }
 
-        public void SendGenericMessage(string method, List<byte[]> message)
+        public void SendGenericMessage(string method, UUID invoice, List<byte[]> message)
         {
 
         }
@@ -566,13 +625,15 @@ namespace OpenSim.Tests.Common.Mock
 
         public virtual void MoveAgentIntoRegion(RegionInfo regInfo, Vector3 pos, Vector3 look)
         {
+            if (OnReceivedMoveAgentIntoRegion != null)
+                OnReceivedMoveAgentIntoRegion(regInfo, pos, look);
         }
 
         public virtual AgentCircuitData RequestClientInfo()
         {
             AgentCircuitData agentData = new AgentCircuitData();
             agentData.AgentID = AgentId;
-            agentData.SessionID = UUID.Zero;
+            agentData.SessionID = SessionId; 
             agentData.SecureSessionID = UUID.Zero;
             agentData.circuitcode = m_circuitCode;
             agentData.child = false;
@@ -591,46 +652,29 @@ namespace OpenSim.Tests.Common.Mock
 
         public virtual void InformClientOfNeighbour(ulong neighbourHandle, IPEndPoint neighbourExternalEndPoint)
         {
-            m_log.DebugFormat("[TEST CLIENT]: Processing inform client of neighbour");
-
-            // In response to this message, we are going to make a teleport to the scene we've previous been told
-            // about by test code (this needs to be improved).
-            AgentCircuitData newAgent = RequestClientInfo();
-
-            // Stage 2: add the new client as a child agent to the scene
-            uint x, y;
-            Utils.LongToUInts(neighbourHandle, out x, out y);
-            x /= Constants.RegionSize;
-            y /= Constants.RegionSize;
-
-            Scene neighbourScene;
-            m_sceneManager.TryGetScene(x, y, out neighbourScene);
-
-            TeleportSceneClient = new TestClient(newAgent, neighbourScene, m_sceneManager);
-            neighbourScene.AddNewClient(TeleportSceneClient, PresenceType.User);
+            if (OnTestClientInformClientOfNeighbour != null)
+                OnTestClientInformClientOfNeighbour(neighbourHandle, neighbourExternalEndPoint);
         }
 
-        public virtual void SendRegionTeleport(ulong regionHandle, byte simAccess, IPEndPoint regionExternalEndPoint,
-                                               uint locationID, uint flags, string capsURL)
+        public virtual void SendRegionTeleport(
+            ulong regionHandle, byte simAccess, IPEndPoint regionExternalEndPoint,
+            uint locationID, uint flags, string capsURL)
         {
-            m_log.DebugFormat("[TEST CLIENT]: Received SendRegionTeleport");
+            m_log.DebugFormat(
+                "[TEST CLIENT]: Received SendRegionTeleport for {0} {1} on {2}", m_firstName, m_lastName, m_scene.Name);
 
             CapsSeedUrl = capsURL;
 
-            // We don't do this here so that the source region can complete processing first in a single-threaded
-            // regression test scenario.  The test itself will have to call CompleteTeleportClientSide() after a teleport
-            // CompleteTeleportClientSide();
-        }
-
-        public void CompleteTeleportClientSide()
-        {
-            TeleportSceneClient.CompleteMovement();
-            //TeleportTargetScene.AgentCrossing(newAgent.AgentID, new Vector3(90, 90, 90), false);
+            if (OnTestClientSendRegionTeleport != null)
+                OnTestClientSendRegionTeleport(
+                    regionHandle, simAccess, regionExternalEndPoint, locationID, flags, capsURL);
         }
 
         public virtual void SendTeleportFailed(string reason)
         {
-            m_log.DebugFormat("[TEST CLIENT]: Teleport failed with reason {0}", reason);
+            m_log.DebugFormat(
+                "[TEST CLIENT]: Teleport failed for {0} {1} on {2} with reason {3}", 
+                m_firstName, m_lastName, m_scene.Name, reason);
         }
 
         public virtual void CrossRegion(ulong newRegionHandle, Vector3 pos, Vector3 lookAt,
@@ -660,7 +704,7 @@ namespace OpenSim.Tests.Common.Mock
         {
         }
 
-        public virtual void SendMoneyBalance(UUID transaction, bool success, byte[] description, int balance)
+        public virtual void SendMoneyBalance(UUID transaction, bool success, byte[] description, int balance, int transactionType, UUID sourceID, bool sourceIsGroup, UUID destID, bool destIsGroup, int amount, string item)
         {
         }
 
@@ -682,6 +726,8 @@ namespace OpenSim.Tests.Common.Mock
 
         public void SendEntityUpdate(ISceneEntity entity, PrimUpdateFlags updateFlags)
         {
+            if (OnReceivedEntityUpdate != null)
+                OnReceivedEntityUpdate(entity, updateFlags);
         }
 
         public void ReprioritizeUpdates()
@@ -786,11 +832,6 @@ namespace OpenSim.Tests.Common.Mock
             {
                 OnRegionHandShakeReply(this);
             }
-
-            if (OnCompleteMovementToRegion != null)
-            {
-                OnCompleteMovementToRegion(this, true);
-            }
         }
         
         public void SendAssetUploadCompleteMessage(sbyte AssetType, bool Success, UUID AssetFullID)
@@ -884,11 +925,6 @@ namespace OpenSim.Tests.Common.Mock
 
         }
 
-        public bool AddMoney(int debit)
-        {
-            return false;
-        }
-
         public void SendSunPos(Vector3 sunPos, Vector3 sunVel, ulong time, uint dlen, uint ylen, float phase)
         {
         }
@@ -1235,6 +1271,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)
@@ -1269,12 +1307,17 @@ namespace OpenSim.Tests.Common.Mock
         {
         }
 
-        public void StopFlying(ISceneEntity presence)
+        public void SendAgentTerseUpdate(ISceneEntity presence)
         {
         }
 
         public void SendPlacesReply(UUID queryID, UUID transactionID, PlacesReplyData[] data)
         {
         }
+
+        public void SendPartPhysicsProprieties(ISceneEntity entity)
+        {
+        }
+
     }
 }
diff --git a/OpenSim/Tests/Common/Mock/TestEventQueueGetModule.cs b/OpenSim/Tests/Common/Mock/TestEventQueueGetModule.cs
new file mode 100644
index 0000000..f2bae58
--- /dev/null
+++ b/OpenSim/Tests/Common/Mock/TestEventQueueGetModule.cs
@@ -0,0 +1,182 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.Net;
+using System.Reflection;
+using System.Threading;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Region.ClientStack.Linden;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Tests.Common
+{
+    public class TestEventQueueGetModule : IEventQueue, INonSharedRegionModule
+    {
+        public class Event 
+        {
+            public string Name { get; set; }
+            public object[] Args { get; set; }
+
+            public Event(string name, object[] args)
+            {
+                name = Name;
+                args = Args;
+            }
+        }
+
+        public Dictionary<UUID, List<Event>> Events { get; set; }
+
+        public void Initialise(IConfigSource source) {}
+
+        public void Close() {}
+
+        public void AddRegion(Scene scene) 
+        {
+            Events = new Dictionary<UUID, List<Event>>();
+            scene.RegisterModuleInterface<IEventQueue>(this);
+        }
+
+        public void RemoveRegion (Scene scene) {}
+
+        public void RegionLoaded (Scene scene) {}
+
+        public string Name { get { return "TestEventQueueGetModule"; } }
+
+        public Type ReplaceableInterface { get { return null; } }
+
+        private void AddEvent(UUID avatarID, string name, params object[] args)
+        {
+            Console.WriteLine("Adding event {0} for {1}", name, avatarID);
+
+            List<Event> avEvents;
+
+            if (!Events.ContainsKey(avatarID))
+            {
+                avEvents = new List<Event>();
+                Events[avatarID] = avEvents;
+            }
+            else
+            {
+                avEvents = Events[avatarID];
+            }
+
+            avEvents.Add(new Event(name, args));
+        }
+
+        public void ClearEvents()
+        {
+            if (Events != null)
+                Events.Clear();
+        }
+
+        public bool Enqueue(OSD o, UUID avatarID)
+        {
+            AddEvent(avatarID, "Enqueue", o);
+            return true;
+        }
+
+        public void DisableSimulator(ulong handle, UUID avatarID)
+        {
+            AddEvent(avatarID, "DisableSimulator", handle);
+        }
+
+        public void EnableSimulator (ulong handle, IPEndPoint endPoint, UUID avatarID, int regionSizeX, int regionSizeY)
+        {
+            AddEvent(avatarID, "EnableSimulator", handle);
+        }
+
+        public void EstablishAgentCommunication (UUID avatarID, IPEndPoint endPoint, string capsPath,
+                                ulong regionHandle, int regionSizeX, int regionSizeY)
+        {
+            AddEvent(avatarID, "EstablishAgentCommunication", endPoint, capsPath);
+        }
+
+        public void TeleportFinishEvent (ulong regionHandle, byte simAccess, IPEndPoint regionExternalEndPoint,
+                    uint locationID, uint flags, string capsURL, UUID agentID, int regionSizeX, int regionSizeY)
+        {
+            AddEvent(agentID, "TeleportFinishEvent", regionHandle, simAccess, regionExternalEndPoint, locationID, flags, capsURL);
+        }
+
+        public void CrossRegion (ulong handle, Vector3 pos, Vector3 lookAt, IPEndPoint newRegionExternalEndPoint,
+                                    string capsURL, UUID avatarID, UUID sessionID, int regionSizeX, int regionSizeY)
+        {
+            AddEvent(avatarID, "CrossRegion", handle, pos, lookAt, newRegionExternalEndPoint, capsURL, sessionID);
+        }
+
+        public void ChatterboxInvitation(
+            UUID sessionID, string sessionName, UUID fromAgent, string message, UUID toAgent, string fromName, 
+            byte dialog, uint timeStamp, bool offline, int parentEstateID, Vector3 position, uint ttl, 
+            UUID transactionID, bool fromGroup, byte[] binaryBucket)
+        {
+            AddEvent(
+                toAgent, "ChatterboxInvitation", sessionID, sessionName, fromAgent, message, toAgent, fromName, dialog, 
+                timeStamp, offline, parentEstateID, position, ttl, transactionID, fromGroup, binaryBucket);
+        }
+
+        public void ChatterBoxSessionAgentListUpdates (UUID sessionID, UUID fromAgent, UUID toAgent, bool canVoiceChat, bool isModerator, bool textMute)
+        {
+            AddEvent(toAgent, "ChatterBoxSessionAgentListUpdates", sessionID, fromAgent, canVoiceChat, isModerator, textMute);
+        }
+
+        public void ParcelProperties (OpenMetaverse.Messages.Linden.ParcelPropertiesMessage parcelPropertiesMessage, UUID avatarID)
+        {
+            AddEvent(avatarID, "ParcelProperties", parcelPropertiesMessage);
+        }
+
+        public void GroupMembership (OpenMetaverse.Packets.AgentGroupDataUpdatePacket groupUpdate, UUID avatarID)
+        {
+            AddEvent(avatarID, "GroupMembership", groupUpdate);
+        }
+
+        public OSD ScriptRunningEvent (UUID objectID, UUID itemID, bool running, bool mono)
+        {
+            Console.WriteLine("ONE");
+            throw new System.NotImplementedException ();
+        }
+
+        public OSD BuildEvent(string eventName, OSD eventBody)
+        {
+            Console.WriteLine("TWO");
+            throw new System.NotImplementedException ();
+        }
+
+        public void partPhysicsProperties (uint localID, byte physhapetype, float density, float friction, float bounce, float gravmod, UUID avatarID)
+        {
+            AddEvent(avatarID, "partPhysicsProperties", localID, physhapetype, density, friction, bounce, gravmod);
+        }
+    }
+}
\ No newline at end of file
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/Tests/Common/Mock/TestLLUDPServer.cs b/OpenSim/Tests/Common/Mock/TestLLUDPServer.cs
new file mode 100644
index 0000000..26887c9
--- /dev/null
+++ b/OpenSim/Tests/Common/Mock/TestLLUDPServer.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.Collections.Generic;
+using System.Net;
+using System.Net.Sockets;
+using Nini.Config;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Region.ClientStack.LindenUDP;
+
+namespace OpenSim.Tests.Common
+{
+    /// <summary>
+    /// This class enables regression testing of the LLUDPServer by allowing us to intercept outgoing data.
+    /// </summary>
+    public class TestLLUDPServer : LLUDPServer
+    {
+        public List<Packet> PacketsSent { get; private set; }
+
+        public TestLLUDPServer(IPAddress listenIP, ref uint port, int proxyPortOffsetParm, bool allow_alternate_port, IConfigSource configSource, AgentCircuitManager circuitManager)
+            : base(listenIP, ref port, proxyPortOffsetParm, allow_alternate_port, configSource, circuitManager)
+        {
+            PacketsSent = new List<Packet>();
+        }
+
+        public override void SendAckImmediate(IPEndPoint remoteEndpoint, PacketAckPacket ack)
+        {
+            PacketsSent.Add(ack);
+        }
+
+        public override void SendPacket(
+            LLUDPClient udpClient, Packet packet, ThrottleOutPacketType category, bool allowSplitting, UnackedPacketMethod method)
+        {
+            PacketsSent.Add(packet);
+        }
+
+        public void ClientOutgoingPacketHandler(IClientAPI client, bool resendUnacked, bool sendAcks, bool sendPing)
+        {
+            m_resendUnacked = resendUnacked;
+            m_sendAcks = sendAcks;
+            m_sendPing = sendPing;
+
+            ClientOutgoingPacketHandler(client);
+        }
+
+////        /// <summary>
+////        /// The chunks of data to pass to the LLUDPServer when it calls EndReceive
+////        /// </summary>
+////        protected Queue<ChunkSenderTuple> m_chunksToLoad = new Queue<ChunkSenderTuple>();
+//        
+////        protected override void BeginReceive()
+////        {
+////            if (m_chunksToLoad.Count > 0 && m_chunksToLoad.Peek().BeginReceiveException)
+////            {
+////                ChunkSenderTuple tuple = m_chunksToLoad.Dequeue();
+////                reusedEpSender = tuple.Sender;
+////                throw new SocketException();
+////            }
+////        }
+//        
+////        protected override bool EndReceive(out int numBytes, IAsyncResult result, ref EndPoint epSender)
+////        {
+////            numBytes = 0;
+////
+////            //m_log.Debug("Queue size " + m_chunksToLoad.Count);
+////            
+////            if (m_chunksToLoad.Count <= 0)
+////                return false;
+////            
+////            ChunkSenderTuple tuple = m_chunksToLoad.Dequeue();
+////            RecvBuffer = tuple.Data;
+////            numBytes   = tuple.Data.Length;
+////            epSender   = tuple.Sender;
+////            
+////            return true;
+////        }
+//        
+////        public override void SendPacketTo(byte[] buffer, int size, SocketFlags flags, uint circuitcode)
+////        {
+////            // Don't do anything just yet
+////        }
+//        
+//        /// <summary>
+//        /// Signal that this chunk should throw an exception on Socket.BeginReceive()
+//        /// </summary>
+//        /// <param name="epSender"></param>
+//        public void LoadReceiveWithBeginException(EndPoint epSender)
+//        {
+//            ChunkSenderTuple tuple = new ChunkSenderTuple(epSender);
+//            tuple.BeginReceiveException = true;
+//            m_chunksToLoad.Enqueue(tuple);
+//        }
+//        
+//        /// <summary>
+//        /// Load some data to be received by the LLUDPServer on the next receive call
+//        /// </summary>
+//        /// <param name="data"></param>
+//        /// <param name="epSender"></param>
+//        public void LoadReceive(byte[] data, EndPoint epSender)
+//        {
+//            m_chunksToLoad.Enqueue(new ChunkSenderTuple(data, epSender));
+//        }
+//        
+//        /// <summary>
+//        /// Load a packet to be received by the LLUDPServer on the next receive call
+//        /// </summary>
+//        /// <param name="packet"></param>
+//        public void LoadReceive(Packet packet, EndPoint epSender)
+//        {
+//            LoadReceive(packet.ToBytes(), epSender);
+//        }
+//        
+//        /// <summary>
+//        /// Calls the protected asynchronous result method.  This fires out all data chunks currently queued for send
+//        /// </summary>
+//        /// <param name="result"></param>
+//        public void ReceiveData(IAsyncResult result)
+//        {
+//            // Doesn't work the same way anymore
+////            while (m_chunksToLoad.Count > 0)
+////                OnReceivedData(result);
+//        }
+    }
+    
+    /// <summary>
+    /// Record the data and sender tuple
+    /// </summary>
+    public class ChunkSenderTuple
+    {
+        public byte[] Data;
+        public EndPoint Sender;
+        public bool BeginReceiveException;
+        
+        public ChunkSenderTuple(byte[] data, EndPoint sender)
+        {
+            Data = data;
+            Sender = sender;
+        }
+        
+        public ChunkSenderTuple(EndPoint sender)
+        {
+            Sender = sender;
+        }
+    }
+}
diff --git a/OpenSim/Tests/Common/Mock/TestLandChannel.cs b/OpenSim/Tests/Common/Mock/TestLandChannel.cs
index 4b4d52d..89ebcd5 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
@@ -81,6 +81,11 @@ namespace OpenSim.Tests.Common.Mock
             return obj;
         }
 
+        public ILandObject GetLandObject(Vector3 position)
+        {
+            return GetLandObject(position.X, position.Y);
+        }
+
         public ILandObject GetLandObject(int x, int y)
         {
             return GetNoLand();
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 d4b5648..1a93c9f 100644
--- a/OpenSim/Tests/Common/Mock/TestScene.cs
+++ b/OpenSim/Tests/Common/Mock/TestScene.cs
@@ -28,23 +28,24 @@
 using System;
 using Nini.Config;
 using OpenSim.Framework;
-using OpenSim.Framework.Communications;
+
 using OpenSim.Framework.Servers;
 using OpenSim.Region.Framework;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenSim.Services.Interfaces;
 
-namespace OpenSim.Tests.Common.Mock
+namespace OpenSim.Tests.Common
 {
     public class TestScene : Scene
     {
         public TestScene(
-            RegionInfo regInfo, AgentCircuitManager authen,
-            SceneCommunicationService sceneGridService, ISimulationDataService simDataService, IEstateDataService estateDataService,
-            bool dumpAssetsToFile,
+            RegionInfo regInfo, AgentCircuitManager authen, 
+            ISimulationDataService simDataService, IEstateDataService estateDataService,
             IConfigSource config, string simulatorVersion)
-            : base(regInfo, authen, sceneGridService, simDataService, estateDataService,
-                   dumpAssetsToFile, config, simulatorVersion)
+            : base(regInfo, authen, simDataService, estateDataService,
+                   config, simulatorVersion)
         {
         }
 
diff --git a/OpenSim/Tests/Common/Mock/TestXInventoryDataPlugin.cs b/OpenSim/Tests/Common/Mock/TestXInventoryDataPlugin.cs
index ccbdf81..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,17 +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));
+
             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)
@@ -72,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;
         }
@@ -104,7 +122,30 @@ namespace OpenSim.Tests.Common.Mock
         }
 
         public bool MoveItem(string id, string newParent) { throw new NotImplementedException(); }
-        public bool MoveFolder(string id, string newParent) { throw new NotImplementedException(); }
+
+        public bool MoveFolder(string id, string newParent) 
+        { 
+            // Don't use GetFolders() here - it takes a clone!
+            XInventoryFolder folder = m_allFolders[new UUID(id)];
+
+            if (folder == null)
+                return false;
+
+            folder.parentFolderID = new UUID(newParent);
+
+//            XInventoryFolder[] newParentFolders 
+//                = GetFolders(new string[] { "folderID" }, new string[] { folder.parentFolderID.ToString() });
+
+//            Console.WriteLine(
+//                "Moved folder {0} {1}, to {2} {3}", 
+//                folder.folderName, folder.folderID, newParentFolders[0].folderName, folder.parentFolderID);
+
+            // TODO: Really need to implement folder version incrementing, though this should be common code anyway,
+            // not reimplemented in each db plugin.
+
+            return true;
+        }
+
         public XInventoryItem[] GetActiveGestures(UUID principalID) { throw new NotImplementedException(); }
         public int GetAssetPermissions(UUID principalID, UUID assetID) { throw new NotImplementedException(); }
     }