8 files changed, 519 insertions, 148 deletions

diff --git a/OpenSim/Tests/Common/Helpers/SceneHelpers.cs b/OpenSim/Tests/Common/Helpers/SceneHelpers.cs
index 318758d..769de83 100644
--- a/OpenSim/Tests/Common/Helpers/SceneHelpers.cs
+++ b/OpenSim/Tests/Common/Helpers/SceneHelpers.cs
@@ -58,57 +58,74 @@ namespace OpenSim.Tests.Common
     /// </summary>
     public class SceneHelpers
     {
-        public static TestScene SetupScene()
+        /// <summary>
+        /// We need a scene manager so that test clients can retrieve a scene when performing teleport tests.
+        /// </summary>
+        public SceneManager SceneManager { 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;
+        private LocalAuthenticationServicesConnector m_authenticationService;
+        private LocalInventoryServicesConnector m_inventoryService;
+        private LocalGridServicesConnector m_gridService;
+        private LocalUserAccountServicesConnector m_userAccountService;
+        private LocalPresenceServicesConnector m_presenceService;
+
+        private CoreAssetCache m_cache;
+
+        public SceneHelpers() : this(null) {}
+
+        public SceneHelpers(CoreAssetCache cache)
         {
-            return SetupScene(null);
+            SceneManager = new SceneManager();
+
+            m_assetService          = StartAssetService(cache);
+            m_authenticationService = StartAuthenticationService();
+            m_inventoryService      = StartInventoryService();
+            m_gridService           = StartGridService();
+            m_userAccountService    = StartUserAccountService();
+            m_presenceService       = StartPresenceService();
+
+            m_inventoryService.PostInitialise();
+            m_assetService.PostInitialise();
+            m_userAccountService.PostInitialise();
+            m_presenceService.PostInitialise();
+
+            m_cache = cache;
         }
 
         /// <summary>
         /// Set up a test scene
         /// </summary>
         /// <remarks>
-        /// Automatically starts service threads, as would the normal runtime.
+        /// Automatically starts services, as would the normal runtime.
         /// </remarks>
         /// <returns></returns>
-        public static TestScene SetupScene(CoreAssetCache cache)
+        public TestScene SetupScene()
         {
-            return SetupScene("Unit test region", UUID.Random(), 1000, 1000, cache);
+            return SetupScene("Unit test region", UUID.Random(), 1000, 1000);
         }
 
-        public static TestScene SetupScene(string name, UUID id, uint x, uint y)
-        {
-            return SetupScene(name, id, x, y, null);
-        }
-
-        /// <summary>
-        /// Set up a scene. If it's more then one scene, use the same CommunicationsManager to link regions
-        /// or a different, to get a brand new scene with new shared region modules.
-        /// </summary>
-        /// <param name="name">Name of the region</param>
-        /// <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="cache"></param>
-        /// <returns></returns>
-        public static TestScene SetupScene(
-            string name, UUID id, uint x, uint y, CoreAssetCache cache)
+        public TestScene SetupScene(string name, UUID id, uint x, uint y)
         {
-            return SetupScene(name, id, x, y, cache, new IniConfigSource());
+            return SetupScene(name, id, x, y, new IniConfigSource());
         }
 
         /// <summary>
-        /// Set up a scene. If it's more then one scene, use the same CommunicationsManager to link regions
-        /// or a different, to get a brand new scene with new shared region modules.
+        /// Set up a scene.
         /// </summary>
         /// <param name="name">Name of the region</param>
         /// <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="cache"></param>
         /// <param name="configSource"></param>
         /// <returns></returns>
-        public static TestScene SetupScene(
-            string name, UUID id, uint x, uint y, CoreAssetCache cache, IConfigSource configSource)
+        public TestScene SetupScene(
+            string name, UUID id, uint x, uint y, IConfigSource configSource)
         {
             Console.WriteLine("Setting up test scene {0}", name);
 
@@ -119,30 +136,47 @@ namespace OpenSim.Tests.Common
             regInfo.RegionName = name;
             regInfo.RegionID = id;
 
-            AgentCircuitManager acm = new AgentCircuitManager();
             SceneCommunicationService scs = new SceneCommunicationService();
 
-            ISimulationDataService simDataService = OpenSim.Server.Base.ServerUtils.LoadPlugin<ISimulationDataService>("OpenSim.Tests.Common.dll", null);
-            IEstateDataService estateDataService = null;
-
             TestScene testScene = new TestScene(
-                regInfo, acm, scs, simDataService, estateDataService, null, false, configSource, null);
+                regInfo, m_acm, scs, m_simDataService, m_estateDataService, null, false, configSource, null);
 
             IRegionModule godsModule = new GodsModule();
             godsModule.Initialise(testScene, new IniConfigSource());
             testScene.AddModule(godsModule.Name, godsModule);
 
-            LocalAssetServicesConnector       assetService       = StartAssetService(testScene, cache);
-                                                                   StartAuthenticationService(testScene);
-            LocalInventoryServicesConnector   inventoryService   = StartInventoryService(testScene);
-                                                                   StartGridService(testScene);
-            LocalUserAccountServicesConnector userAccountService = StartUserAccountService(testScene);
-            LocalPresenceServicesConnector    presenceService    = StartPresenceService(testScene);
-
-            inventoryService.PostInitialise();
-            assetService.PostInitialise();
-            userAccountService.PostInitialise();
-            presenceService.PostInitialise();
+            // Add scene to services
+            m_assetService.AddRegion(testScene);
+
+            if (m_cache != null)
+            {
+                m_cache.AddRegion(testScene);
+                m_cache.RegionLoaded(testScene);
+                testScene.AddRegionModule(m_cache.Name, m_cache);
+            }
+
+            m_assetService.RegionLoaded(testScene);
+            testScene.AddRegionModule(m_assetService.Name, m_assetService);
+
+            m_authenticationService.AddRegion(testScene);
+            m_authenticationService.RegionLoaded(testScene);
+            testScene.AddRegionModule(m_authenticationService.Name, m_authenticationService);
+
+            m_inventoryService.AddRegion(testScene);
+            m_inventoryService.RegionLoaded(testScene);
+            testScene.AddRegionModule(m_inventoryService.Name, m_inventoryService);
+
+            m_gridService.AddRegion(testScene);
+            m_gridService.RegionLoaded(testScene);
+            testScene.AddRegionModule(m_gridService.Name, m_gridService);
+
+            m_userAccountService.AddRegion(testScene);
+            m_userAccountService.RegionLoaded(testScene);
+            testScene.AddRegionModule(m_userAccountService.Name, m_userAccountService);
+
+            m_presenceService.AddRegion(testScene);
+            m_presenceService.RegionLoaded(testScene);
+            testScene.AddRegionModule(m_presenceService.Name, m_presenceService);
             
             testScene.RegionInfo.EstateSettings.EstateOwner = UUID.Random();
             testScene.SetModuleInterfaces();
@@ -153,28 +187,28 @@ namespace OpenSim.Tests.Common
             PhysicsPluginManager physicsPluginManager = new PhysicsPluginManager();
             physicsPluginManager.LoadPluginsFromAssembly("Physics/OpenSim.Region.Physics.BasicPhysicsPlugin.dll");
             testScene.PhysicsScene
-                = physicsPluginManager.GetPhysicsScene("basicphysics", "ZeroMesher",   new IniConfigSource(), "test");
+                = physicsPluginManager.GetPhysicsScene("basicphysics", "ZeroMesher", new IniConfigSource(), "test");
 
             testScene.RegionInfo.EstateSettings = new EstateSettings();
             testScene.LoginsDisabled = false;
             testScene.RegisterRegionWithGrid();
 
+            SceneManager.Add(testScene);
+
             return testScene;
         }
 
-        private static LocalAssetServicesConnector StartAssetService(Scene testScene, CoreAssetCache cache)
+        private static LocalAssetServicesConnector StartAssetService(CoreAssetCache cache)
         {
-            LocalAssetServicesConnector assetService = new LocalAssetServicesConnector();
             IConfigSource config = new IniConfigSource();
-            
             config.AddConfig("Modules");            
             config.Configs["Modules"].Set("AssetServices", "LocalAssetServicesConnector");            
             config.AddConfig("AssetService");
             config.Configs["AssetService"].Set("LocalServiceModule", "OpenSim.Services.AssetService.dll:AssetService");            
             config.Configs["AssetService"].Set("StorageProvider", "OpenSim.Tests.Common.dll");
-            
+
+            LocalAssetServicesConnector assetService = new LocalAssetServicesConnector();
             assetService.Initialise(config);
-            assetService.AddRegion(testScene);
 
             if (cache != null)
             {
@@ -184,56 +218,43 @@ namespace OpenSim.Tests.Common
                 cacheConfig.AddConfig("AssetCache");
 
                 cache.Initialise(cacheConfig);
-                cache.AddRegion(testScene);
-                cache.RegionLoaded(testScene);
-                testScene.AddRegionModule(cache.Name, cache);
             }
-
-            assetService.RegionLoaded(testScene);
-            testScene.AddRegionModule(assetService.Name, assetService);
             
             return assetService;
         }
 
-        private static void StartAuthenticationService(Scene testScene)
+        private static LocalAuthenticationServicesConnector StartAuthenticationService()
         {
-            ISharedRegionModule service = new LocalAuthenticationServicesConnector();
             IConfigSource config = new IniConfigSource();
-            
             config.AddConfig("Modules");
             config.AddConfig("AuthenticationService");
             config.Configs["Modules"].Set("AuthenticationServices", "LocalAuthenticationServicesConnector");
             config.Configs["AuthenticationService"].Set(
                 "LocalServiceModule", "OpenSim.Services.AuthenticationService.dll:PasswordAuthenticationService");
             config.Configs["AuthenticationService"].Set("StorageProvider", "OpenSim.Data.Null.dll");
-            
+
+            LocalAuthenticationServicesConnector service = new LocalAuthenticationServicesConnector();
             service.Initialise(config);
-            service.AddRegion(testScene);
-            service.RegionLoaded(testScene);
-            testScene.AddRegionModule(service.Name, service);
-            //m_authenticationService = service;
+
+            return service;
         }
 
-        private static LocalInventoryServicesConnector StartInventoryService(Scene testScene)
+        private static LocalInventoryServicesConnector StartInventoryService()
         {
-            LocalInventoryServicesConnector inventoryService = new LocalInventoryServicesConnector();
-            
             IConfigSource config = new IniConfigSource();            
             config.AddConfig("Modules");
             config.AddConfig("InventoryService");
             config.Configs["Modules"].Set("InventoryServices", "LocalInventoryServicesConnector");
             config.Configs["InventoryService"].Set("LocalServiceModule", "OpenSim.Services.InventoryService.dll:InventoryService");
             config.Configs["InventoryService"].Set("StorageProvider", "OpenSim.Tests.Common.dll");
-            
+
+            LocalInventoryServicesConnector inventoryService = new LocalInventoryServicesConnector();
             inventoryService.Initialise(config);
-            inventoryService.AddRegion(testScene);
-            inventoryService.RegionLoaded(testScene);
-            testScene.AddRegionModule(inventoryService.Name, inventoryService);
             
             return inventoryService;           
         }
 
-        private static LocalGridServicesConnector StartGridService(Scene testScene)
+        private static LocalGridServicesConnector StartGridService()
         {
             IConfigSource config = new IniConfigSource();
             config.AddConfig("Modules");
@@ -245,8 +266,6 @@ namespace OpenSim.Tests.Common
 
             LocalGridServicesConnector gridService = new LocalGridServicesConnector();
             gridService.Initialise(config);
-            gridService.AddRegion(testScene);
-            gridService.RegionLoaded(testScene);
             
             return gridService;
         }
@@ -256,7 +275,7 @@ namespace OpenSim.Tests.Common
         /// </summary>
         /// <param name="testScene"></param>
         /// <returns></returns>
-        private static LocalUserAccountServicesConnector StartUserAccountService(Scene testScene)
+        private static LocalUserAccountServicesConnector StartUserAccountService()
         {
             IConfigSource config = new IniConfigSource();
             config.AddConfig("Modules");
@@ -268,10 +287,6 @@ namespace OpenSim.Tests.Common
 
             LocalUserAccountServicesConnector userAccountService = new LocalUserAccountServicesConnector();
             userAccountService.Initialise(config);
-
-            userAccountService.AddRegion(testScene);
-            userAccountService.RegionLoaded(testScene);
-            testScene.AddRegionModule(userAccountService.Name, userAccountService);
             
             return userAccountService;
         }
@@ -280,7 +295,7 @@ namespace OpenSim.Tests.Common
         /// Start a presence service
         /// </summary>
         /// <param name="testScene"></param>
-        private static LocalPresenceServicesConnector StartPresenceService(Scene testScene)
+        private static LocalPresenceServicesConnector StartPresenceService()
         {
             IConfigSource config = new IniConfigSource();
             config.AddConfig("Modules");
@@ -292,10 +307,6 @@ namespace OpenSim.Tests.Common
 
             LocalPresenceServicesConnector presenceService = new LocalPresenceServicesConnector();
             presenceService.Initialise(config);
-
-            presenceService.AddRegion(testScene);
-            presenceService.RegionLoaded(testScene);
-            testScene.AddRegionModule(presenceService.Name, presenceService);
             
             return presenceService;
         }
@@ -313,19 +324,52 @@ namespace OpenSim.Tests.Common
         /// <summary>
         /// Setup modules for a scene.
         /// </summary>
-        /// <param name="scene"></param>
+        /// <remarks>
+        /// If called directly, then all the modules must be shared modules.
+        /// </remarks>
+        /// <param name="scenes"></param>
         /// <param name="config"></param>
         /// <param name="modules"></param>
         public static void SetupSceneModules(Scene scene, IConfigSource config, params object[] modules)
         {
+            SetupSceneModules(new Scene[] { scene }, config, modules);
+        }
+
+        /// <summary>
+        /// Setup modules for a scene using their default settings.
+        /// </summary>
+        /// <param name="scenes"></param>
+        /// <param name="modules"></param>
+        public static void SetupSceneModules(Scene[] scenes, params object[] modules)
+        {
+            SetupSceneModules(scenes, new IniConfigSource(), modules);
+        }
+
+        /// <summary>
+        /// Setup modules for scenes.
+        /// </summary>
+        /// <remarks>
+        /// If called directly, then all the modules must be shared modules.
+        /// </remarks>
+        /// <param name="scenes"></param>
+        /// <param name="config"></param>
+        /// <param name="modules"></param>
+        public static void SetupSceneModules(Scene[] scenes, IConfigSource config, params object[] modules)
+        {
             List<IRegionModuleBase> newModules = new List<IRegionModuleBase>();
             foreach (object module in modules)
             {
+//                Console.WriteLine("MODULE RAW {0}", module);
                 if (module is IRegionModule)
                 {
                     IRegionModule m = (IRegionModule)module;
-                    m.Initialise(scene, config);
-                    scene.AddModule(m.Name, m);
+
+                    foreach (Scene scene in scenes)
+                    {
+                        m.Initialise(scene, config);
+                        scene.AddModule(m.Name, m);
+                    }
+
                     m.PostInitialise();
                 }
                 else if (module is IRegionModuleBase)
@@ -333,6 +377,7 @@ namespace OpenSim.Tests.Common
                     // for the new system, everything has to be initialised first,
                     // shared modules have to be post-initialised, then all get an AddRegion with the scene
                     IRegionModuleBase m = (IRegionModuleBase)module;
+//                    Console.WriteLine("MODULE {0}", m.Name);
                     m.Initialise(config);
                     newModules.Add(m);
                 }
@@ -345,15 +390,19 @@ namespace OpenSim.Tests.Common
 
             foreach (IRegionModuleBase module in newModules)
             {
-                module.AddRegion(scene);
-                scene.AddRegionModule(module.Name, module);
+                foreach (Scene scene in scenes)
+                {
+                    module.AddRegion(scene);
+                    scene.AddRegionModule(module.Name, module);
+                }
             }
             
             // RegionLoaded is fired after all modules have been appropriately added to all scenes
             foreach (IRegionModuleBase module in newModules)
-                module.RegionLoaded(scene);                
+                foreach (Scene scene in scenes)
+                    module.RegionLoaded(scene);
 
-            scene.SetModuleInterfaces();
+            foreach (Scene scene in scenes) { scene.SetModuleInterfaces(); }
         }
 
         /// <summary>
@@ -363,31 +412,61 @@ namespace OpenSim.Tests.Common
         /// <returns></returns>
         public static AgentCircuitData GenerateAgentData(UUID agentId)
         {
-            string firstName = "testfirstname";
+            AgentCircuitData acd = GenerateCommonAgentData();
 
-            AgentCircuitData agentData = new AgentCircuitData();
-            agentData.AgentID = agentId;
-            agentData.firstname = firstName;
-            agentData.lastname = "testlastname";
+            acd.AgentID = agentId;
+            acd.firstname = "testfirstname";
+            acd.lastname = "testlastname";
+            acd.ServiceURLs = new Dictionary<string, object>();
+
+            return acd;
+        }
+
+        /// <summary>
+        /// Generate some standard agent connection data.
+        /// </summary>
+        /// <param name="agentId"></param>
+        /// <returns></returns>
+        public static AgentCircuitData GenerateAgentData(UserAccount ua)
+        {
+            AgentCircuitData acd = GenerateCommonAgentData();
+
+            acd.AgentID = ua.PrincipalID;
+            acd.firstname = ua.FirstName;
+            acd.lastname = ua.LastName;
+            acd.ServiceURLs = ua.ServiceURLs;
+
+            return acd;
+        }
+
+        private static AgentCircuitData GenerateCommonAgentData()
+        {
+            AgentCircuitData acd = new AgentCircuitData();
 
             // XXX: Sessions must be unique, otherwise one presence can overwrite another in NullPresenceData.
-            agentData.SessionID = UUID.Random();
-            agentData.SecureSessionID = UUID.Random();
-
-            agentData.circuitcode = 123;
-            agentData.BaseFolder = UUID.Zero;
-            agentData.InventoryFolder = UUID.Zero;
-            agentData.startpos = Vector3.Zero;
-            agentData.CapsPath = "http://wibble.com";
-            agentData.ServiceURLs = new Dictionary<string, object>();
-            agentData.Appearance = new AvatarAppearance();
-
-            return agentData;
+            acd.SessionID = UUID.Random();
+            acd.SecureSessionID = UUID.Random();
+
+            acd.circuitcode = 123;
+            acd.BaseFolder = UUID.Zero;
+            acd.InventoryFolder = UUID.Zero;
+            acd.startpos = Vector3.Zero;
+            acd.CapsPath = "http://wibble.com";
+            acd.Appearance = new AvatarAppearance();
+
+            return acd;
         }
 
         /// <summary>
         /// 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>
         /// <param name="scene"></param>
         /// <param name="agentId"></param>
         /// <returns></returns>
@@ -397,6 +476,33 @@ 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>
+        /// <param name="ua"></param>
+        /// <returns></returns>
+        public static ScenePresence AddScenePresence(Scene scene, UserAccount ua)
+        {
+            return AddScenePresence(scene, GenerateAgentData(ua));
+        }
+
+        /// <summary>
         /// Add a root agent.
         /// </summary>
         /// <remarks>
@@ -416,6 +522,30 @@ namespace OpenSim.Tests.Common
         /// <returns></returns>
         public static ScenePresence AddScenePresence(Scene scene, AgentCircuitData agentData)
         {
+            return AddScenePresence(scene, agentData, null);
+        }
+
+        /// <summary>
+        /// Add a root agent.
+        /// </summary>
+        /// <remarks>
+        /// This function
+        ///
+        /// 1)  Tells the scene that an agent is coming.  Normally, the login service (local if standalone, from the
+        /// userserver if grid) would give initial login data back to the client and separately tell the scene that the
+        /// agent was coming.
+        ///
+        /// 2)  Connects the agent with the scene
+        ///
+        /// This function performs actions equivalent with notifying the scene that an agent is
+        /// coming and then actually connecting the agent to the scene.  The one step missed out is the very first
+        /// </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)
+        {
             // We emulate the proper login sequence here by doing things in four stages
 
             // Stage 0: login
@@ -425,7 +555,7 @@ namespace OpenSim.Tests.Common
             lpsc.m_PresenceService.LoginAgent(agentData.AgentID.ToString(), agentData.SessionID, agentData.SecureSessionID);
 
             // Stages 1 & 2
-            ScenePresence sp = IntroduceClientToScene(scene, agentData, TeleportFlags.ViaLogin);
+            ScenePresence sp = IntroduceClientToScene(scene, sceneManager, 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);
@@ -433,7 +563,20 @@ namespace OpenSim.Tests.Common
             return sp;
         }
 
-        private static ScenePresence IntroduceClientToScene(Scene scene, AgentCircuitData agentData, TeleportFlags tf)
+        /// <summary>
+        /// 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='agentData'></param>
+        /// <param name='tf'></param>
+        private static ScenePresence IntroduceClientToScene(
+            Scene scene, SceneManager sceneManager, AgentCircuitData agentData, TeleportFlags tf)
         {
             string reason;
 
@@ -442,7 +585,7 @@ namespace OpenSim.Tests.Common
                 Console.WriteLine("NewUserConnection failed: " + reason);
 
             // Stage 2: add the new client as a child agent to the scene
-            TestClient client = new TestClient(agentData, scene);
+            TestClient client = new TestClient(agentData, scene, sceneManager);
             scene.AddNewClient(client, PresenceType.User);
 
             return scene.GetScenePresence(agentData.AgentID);
@@ -454,7 +597,7 @@ namespace OpenSim.Tests.Common
             acd.child = true;
 
             // XXX: ViaLogin may not be correct for child agents
-            return IntroduceClientToScene(scene, acd, TeleportFlags.ViaLogin);
+            return IntroduceClientToScene(scene, null, acd, TeleportFlags.ViaLogin);
         }
 
         /// <summary>
@@ -462,9 +605,9 @@ namespace OpenSim.Tests.Common
         /// </summary>
         /// <param name="scene"></param>
         /// <returns></returns>
-        public static SceneObjectPart AddSceneObject(Scene scene)
+        public static SceneObjectGroup AddSceneObject(Scene scene)
         {
-            return AddSceneObject(scene, "Test Object");
+            return AddSceneObject(scene, "Test Object", UUID.Zero);
         }
 
         /// <summary>
@@ -472,17 +615,18 @@ namespace OpenSim.Tests.Common
         /// </summary>
         /// <param name="scene"></param>
         /// <param name="name"></param>
+        /// <param name="ownerId"></param>
         /// <returns></returns>
-        public static SceneObjectPart AddSceneObject(Scene scene, string name)
+        public static SceneObjectGroup AddSceneObject(Scene scene, string name, UUID ownerId)
         {
-            SceneObjectPart part = CreateSceneObjectPart(name, UUID.Random(), UUID.Zero);
+            SceneObjectGroup so = new SceneObjectGroup(CreateSceneObjectPart(name, UUID.Random(), ownerId));
 
             //part.UpdatePrimFlags(false, false, true);
             //part.ObjectFlags |= (uint)PrimFlags.Phantom;
 
-            scene.AddNewSceneObject(new SceneObjectGroup(part), false);
+            scene.AddNewSceneObject(so, false);
 
-            return part;
+            return so;
         }
         
         /// <summary>
@@ -498,19 +642,36 @@ namespace OpenSim.Tests.Common
                 ownerId, PrimitiveBaseShape.Default, Vector3.Zero, Quaternion.Identity, Vector3.Zero) 
                     { Name = name, UUID = id, Scale = new Vector3(1, 1, 1) };            
         }
