7 files changed, 520 insertions, 103 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
new file mode 100644
index 0000000..b215f1e
--- /dev/null
+++ b/OpenSim/Tests/Common/Helpers/EntityTransferHelpers.cs
@@ -0,0 +1,123 @@
+/*
+ * 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.Reflection;
+using System.Text;
+using System.Threading;
+using log4net;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenSim.Framework;
+
+using OpenSim.Framework.Servers;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.CoreModules.Framework;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Tests.Common
+{
+    public static class EntityTransferHelpers
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// Set up correct handling of the InformClientOfNeighbour call from the source region that triggers the
+        /// viewer to setup a connection with the destination region.
+        /// </summary>
+        /// <param name='tc'></param>
+        /// <param name='neighbourTcs'>
+        /// A list that will be populated with any TestClients set up in response to 
+        /// being informed about a destination region.
+        /// </param>
+        public static void SetupInformClientOfNeighbourTriggersNeighbourClientCreate(
+            TestClient tc, List<TestClient> neighbourTcs)
+        {
+            // XXX: Confusingly, this is also used for non-neighbour notification (as in teleports that do not use the
+            // event queue).
+
+            tc.OnTestClientInformClientOfNeighbour += (neighbourHandle, neighbourExternalEndPoint) =>
+            {
+                uint x, y;
+                Util.RegionHandleToRegionLoc(neighbourHandle, out x, out y);
+
+                m_log.DebugFormat(
+                    "[TEST CLIENT]: Processing inform client of neighbour located at {0},{1} at {2}", 
+                    x, y, neighbourExternalEndPoint);
+
+                AgentCircuitData newAgent = tc.RequestClientInfo();
+
+                Scene neighbourScene;
+                SceneManager.Instance.TryGetScene(x, y, out neighbourScene);
+
+                TestClient neighbourTc = new TestClient(newAgent, neighbourScene);
+                neighbourTcs.Add(neighbourTc);
+                neighbourScene.AddNewAgent(neighbourTc, PresenceType.User);
+            };
+        }
+
+        /// <summary>
+        /// Set up correct handling of the InformClientOfNeighbour call from the source region that triggers the
+        /// viewer to setup a connection with the destination region.
+        /// </summary>
+        /// <param name='tc'></param>
+        /// <param name='neighbourTcs'>
+        /// A list that will be populated with any TestClients set up in response to 
+        /// being informed about a destination region.
+        /// </param>
+        public static void SetupSendRegionTeleportTriggersDestinationClientCreateAndCompleteMovement(
+            TestClient client, List<TestClient> destinationClients)
+        {
+            client.OnTestClientSendRegionTeleport 
+                += (regionHandle, simAccess, regionExternalEndPoint, locationID, flags, capsURL) =>
+            {
+                uint x, y;
+                Util.RegionHandleToRegionLoc(regionHandle, out x, out y);
+
+                m_log.DebugFormat(
+                    "[TEST CLIENT]: Processing send region teleport for destination at {0},{1} at {2}", 
+                    x, y, regionExternalEndPoint);
+
+                AgentCircuitData newAgent = client.RequestClientInfo();
+
+                Scene destinationScene;
+                SceneManager.Instance.TryGetScene(x, y, out destinationScene);
+
+                TestClient destinationClient = new TestClient(newAgent, destinationScene);
+                destinationClients.Add(destinationClient);
+                destinationScene.AddNewAgent(destinationClient, PresenceType.User);
+
+                ThreadPool.UnsafeQueueUserWorkItem(o => destinationClient.CompleteMovement(), null);
+            };
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Tests/Common/Helpers/SceneHelpers.cs b/OpenSim/Tests/Common/Helpers/SceneHelpers.cs
index ea3e348..df8b14c 100644
--- a/OpenSim/Tests/Common/Helpers/SceneHelpers.cs
+++ b/OpenSim/Tests/Common/Helpers/SceneHelpers.cs
@@ -30,12 +30,13 @@ 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;
 using OpenSim.Framework.Servers;
 using OpenSim.Framework.Servers.HttpServer;
-using OpenSim.Region.Physics.Manager;
+using OpenSim.Region.PhysicsModules.SharedBase;
 using OpenSim.Region.Framework;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
@@ -47,8 +48,8 @@ using OpenSim.Region.CoreModules.ServiceConnectorsOut.Inventory;
 using OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid;
 using OpenSim.Region.CoreModules.ServiceConnectorsOut.UserAccounts;
 using OpenSim.Region.CoreModules.ServiceConnectorsOut.Presence;
+using OpenSim.Region.PhysicsModule.BasicPhysics;
 using OpenSim.Services.Interfaces;
-using OpenSim.Tests.Common.Mock;
 using GridRegion = OpenSim.Services.Interfaces.GridRegion;
 
 namespace OpenSim.Tests.Common
@@ -63,9 +64,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;
@@ -77,6 +78,8 @@ namespace OpenSim.Tests.Common
 
         private CoreAssetCache m_cache;
 
+        private PhysicsScene m_physicsScene;
+
         public SceneHelpers() : this(null) {}
 
         public SceneHelpers(CoreAssetCache cache)
@@ -96,6 +99,11 @@ namespace OpenSim.Tests.Common
             m_presenceService.PostInitialise();
 
             m_cache = cache;
+
+            m_physicsScene = StartPhysicsScene();
+
+            SimDataService 
+                = OpenSim.Server.Base.ServerUtils.LoadPlugin<ISimulationDataService>("OpenSim.Tests.Common.dll", null);
         }
 
         /// <summary>
@@ -115,6 +123,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 +135,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,16 +150,20 @@ 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;
-
-            SceneCommunicationService scs = new SceneCommunicationService();
+            regInfo.RegionSizeX = sizeX;
+            regInfo.RegionSizeY = sizeY;
 
             TestScene testScene = new TestScene(
-                regInfo, m_acm, scs, m_simDataService, m_estateDataService, false, configSource, null);
+                regInfo, m_acm, SimDataService, m_estateDataService, configSource, null);
 
             INonSharedRegionModule godsModule = new GodsModule();
             godsModule.Initialise(new IniConfigSource());
             godsModule.AddRegion(testScene);
 
+            // Add scene to physics
+            ((INonSharedRegionModule)m_physicsScene).AddRegion(testScene);
+            ((INonSharedRegionModule)m_physicsScene).RegionLoaded(testScene);
+
             // Add scene to services
             m_assetService.AddRegion(testScene);
 
@@ -182,12 +201,7 @@ namespace OpenSim.Tests.Common
             testScene.SetModuleInterfaces();
 
             testScene.LandChannel = new TestLandChannel(testScene);
-            testScene.LoadWorldMap();
-
-            PhysicsPluginManager physicsPluginManager = new PhysicsPluginManager();
-            physicsPluginManager.LoadPluginsFromAssembly("Physics/OpenSim.Region.Physics.BasicPhysicsPlugin.dll");
-            testScene.PhysicsScene
-                = physicsPluginManager.GetPhysicsScene("basicphysics", "ZeroMesher", new IniConfigSource(), "test");
+            testScene.LoadWorldMap();           
 
             testScene.RegionInfo.EstateSettings = new EstateSettings();
             testScene.LoginsEnabled = true;
@@ -297,6 +311,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");
@@ -311,6 +330,19 @@ namespace OpenSim.Tests.Common
             return presenceService;
         }
 
+        private static PhysicsScene StartPhysicsScene()
+        {
+            IConfigSource config = new IniConfigSource();
+            config.AddConfig("Startup");
+            config.Configs["Startup"].Set("physics", "basicphysics");
+
+            PhysicsScene pScene = new BasicScene();
+            INonSharedRegionModule mod = pScene as INonSharedRegionModule;
+            mod.Initialise(config);
+
+            return pScene;
+        }
+
         /// <summary>
         /// Setup modules for a scene using their default settings.
         /// </summary>
@@ -447,9 +479,6 @@ namespace OpenSim.Tests.Common
         /// Add a root agent where the details of the agent connection (apart from the id) are unimportant for the test
         /// </summary>
         /// <remarks>
-        /// This can be used for tests where there is only one region or where there are multiple non-neighbour regions
-        /// and teleport doesn't take place.
-        ///
         /// XXX: Use the version of this method that takes the UserAccount structure wherever possible - this will
         /// make the agent circuit data (e.g. first, lastname) consistent with the user account data.
         /// </remarks>
@@ -462,22 +491,6 @@ namespace OpenSim.Tests.Common
         }
 
         /// <summary>
-        /// Add a root agent where the details of the agent connection (apart from the id) are unimportant for the test
-        /// </summary>
-        /// <remarks>
-        /// XXX: Use the version of this method that takes the UserAccount structure wherever possible - this will
-        /// make the agent circuit data (e.g. first, lastname) consistent with the user account data.
-        /// </remarks>
-        /// <param name="scene"></param>
-        /// <param name="agentId"></param>
-        /// <param name="sceneManager"></param>
-        /// <returns></returns>
-        public static ScenePresence AddScenePresence(Scene scene, UUID agentId, SceneManager sceneManager)
-        {
-            return AddScenePresence(scene, GenerateAgentData(agentId), sceneManager);
-        }
-
-        /// <summary>
         /// Add a root agent.
         /// </summary>
         /// <param name="scene"></param>
@@ -508,7 +521,7 @@ namespace OpenSim.Tests.Common
         /// <returns></returns>
         public static ScenePresence AddScenePresence(Scene scene, AgentCircuitData agentData)
         {
-            return AddScenePresence(scene, agentData, null);
+            return AddScenePresence(scene, new TestClient(agentData, scene), agentData);
         }
 
         /// <summary>
@@ -528,9 +541,9 @@ namespace OpenSim.Tests.Common
         /// </remarks>
         /// <param name="scene"></param>
         /// <param name="agentData"></param>
-        /// <param name="sceneManager"></param>
         /// <returns></returns>
-        public static ScenePresence AddScenePresence(Scene scene, AgentCircuitData agentData, SceneManager sceneManager)
+        public static ScenePresence AddScenePresence(
+            Scene scene, IClientAPI client, AgentCircuitData agentData)
         {
             // We emulate the proper login sequence here by doing things in four stages
 
@@ -541,7 +554,7 @@ namespace OpenSim.Tests.Common
             lpsc.m_PresenceService.LoginAgent(agentData.AgentID.ToString(), agentData.SessionID, agentData.SecureSessionID);
 
             // Stages 1 & 2
-            ScenePresence sp = IntroduceClientToScene(scene, sceneManager, agentData, TeleportFlags.ViaLogin);
+            ScenePresence sp = IntroduceClientToScene(scene, client, agentData, TeleportFlags.ViaLogin);
 
             // Stage 3: Complete the entrance into the region.  This converts the child agent into a root agent.
             sp.CompleteMovement(sp.ControllingClient, true);
@@ -553,37 +566,37 @@ namespace OpenSim.Tests.Common
         /// Introduce an agent into the scene by adding a new client.
         /// </summary>
         /// <returns>The scene presence added</returns>
-        /// <param name='sceneManager'>
-        /// Scene manager.  Can be null if there is only one region in the test or multiple regions that are not
-        /// neighbours and where no teleporting takes place.
-        /// </param>
         /// <param name='scene'></param>
-        /// <param name='sceneManager></param>
+        /// <param name='testClient'></param>
         /// <param name='agentData'></param>
         /// <param name='tf'></param>
         private static ScenePresence IntroduceClientToScene(
-            Scene scene, SceneManager sceneManager, AgentCircuitData agentData, TeleportFlags tf)
+            Scene scene, IClientAPI client, AgentCircuitData agentData, TeleportFlags tf)
         {
             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
-            TestClient client = new TestClient(agentData, scene, sceneManager);
-            scene.AddNewClient(client, PresenceType.User);
+            scene.AddNewAgent(client, PresenceType.User);
 
-            return scene.GetScenePresence(agentData.AgentID);
+            return scene.GetScenePresence(client.AgentId);
         }
 
         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
-            return IntroduceClientToScene(scene, null, acd, TeleportFlags.ViaLogin);
+            TestClient client = new TestClient(acd, scene);
+            return IntroduceClientToScene(scene, client, acd, TeleportFlags.ViaLogin);
         }
 
         /// <summary>
@@ -610,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 0a2b30a..3a3b33a 100644
--- a/OpenSim/Tests/Common/Helpers/TaskInventoryHelpers.cs
+++ b/OpenSim/Tests/Common/Helpers/TaskInventoryHelpers.cs
@@ -43,21 +43,40 @@ 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>
+        /// <param name="assetIDFrag">UUID or UUID stem</param>
+        /// <param name="text">The tex to put in the notecard.</param>
+        /// <returns>The item that was added</returns>
+        public static TaskInventoryItem AddNotecard(
+            IAssetService assetService, SceneObjectPart part, string itemName, string itemIDStem, string assetIDStem, string text)
+        {
+            return AddNotecard(
+                assetService, part, itemName, TestHelpers.ParseStem(itemIDStem), TestHelpers.ParseStem(assetIDStem), text);
+        }
+
+        /// <summary>
+        /// Add a notecard item to the given part.
+        /// </summary>
+        /// <param name="assetService"></param>
         /// <param name="part"></param>
         /// <param name="itemName"></param>
         /// <param name="itemID"></param>
         /// <param name="assetID"></param>
+        /// <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)
+        public static TaskInventoryItem AddNotecard(
+            IAssetService assetService, SceneObjectPart part, string itemName, UUID itemID, UUID assetID, string text)
         {
             AssetNotecard nc = new AssetNotecard();
-            nc.BodyText = "Hello World!";
+            nc.BodyText = text;
             nc.Encode();
 
             AssetBase ncAsset
                 = AssetHelpers.CreateAsset(assetID, AssetType.Notecard, nc.AssetData, UUID.Zero);
-            scene.AssetService.Store(ncAsset);
+            assetService.Store(ncAsset);
 
             TaskInventoryItem ncItem 
                 = new TaskInventoryItem 
@@ -75,44 +94,62 @@ 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>
         /// Add a simple script 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.
+        /// 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="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, 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="scene"></param>
+        /// <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(
-            Scene scene, SceneObjectPart part, string scriptName, string scriptSource)
+            IAssetService assetService, SceneObjectPart part, UUID itemId, UUID assetId, string scriptName, string scriptSource)
         {
             AssetScriptText ast = new AssetScriptText();
             ast.Source = scriptSource;
             ast.Encode();
 
-            UUID assetUuid = new UUID("00000000-0000-0000-1000-000000000000");
-            UUID itemUuid = new UUID("00000000-0000-0000-1100-000000000000");
             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;
         }
 
@@ -124,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/UserAccountHelpers.cs b/OpenSim/Tests/Common/Helpers/UserAccountHelpers.cs
index 2fbebc4..c62b58e 100644
--- a/OpenSim/Tests/Common/Helpers/UserAccountHelpers.cs
+++ b/OpenSim/Tests/Common/Helpers/UserAccountHelpers.cs
@@ -27,7 +27,7 @@
 
 using System.Collections.Generic;
 using OpenMetaverse;
-using OpenSim.Framework.Communications;
+
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Services.Interfaces;
 
diff --git a/OpenSim/Tests/Common/Helpers/UserInventoryHelpers.cs b/OpenSim/Tests/Common/Helpers/UserInventoryHelpers.cs
index 87d9410..5a36332 100644
--- a/OpenSim/Tests/Common/Helpers/UserInventoryHelpers.cs
+++ b/OpenSim/Tests/Common/Helpers/UserInventoryHelpers.cs
@@ -45,6 +45,9 @@ namespace OpenSim.Tests.Common
         /// <summary>
         /// Add an existing scene object as an item in the user's inventory.
         /// </summary>
+        /// <remarks>
+        /// Will be added to the system Objects folder.
+        /// </remarks>
         /// <param name='scene'></param>
         /// <param name='so'></param>
         /// <param name='inventoryIdTail'></param>
@@ -63,7 +66,29 @@ namespace OpenSim.Tests.Common
         }
 
         /// <summary>
-        /// Creates a notecard in the objects folder and specify an item id.
+        /// Add an existing scene object as an item in the user's inventory at the given path.
+        /// </summary>
+        /// <param name='scene'></param>
+        /// <param name='so'></param>
+        /// <param name='inventoryIdTail'></param>
+        /// <param name='assetIdTail'></param>
+        /// <returns>The inventory item created.</returns>
+        public static InventoryItemBase AddInventoryItem(
+            Scene scene, SceneObjectGroup so, int inventoryIdTail, int assetIdTail, string path)
+        {
+            return AddInventoryItem(
+                scene,
+                so.Name,
+                TestHelpers.ParseTail(inventoryIdTail),
+                InventoryType.Object,
+                AssetHelpers.CreateAsset(TestHelpers.ParseTail(assetIdTail), so),
+                so.OwnerID,
+                path);
+        }
+
+        /// <summary>
+        /// Adds the given item to the existing system folder for its type (e.g. an object will go in the "Objects"
+        /// folder).
         /// </summary>
         /// <param name="scene"></param>
         /// <param name="itemName"></param>
@@ -75,6 +100,25 @@ namespace OpenSim.Tests.Common
         private static InventoryItemBase AddInventoryItem(
             Scene scene, string itemName, UUID itemId, InventoryType itemType, AssetBase asset, UUID userId)
         {
+            return AddInventoryItem(
+                scene, itemName, itemId, itemType, asset, userId, 
+                scene.InventoryService.GetFolderForType(userId, (FolderType)asset.Type).Name);
+        }
+
+        /// <summary>
+        /// Adds the given item to an inventory folder
+        /// </summary>
+        /// <param name="scene"></param>
+        /// <param name="itemName"></param>
+        /// <param name="itemId"></param>
+        /// <param name="itemType"></param>
+        /// <param name="asset">The serialized asset for this item</param>
+        /// <param name="userId"></param>
+        /// <param name="path">Existing inventory path at which to add.</param>
+        /// <returns></returns>
+        private static InventoryItemBase AddInventoryItem(
+            Scene scene, string itemName, UUID itemId, InventoryType itemType, AssetBase asset, UUID userId, string path)
+        {
             scene.AssetService.Store(asset);
 
             InventoryItemBase item = new InventoryItemBase();
@@ -85,7 +129,7 @@ namespace OpenSim.Tests.Common
             item.AssetType = asset.Type;
             item.InvType = (int)itemType;
 
-            InventoryFolderBase folder = scene.InventoryService.GetFolderForType(userId, (AssetType)asset.Type);
+            InventoryFolderBase folder = InventoryArchiveUtils.FindFoldersByPath(scene.InventoryService, userId, path)[0];
 
             item.Folder = folder.ID;
             scene.AddInventoryItem(item);
@@ -156,58 +200,116 @@ namespace OpenSim.Tests.Common
         /// <summary>
         /// Create inventory folders starting from the user's root folder.
         /// </summary>
-        ///
-        /// Ignores any existing folders with the same name
-        /// 
         /// <param name="inventoryService"></param>
         /// <param name="userId"></param>
         /// <param name="path">
         /// The folders to create.  Multiple folders can be specified on a path delimited by the PATH_DELIMITER
         /// </param>
+        /// <param name="useExistingFolders">
+        /// If true, then folders in the path which already the same name are
+        /// used.  This applies to the terminal folder as well.  
+        /// If false, then all folders in the path are created, even if there is already a folder at a particular
+        /// level with the same name.
+        /// </param>
         /// <returns>
         /// The folder created.  If the path contains multiple folders then the last one created is returned.
         /// Will return null if the root folder could not be found.
         /// </returns>
         public static InventoryFolderBase CreateInventoryFolder(
-            IInventoryService inventoryService, UUID userId, string path)
+            IInventoryService inventoryService, UUID userId, string path, bool useExistingFolders)
+        {
+            return CreateInventoryFolder(inventoryService, userId, UUID.Random(), path, useExistingFolders);
+        }
+
+        /// <summary>
+        /// Create inventory folders starting from the user's root folder.
+        /// </summary>
+        /// <param name="inventoryService"></param>
+        /// <param name="userId"></param>
+        /// <param name="folderId"></param>
+        /// <param name="path">
+        /// The folders to create.  Multiple folders can be specified on a path delimited by the PATH_DELIMITER
+        /// </param>
+        /// <param name="useExistingFolders">
+        /// If true, then folders in the path which already the same name are
+        /// used.  This applies to the terminal folder as well.  
+        /// If false, then all folders in the path are created, even if there is already a folder at a particular
+        /// level with the same name.
+        /// </param>
+        /// <returns>
+        /// The folder created.  If the path contains multiple folders then the last one created is returned.
+        /// Will return null if the root folder could not be found.
+        /// </returns>
+        public static InventoryFolderBase CreateInventoryFolder(
+            IInventoryService inventoryService, UUID userId, UUID folderId, string path, bool useExistingFolders)
         {
             InventoryFolderBase rootFolder = inventoryService.GetRootFolder(userId);
 
             if (null == rootFolder)
                 return null;
 
-            return CreateInventoryFolder(inventoryService, rootFolder, path);
+            return CreateInventoryFolder(inventoryService, folderId, rootFolder, path, useExistingFolders);
         }
 
         /// <summary>
         /// Create inventory folders starting from a given parent folder
         /// </summary>
-        ///
-        /// Ignores any existing folders with the same name
-        /// 
+        /// <remarks>
+        /// If any stem of the path names folders that already exist then these are not recreated.  This includes the 
+        /// final folder.
+        /// TODO: May need to make it an option to create duplicate folders.
+        /// </remarks>
         /// <param name="inventoryService"></param>
+        /// <param name="folderId">ID of the folder to create</param>
         /// <param name="parentFolder"></param>
         /// <param name="path">
-        /// The folders to create.  Multiple folders can be specified on a path delimited by the PATH_DELIMITER
+        /// The folder to create.
+        /// </param>
+        /// <param name="useExistingFolders">
+        /// If true, then folders in the path which already the same name are
+        /// used.  This applies to the terminal folder as well.  
+        /// If false, then all folders in the path are created, even if there is already a folder at a particular
+        /// level with the same name.
         /// </param>
         /// <returns>
         /// The folder created.  If the path contains multiple folders then the last one created is returned.
         /// </returns>
         public static InventoryFolderBase CreateInventoryFolder(
-            IInventoryService inventoryService, InventoryFolderBase parentFolder, string path)
+            IInventoryService inventoryService, UUID folderId, InventoryFolderBase parentFolder, string path, bool useExistingFolders)
         {
             string[] components = path.Split(new string[] { PATH_DELIMITER }, 2, StringSplitOptions.None);
 
-            InventoryFolderBase newFolder 
-                = new InventoryFolderBase(
-                    UUID.Random(), components[0], parentFolder.Owner, (short)AssetType.Unknown, parentFolder.ID, 0);
-            
-            inventoryService.AddFolder(newFolder);
+            InventoryFolderBase folder = null;
+
+            if (useExistingFolders)
+                folder = InventoryArchiveUtils.FindFolderByPath(inventoryService, parentFolder, components[0]);
+
+            if (folder == null)
+            {
+//                Console.WriteLine("Creating folder {0} at {1}", components[0], parentFolder.Name);
+
+                UUID folderIdForCreate;
+
+                if (components.Length > 1)
+                    folderIdForCreate = UUID.Random();
+                else
+                    folderIdForCreate = folderId;
+
+                folder 
+                    = new InventoryFolderBase(
+                        folderIdForCreate, components[0], parentFolder.Owner, (short)AssetType.Unknown, parentFolder.ID, 0);
+                
+                inventoryService.AddFolder(folder);
+            }
+//            else
+//            {
+//                Console.WriteLine("Found existing folder {0}", folder.Name);
+//            }
 
             if (components.Length > 1)
-                return CreateInventoryFolder(inventoryService, newFolder, components[1]);
+                return CreateInventoryFolder(inventoryService, folderId, folder, components[1], useExistingFolders);
             else
-                return newFolder;
+                return folder;
         }
 
         /// <summary>
@@ -237,7 +339,7 @@ namespace OpenSim.Tests.Common
         /// <returns>An empty list if no matching folders were found</returns>
         public static List<InventoryFolderBase> GetInventoryFolders(IInventoryService inventoryService, UUID userId, string path)
         {
-            return InventoryArchiveUtils.FindFolderByPath(inventoryService, userId, path);
+            return InventoryArchiveUtils.FindFoldersByPath(inventoryService, userId, path);
         }
 
         /// <summary>