-        
+
         /// <summary>
         /// Create a scene object but do not add it to the scene.
         /// </summary>
         /// <remarks>
-        /// UUID always starts at 00000000-0000-0000-0000-000000000001
+        /// UUID always starts at 00000000-0000-0000-0000-000000000001.  For some purposes, (e.g. serializing direct
+        /// to another object's inventory) we do not need a scene unique ID.  So it would be better to add the
+        /// UUID when we actually add an object to a scene rather than on creation.
         /// </remarks>
         /// <param name="parts">The number of parts that should be in the scene object</param>
         /// <param name="ownerId"></param>
         /// <returns></returns>
         public static SceneObjectGroup CreateSceneObject(int parts, UUID ownerId)
         {            
-            return CreateSceneObject(parts, ownerId, "", 0x1);
+            return CreateSceneObject(parts, ownerId, 0x1);
+        }
+        
+        /// <summary>
+        /// Create a scene object but do not add it to the scene.
+        /// </summary>
+        /// <param name="parts">The number of parts that should be in the scene object</param>
+        /// <param name="ownerId"></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 CreateSceneObject(int parts, UUID ownerId, int uuidTail)
+        {            
+            return CreateSceneObject(parts, ownerId, "", uuidTail);
         }          
         
         /// <summary>
@@ -522,7 +683,7 @@ namespace OpenSim.Tests.Common
         /// <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. mynamePart0 for the root part)
+        /// (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}"
@@ -535,14 +696,14 @@ namespace OpenSim.Tests.Common
             
             SceneObjectGroup sog 
                 = new SceneObjectGroup(
-                    CreateSceneObjectPart(string.Format("{0}Part0", partNamePrefix), new UUID(rawSogId), ownerId));
+                    CreateSceneObjectPart(string.Format("{0}Part1", partNamePrefix), new UUID(rawSogId), ownerId));
             
             if (parts > 1)
-                for (int i = 1; i < parts; i++)
+                for (int i = 2; i <= parts; i++)
                     sog.AddPart(
                         CreateSceneObjectPart(
                             string.Format("{0}Part{1}", partNamePrefix, i), 
-                            new UUID(string.Format("00000000-0000-0000-0000-{0:X12}", uuidTail + i)), 
+                            new UUID(string.Format("00000000-0000-0000-0000-{0:X12}", uuidTail + i - 1)),
                             ownerId));
             
             return sog;
diff --git a/OpenSim/Tests/Common/Helpers/TaskInventoryHelpers.cs b/OpenSim/Tests/Common/Helpers/TaskInventoryHelpers.cs
index 7058d1e..9607f1f 100644
--- a/OpenSim/Tests/Common/Helpers/TaskInventoryHelpers.cs
+++ b/OpenSim/Tests/Common/Helpers/TaskInventoryHelpers.cs
@@ -45,20 +45,23 @@ namespace OpenSim.Tests.Common
         /// </summary>
         /// <param name="scene"></param>
         /// <param name="part"></param>
+        /// <param name="itemName"></param>
+        /// <param name="itemID"></param>
+        /// <param name="assetID"></param>
         /// <returns>The item that was added</returns>
-        public static TaskInventoryItem AddNotecard(Scene scene, SceneObjectPart part)
+        public static TaskInventoryItem AddNotecard(Scene scene, SceneObjectPart part, string itemName, UUID itemID, UUID assetID)
         {
             AssetNotecard nc = new AssetNotecard();
             nc.BodyText = "Hello World!";
             nc.Encode();
-            UUID ncAssetUuid = new UUID("00000000-0000-0000-1000-000000000000");
-            UUID ncItemUuid = new UUID("00000000-0000-0000-1100-000000000000");
+
             AssetBase ncAsset
-                = AssetHelpers.CreateAsset(ncAssetUuid, AssetType.Notecard, nc.AssetData, UUID.Zero);
+                = AssetHelpers.CreateAsset(assetID, AssetType.Notecard, nc.AssetData, UUID.Zero);
             scene.AssetService.Store(ncAsset);
+
             TaskInventoryItem ncItem 
                 = new TaskInventoryItem 
-                    { Name = "ncItem", AssetID = ncAssetUuid, ItemID = ncItemUuid, 
+                    { Name = itemName, AssetID = assetID, ItemID = itemID,
                       Type = (int)AssetType.Notecard, InvType = (int)InventoryType.Notecard };
             part.Inventory.AddInventoryItem(ncItem, true); 
             
@@ -66,8 +69,42 @@ namespace OpenSim.Tests.Common
         }
 
         /// <summary>
+        /// Add a blank 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.
+        /// </remarks>
+        /// <param name="scene"></param>
+        /// <param name="part"></param>
+        /// <returns>The item that was added</returns>
+        public static TaskInventoryItem AddScript(Scene scene, SceneObjectPart part)
+        {
+            AssetScriptText ast = new AssetScriptText();
+            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);
+            TaskInventoryItem item
+                = new TaskInventoryItem 
+                    { Name = "scriptItem", AssetID = assetUuid, ItemID = itemUuid,
+                      Type = (int)AssetType.LSLText, InvType = (int)InventoryType.LSL };
+            part.Inventory.AddInventoryItem(item, true);
+            
+            return item;
+        }
+
+        /// <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="scene"></param>
         /// <param name="sop"></param>
         /// <param name="itemName"></param>
diff --git a/OpenSim/Tests/Common/Helpers/UserAccountHelpers.cs b/OpenSim/Tests/Common/Helpers/UserAccountHelpers.cs
index b73df2c..2fbebc4 100644
--- a/OpenSim/Tests/Common/Helpers/UserAccountHelpers.cs
+++ b/OpenSim/Tests/Common/Helpers/UserAccountHelpers.cs
@@ -126,6 +126,11 @@ namespace OpenSim.Tests.Common
             return CreateUserWithInventory(scene, "Bill", "Bailey", userId, "troll");
         }
 
+        public static UserAccount CreateUserWithInventory(Scene scene, int userId)
+        {
+            return CreateUserWithInventory(scene, "Bill", "Bailey", TestHelpers.ParseTail(userId), "troll");
+        }
+
         public static UserAccount CreateUserWithInventory(
             Scene scene, string firstName, string lastName, UUID userId, string pw)
         {
@@ -133,6 +138,15 @@ namespace OpenSim.Tests.Common
             CreateUserWithInventory(scene, ua, pw);
             return ua;
         }
+
+        public static UserAccount CreateUserWithInventory(
+            Scene scene, string firstName, string lastName, int userId, string pw)
+        {
+            UserAccount ua
+                = new UserAccount(TestHelpers.ParseTail(userId)) { FirstName = firstName, LastName = lastName };
+            CreateUserWithInventory(scene, ua, pw);
+            return ua;
+        }
         
         public static void CreateUserWithInventory(Scene scene, UserAccount ua, string pw)
         {
diff --git a/OpenSim/Tests/Common/Mock/MockRegionDataPlugin.cs b/OpenSim/Tests/Common/Mock/MockRegionDataPlugin.cs
index 38fbbe3..3f99a39 100644
--- a/OpenSim/Tests/Common/Mock/MockRegionDataPlugin.cs
+++ b/OpenSim/Tests/Common/Mock/MockRegionDataPlugin.cs
@@ -113,6 +113,21 @@ namespace OpenSim.Data.Null
             m_store.StoreRegionWindlightSettings(wl);
         }
 
+        public string LoadRegionEnvironmentSettings(UUID regionUUID)
+        {
+            return m_store.LoadRegionEnvironmentSettings(regionUUID);
+        }
+
+        public void StoreRegionEnvironmentSettings(UUID regionUUID, string settings)
+        {
+            m_store.StoreRegionEnvironmentSettings(regionUUID, settings);
+        }
+
+        public void RemoveRegionEnvironmentSettings(UUID regionUUID)
+        {
+            m_store.RemoveRegionEnvironmentSettings(regionUUID);
+        }
+
         public UUID[] GetObjectIDs(UUID regionID)
         {
             return new UUID[0];
@@ -163,7 +178,25 @@ namespace OpenSim.Data.Null
         {
             //This connector doesn't support the windlight module yet
         }
-        
+
+        #region Environment Settings
+        public string LoadRegionEnvironmentSettings(UUID regionUUID)
+        {
+            //This connector doesn't support the Environment module yet
+            return string.Empty;
+        }
+
+        public void StoreRegionEnvironmentSettings(UUID regionUUID, string settings)
+        {
+            //This connector doesn't support the Environment module yet
+        }
+
+        public void RemoveRegionEnvironmentSettings(UUID regionUUID)
+        {
+            //This connector doesn't support the Environment module yet
+        }
+        #endregion
+
         public RegionSettings LoadRegionSettings(UUID regionUUID)
         {
             RegionSettings rs = null;
diff --git a/OpenSim/Tests/Common/Mock/TestClient.cs b/OpenSim/Tests/Common/Mock/TestClient.cs
index b2c824c..fb70904 100644
--- a/OpenSim/Tests/Common/Mock/TestClient.cs
+++ b/OpenSim/Tests/Common/Mock/TestClient.cs
@@ -46,12 +46,10 @@ namespace OpenSim.Tests.Common.Mock
 
         EventWaitHandle wh = new EventWaitHandle (false, EventResetMode.AutoReset, "Crossing");
 
-        // TODO: This is a really nasty (and temporary) means of telling the test client which scene to invoke setup
-        // methods on when a teleport is requested
-        public Scene TeleportTargetScene;
         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<UUID> ReceivedOfflineNotifications { get; private set; }
@@ -435,15 +433,29 @@ 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)
+        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)
         {
             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;
@@ -593,8 +605,16 @@ namespace OpenSim.Tests.Common.Mock
             AgentCircuitData newAgent = RequestClientInfo();
 
             // Stage 2: add the new client as a child agent to the scene
-            TeleportSceneClient = new TestClient(newAgent, TeleportTargetScene);
-            TeleportTargetScene.AddNewClient(TeleportSceneClient, PresenceType.User);
+            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);
         }
 
         public virtual void SendRegionTeleport(ulong regionHandle, byte simAccess, IPEndPoint regionExternalEndPoint,
@@ -604,6 +624,13 @@ namespace OpenSim.Tests.Common.Mock
 
             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);
         }
@@ -1104,10 +1131,6 @@ namespace OpenSim.Tests.Common.Mock
         {
         }
 
-        public void KillEndDone()
-        {
-        }
-
         public void SendEventInfoReply (EventData info)
         {
         }
diff --git a/OpenSim/Tests/Common/Mock/TestLandChannel.cs b/OpenSim/Tests/Common/Mock/TestLandChannel.cs
index 0e4dfb9..4b4d52d 100644
--- a/OpenSim/Tests/Common/Mock/TestLandChannel.cs
+++ b/OpenSim/Tests/Common/Mock/TestLandChannel.cs
@@ -46,6 +46,14 @@ namespace OpenSim.Tests.Common.Mock
         {
             m_scene = scene;
             m_parcels = new List<ILandObject>();
+            SetupDefaultParcel();
+        }
+
+        private void SetupDefaultParcel()
+        {
+            ILandObject obj = new LandObject(UUID.Zero, false, m_scene);
+            obj.LandData.Name = "Your Parcel";
+            m_parcels.Add(obj);
         }
 
         public List<ILandObject> ParcelsNearPoint(Vector3 position)
@@ -63,11 +71,7 @@ namespace OpenSim.Tests.Common.Mock
             m_parcels.Clear();
 
             if (setupDefaultParcel)
-            {
-                ILandObject obj = new LandObject(UUID.Zero, false, m_scene);
-                obj.LandData.Name = "Your Parcel";
-                m_parcels.Add(obj);
-            }
+                SetupDefaultParcel();
         }
 
         protected ILandObject GetNoLand()
@@ -102,6 +106,5 @@ namespace OpenSim.Tests.Common.Mock
 
         public void Join(int start_x, int start_y, int end_x, int end_y, UUID attempting_user_id) {}
         public void Subdivide(int start_x, int start_y, int end_x, int end_y, UUID attempting_user_id) {}
-
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Tests/Common/OpenSimTestCase.cs b/OpenSim/Tests/Common/OpenSimTestCase.cs
new file mode 100644
index 0000000..8c40923
--- /dev/null
+++ b/OpenSim/Tests/Common/OpenSimTestCase.cs
@@ -0,0 +1,46 @@
+/*
+ * 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 NUnit.Framework;
+
+namespace OpenSim.Tests.Common
+{
+    [TestFixture]
+    public class OpenSimTestCase
+    {
+        [SetUp]
+        public virtual void SetUp()
+        {
+//            TestHelpers.InMethod();
+            // Disable logging for each test so that one where logging is enabled doesn't cause all subsequent tests
+            // to have logging on if it failed with an exception.
+            TestHelpers.DisableLogging();
+        }
+    }
+}
+
diff --git a/OpenSim/Tests/Common/TestHelpers.cs b/OpenSim/Tests/Common/TestHelpers.cs
index ced06de..30121fe 100644
--- a/OpenSim/Tests/Common/TestHelpers.cs
+++ b/OpenSim/Tests/Common/TestHelpers.cs
@@ -27,6 +27,8 @@
 
 using System;
 using System.Diagnostics;
+using System.IO;
+using System.Text;
 using NUnit.Framework;
 using OpenMetaverse;
 
@@ -34,6 +36,38 @@ namespace OpenSim.Tests.Common
 {
     public class TestHelpers
     {
+        private static Stream EnableLoggingConfigStream
+            = new MemoryStream(
+                Encoding.UTF8.GetBytes(
+@"<log4net>
+  <!-- A1 is set to be a ConsoleAppender -->
+  <appender name=""A1"" type=""log4net.Appender.ConsoleAppender"">
+
+    <!-- A1 uses PatternLayout -->
+    <layout type=""log4net.Layout.PatternLayout"">
+    <!-- Print the date in ISO 8601 format -->
+      <!-- <conversionPattern value=""%date [%thread] %-5level %logger %ndc - %message%newline"" /> -->
+      <conversionPattern value=""%date %message%newline"" />
+      </layout>
+  </appender>
+
+  <!-- Set root logger level to DEBUG and its only appender to A1 -->
+  <root>
+    <level value=""DEBUG"" />
+    <appender-ref ref=""A1"" />
+  </root>
+</log4net>"));
+
+        private static MemoryStream DisableLoggingConfigStream
+            = new MemoryStream(
+                Encoding.UTF8.GetBytes(
+//                        "<?xml version=\"1.0\" encoding=\"utf-8\" ?><configuration><log4net><root><level value=\"OFF\"/><appender-ref ref=\"A1\"/></root></log4net></configuration>"));
+                    //"<?xml version=\"1.0\" encoding=\"utf-8\" ?><configuration><log4net><root><level value=\"OFF\"/></root></log4net></configuration>")));
+//                    "<configuration><log4net><root><level value=\"OFF\"/></root></log4net></configuration>"));
+//                    "<configuration><log4net><root></root></log4net></configuration>")));
+//                    "<configuration><log4net><root/></log4net></configuration>"));
+                    "<log4net><root/></log4net>"));
+
         public static bool AssertThisDelegateCausesArgumentException(TestDelegate d)
         {
             try
@@ -58,6 +92,26 @@ namespace OpenSim.Tests.Common
             Console.WriteLine("===> In Test Method : {0} <===", stackTrace.GetFrame(1).GetMethod().Name);
         }
 
+        public static void EnableLogging()
+        {
+            log4net.Config.XmlConfigurator.Configure(EnableLoggingConfigStream);
+        }
+
+        /// <summary>
+        /// Disable logging whilst running the tests.
+        /// </summary>
+        /// <remarks>
+        /// Remember, if a regression test throws an exception before completing this will not be invoked if it's at
+        /// the end of the test.
+        /// TODO: Always invoke this after every test - probably need to make all test cases inherit from a common
+        /// TestCase class where this can be done.
+        /// </remarks>
+        public static void DisableLogging()
+        {
+            log4net.Config.XmlConfigurator.Configure(DisableLoggingConfigStream);
+            DisableLoggingConfigStream.Position = 0;
+        }
+
         /// <summary>
         /// Parse tail section into full UUID.
         /// </summary>