Merge branch 'master' of ssh://opensimulator.org/var/git/opensim

15 files changed, 823 insertions, 103 deletions

diff --git a/OpenSim/Data/Tests/BasicUserTest.cs b/OpenSim/Data/Tests/BasicUserTest.cs
index d3e6f41..4e4ddc8 100644
--- a/OpenSim/Data/Tests/BasicUserTest.cs
+++ b/OpenSim/Data/Tests/BasicUserTest.cs
@@ -204,8 +204,16 @@ namespace OpenSim.Data.Tests
             UUID webloginkey = UUID.Random();
             uint homeregx = (uint) random.Next();
             uint homeregy = (uint) random.Next();
-            Vector3 homeloc = new Vector3((float)Math.Round(random.NextDouble(),5),(float)Math.Round(random.NextDouble(),5),(float)Math.Round(random.NextDouble(),5));
-            Vector3 homelookat = new Vector3((float)Math.Round(random.NextDouble(),5),(float)Math.Round(random.NextDouble(),5),(float)Math.Round(random.NextDouble(),5));
+            Vector3 homeloc 
+                = new Vector3(
+                    (float)Math.Round(random.NextDouble(), 5),
+                    (float)Math.Round(random.NextDouble(), 5),
+                    (float)Math.Round(random.NextDouble(), 5));
+            Vector3 homelookat 
+                = new Vector3(
+                    (float)Math.Round(random.NextDouble(), 5),
+                    (float)Math.Round(random.NextDouble(), 5),
+                    (float)Math.Round(random.NextDouble(), 5));
             int created = random.Next();
             int lastlogin = random.Next();
             string userinvuri = RandomName();
diff --git a/OpenSim/Data/Tests/PropertyCompareConstraint.cs b/OpenSim/Data/Tests/PropertyCompareConstraint.cs
new file mode 100644
index 0000000..678501e
--- /dev/null
+++ b/OpenSim/Data/Tests/PropertyCompareConstraint.cs
@@ -0,0 +1,298 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using NUnit.Framework;
+using NUnit.Framework.Constraints;
+using NUnit.Framework.SyntaxHelpers;
+using OpenMetaverse;
+using OpenSim.Framework;
+
+namespace OpenSim.Data.Tests
+{
+    public static class Constraints
+    {
+        //This is here because C# has a gap in the language, you can't infer type from a constructor
+        public static PropertyCompareConstraint<T> PropertyCompareConstraint<T>(T expected)
+        {
+            return new PropertyCompareConstraint<T>(expected);
+        }
+    }
+
+    public class PropertyCompareConstraint<T> : NUnit.Framework.Constraints.Constraint
+    {
+        private readonly object _expected;
+        //the reason everywhere uses propertyNames.Reverse().ToArray() is because the stack is backwards of the order we want to display the properties in.
+        private string failingPropertyName = string.Empty;
+        private object failingExpected;
+        private object failingActual;
+
+        public PropertyCompareConstraint(T expected)
+        {
+            _expected = expected;
+        }
+
+        public override bool Matches(object actual)
+        {
+            return ObjectCompare(_expected, actual, new Stack<string>());
+        }
+
+        private bool ObjectCompare(object expected, object actual, Stack<string> propertyNames)
+        {
+            if (actual.GetType() != expected.GetType())
+            {
+                propertyNames.Push("GetType()");
+                failingPropertyName = string.Join(".", propertyNames.Reverse().ToArray());
+                propertyNames.Pop();
+                failingActual = actual.GetType();
+                failingExpected = expected.GetType();
+                return false;
+            }
+
+            if(actual.GetType() == typeof(Color))
+            {
+                Color actualColor = (Color) actual;
+                Color expectedColor = (Color) expected;
+                if (actualColor.R != expectedColor.R)
+                {
+                    propertyNames.Push("R");
+                    failingPropertyName = string.Join(".", propertyNames.Reverse().ToArray());
+                    propertyNames.Pop();
+                    failingActual = actualColor.R;
+                    failingExpected = expectedColor.R;
+                    return false;
+                }
+                if (actualColor.G != expectedColor.G)
+                {
+                    propertyNames.Push("G");
+                    failingPropertyName = string.Join(".", propertyNames.Reverse().ToArray());
+                    propertyNames.Pop();
+                    failingActual = actualColor.G;
+                    failingExpected = expectedColor.G;
+                    return false;
+                }
+                if (actualColor.B != expectedColor.B)
+                {
+                    propertyNames.Push("B");
+                    failingPropertyName = string.Join(".", propertyNames.Reverse().ToArray());
+                    propertyNames.Pop();
+                    failingActual = actualColor.B;
+                    failingExpected = expectedColor.B;
+                    return false;
+                }
+                if (actualColor.A != expectedColor.A)
+                {
+                    propertyNames.Push("A");
+                    failingPropertyName = string.Join(".", propertyNames.Reverse().ToArray());
+                    propertyNames.Pop();
+                    failingActual = actualColor.A;
+                    failingExpected = expectedColor.A;
+                    return false;
+                }
+                return true;
+            }
+
+            //Skip static properties.  I had a nasty problem comparing colors because of all of the public static colors.
+            PropertyInfo[] properties = expected.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
+            foreach (var property in properties)
+            {
+                if (ignores.Contains(property.Name))
+                    continue;
+
+                object actualValue = property.GetValue(actual, null);
+                object expectedValue = property.GetValue(expected, null);
+
+                //If they are both null, they are equal
+                if (actualValue == null && expectedValue == null)
+                    continue;
+
+                //If only one is null, then they aren't
+                if (actualValue == null || expectedValue == null)
+                {
+                    propertyNames.Push(property.Name);
+                    failingPropertyName = string.Join(".", propertyNames.Reverse().ToArray());
+                    propertyNames.Pop();
+                    failingActual = actualValue;
+                    failingExpected = expectedValue;
+                    return false;
+                }
+
+                IComparable comp = actualValue as IComparable;
+                if (comp != null)
+                {
+                    if (comp.CompareTo(expectedValue) != 0)
+                    {
+                        propertyNames.Push(property.Name);
+                        failingPropertyName = string.Join(".", propertyNames.Reverse().ToArray());
+                        propertyNames.Pop();
+                        failingActual = actualValue;
+                        failingExpected = expectedValue;
+                        return false;
+                    }
+                    continue;
+                }
+
+                IEnumerable arr = actualValue as IEnumerable;
+                if (arr != null)
+                {
+                    List<object> actualList = arr.Cast<object>().ToList();
+                    List<object> expectedList = ((IEnumerable)expectedValue).Cast<object>().ToList();
+                    if (actualList.Count != expectedList.Count)
+                    {
+                        propertyNames.Push(property.Name);
+                        propertyNames.Push("Count");
+                        failingPropertyName = string.Join(".", propertyNames.Reverse().ToArray());
+                        failingActual = actualList.Count;
+                        failingExpected = expectedList.Count;
+                        propertyNames.Pop();
+                        propertyNames.Pop();
+                    }
+                    //Todo: A value-wise comparison of all of the values.
+                    //Everything seems okay...
+                    continue;
+                }
+
+                propertyNames.Push(property.Name);
+                if (!ObjectCompare(expectedValue, actualValue, propertyNames))
+                    return false;
+                propertyNames.Pop();
+            }
+
+            return true;
+        }
+
+        public override void WriteDescriptionTo(MessageWriter writer)
+        {
+            writer.WriteExpectedValue(failingExpected);
+        }
+
+        public override void WriteActualValueTo(MessageWriter writer)
+        {
+            writer.WriteActualValue(failingActual);
+            writer.WriteLine();
+            writer.Write("  On Property: " + failingPropertyName);
+        }
+
+        //These notes assume the lambda: (x=>x.Parent.Value)
+        //ignores should really contain like a fully dotted version of the property name, but I'm starting with small steps
+        readonly List<string> ignores = new List<string>();
+        public PropertyCompareConstraint<T> IgnoreProperty(Expression<Func<T, object>> func)
+        {
+            Expression express = func.Body;
+            PullApartExpression(express);
+
+            return this;
+        }
+
+        private void PullApartExpression(Expression express)
+        {
+            //This deals with any casts... like implicit casts to object.  Not all UnaryExpression are casts, but this is a first attempt.
+            if (express is UnaryExpression)
+                PullApartExpression(((UnaryExpression)express).Operand);
+            if (express is MemberExpression)
+            {
+                //If the inside of the lambda is the access to x, we've hit the end of the chain.
+                //   We should track by the fully scoped parameter name, but this is the first rev of doing this.
+                if (((MemberExpression)express).Expression is ParameterExpression)
+                {
+                    ignores.Add(((MemberExpression)express).Member.Name);
+                }
+                else
+                {
+                    //Otherwise there could be more parameters inside...
+                    PullApartExpression(((MemberExpression)express).Expression);
+                }
+            }
+        }
+    }
+
+    [TestFixture]
+    public class PropertyCompareConstraintTest
+    {
+        public class HasInt
+        {
+            public int TheValue { get; set; }
+        }
+
+        [Test]
+        public void IntShouldMatch()
+        {
+            HasInt actual = new HasInt { TheValue = 5 };
+            HasInt expected = new HasInt { TheValue = 5 };
+            var constraint = Constraints.PropertyCompareConstraint(expected);
+
+            Assert.That(constraint.Matches(actual), Is.True);
+        }
+
+        [Test]
+        public void IntShouldNotMatch()
+        {
+            HasInt actual = new HasInt { TheValue = 5 };
+            HasInt expected = new HasInt { TheValue = 4 };
+            var constraint = Constraints.PropertyCompareConstraint(expected);
+
+            Assert.That(constraint.Matches(actual), Is.False);
+        }
+
+
+        [Test]
+        public void IntShouldIgnore()
+        {
+            HasInt actual = new HasInt { TheValue = 5 };
+            HasInt expected = new HasInt { TheValue = 4 };
+            var constraint = Constraints.PropertyCompareConstraint(expected).IgnoreProperty(x=>x.TheValue);
+
+            Assert.That(constraint.Matches(actual), Is.True);
+        }
+
+        [Test]
+        public void AssetShouldMatch()
+        {
+            UUID uuid1 = UUID.Random();
+            AssetBase actual = new AssetBase(uuid1, "asset one");
+            AssetBase expected = new AssetBase(uuid1, "asset one");
+
+            var constraint = Constraints.PropertyCompareConstraint(expected);
+
+            Assert.That(constraint.Matches(actual), Is.True);
+        }
+
+        [Test]
+        public void AssetShouldNotMatch()
+        {
+            UUID uuid1 = UUID.Random();
+            AssetBase actual = new AssetBase(uuid1, "asset one");
+            AssetBase expected = new AssetBase(UUID.Random(), "asset one");
+
+            var constraint = Constraints.PropertyCompareConstraint(expected);
+
+            Assert.That(constraint.Matches(actual), Is.False);
+        }
+
+        [Test]
+        public void AssetShouldNotMatch2()
+        {
+            UUID uuid1 = UUID.Random();
+            AssetBase actual = new AssetBase(uuid1, "asset one");
+            AssetBase expected = new AssetBase(uuid1, "asset two");
+
+            var constraint = Constraints.PropertyCompareConstraint(expected);
+
+            Assert.That(constraint.Matches(actual), Is.False);
+        }
+
+        [Test]
+        public void TestColors()
+        {
+            Color actual = Color.Red;
+            Color expected = Color.FromArgb(actual.A, actual.R, actual.G, actual.B);
+
+            var constraint = Constraints.PropertyCompareConstraint(expected);
+
+            Assert.That(constraint.Matches(actual), Is.True);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Data/Tests/ScrambleForTesting.cs b/OpenSim/Data/Tests/ScrambleForTesting.cs
new file mode 100644
index 0000000..c6e467f
--- /dev/null
+++ b/OpenSim/Data/Tests/ScrambleForTesting.cs
@@ -0,0 +1,102 @@
+using System;
+using System.Collections;
+using System.Reflection;
+using System.Text;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenSim.Framework;
+
+namespace OpenSim.Data.Tests
+{
+    public static class ScrambleForTesting
+    {
+        private static readonly Random random = new Random();
+        public static void Scramble(object obj)
+        {
+            PropertyInfo[] properties = obj.GetType().GetProperties();
+            foreach (var property in properties)
+            {
+                //Skip indexers of classes.  We will assume that everything that has an indexer
+                //  is also IEnumberable.  May not always be true, but should be true normally.
+                if(property.GetIndexParameters().Length > 0)
+                    continue;
+
+                RandomizeProperty(obj, property, null);
+            }
+            //Now if it implments IEnumberable, it's probably some kind of list, so we should randomize
+            //  everything inside of it.
+            IEnumerable enumerable = obj as IEnumerable;
+            if(enumerable != null)
+            {
+                foreach (object value in enumerable)
+                {
+                    Scramble(value);
+                }
+            }
+        }
+
+        private static void RandomizeProperty(object obj, PropertyInfo property, object[] index)
+        {
+            Type t = property.PropertyType;
+            if (!property.CanWrite)
+                return;
+            object value = property.GetValue(obj, index);
+            if (value == null)
+                return;
+
+            if (t == typeof (string))
+                property.SetValue(obj, RandomName(), index);
+            else if (t == typeof (UUID))
+                property.SetValue(obj, UUID.Random(), index);
+            else if (t == typeof (sbyte))
+                property.SetValue(obj, (sbyte)random.Next(sbyte.MinValue, sbyte.MaxValue), index);
+            else if (t == typeof (short))
+                property.SetValue(obj, (short)random.Next(short.MinValue, short.MaxValue), index);
+            else if (t == typeof (int))
+                property.SetValue(obj, random.Next(), index);
+            else if (t == typeof (long))
+                property.SetValue(obj, random.Next() * int.MaxValue, index);
+            else if (t == typeof (byte))
+                property.SetValue(obj, (byte)random.Next(byte.MinValue, byte.MaxValue), index);
+            else if (t == typeof (ushort))
+                property.SetValue(obj, (ushort)random.Next(ushort.MinValue, ushort.MaxValue), index);
+            else if (t == typeof (uint))
+                property.SetValue(obj, Convert.ToUInt32(random.Next()), index);
+            else if (t == typeof (ulong))
+                property.SetValue(obj, Convert.ToUInt64(random.Next()) * Convert.ToUInt64(UInt32.MaxValue), index);
+            else if (t == typeof (bool))
+                property.SetValue(obj, true, index);
+            else if (t == typeof (byte[]))
+            {
+                byte[] bytes = new byte[30];
+                random.NextBytes(bytes);
+                property.SetValue(obj, bytes, index);
+            }
+            else
+                Scramble(value);
+        }
+
+        private static string RandomName()
+        {
+            StringBuilder name = new StringBuilder();
+            int size = random.Next(5, 12);
+            for (int i = 0; i < size; i++)
+            {
+                char ch = Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65)));
+                name.Append(ch);
+            }
+            return name.ToString();
+        }
+    }
+
+    [TestFixture]
+    public class ScrableForTestingTest
+    {
+        [Test]
+        public void TestScramble()
+        {
+            AssetBase actual = new AssetBase(UUID.Random(), "asset one");
+            ScrambleForTesting.Scramble(actual);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiverTests.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiverTests.cs
index 28b4d64..470a386 100644
--- a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiverTests.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiverTests.cs
@@ -74,7 +74,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
         /// <summary>
         /// Test saving a V0.1 OpenSim Inventory Archive (subject to change since there is no fixed format yet).
         /// </summary>
-        //[Test]
+        [Test]
         public void TestSaveIarV0_1()
         {
             TestHelper.InMethod();
@@ -82,7 +82,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 
             InventoryArchiverModule archiverModule = new InventoryArchiverModule();
 
-            Scene scene = SceneSetupHelpers.SetupScene("");
+            Scene scene = SceneSetupHelpers.SetupScene("Inventory");
             SceneSetupHelpers.SetupSceneModules(scene, archiverModule);
             CommunicationsManager cm = scene.CommsManager;
 
@@ -222,7 +222,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
         /// Test loading a V0.1 OpenSim Inventory Archive (subject to change since there is no fixed format yet) where
         /// an account exists with the creator name.
         /// </summary>
-        //[Test]
+        [Test]
         public void TestLoadIarV0_1ExistingUsers()
         {   
             TestHelper.InMethod();
@@ -262,7 +262,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             InventoryArchiverModule archiverModule = new InventoryArchiverModule();
             
             // Annoyingly, we have to set up a scene even though inventory loading has nothing to do with a scene
-            Scene scene = SceneSetupHelpers.SetupScene();
+            Scene scene = SceneSetupHelpers.SetupScene("inventory");
             IUserAdminService userAdminService = scene.CommsManager.UserAdminService;
             
             SceneSetupHelpers.SetupSceneModules(scene, serialiserModule, archiverModule);
@@ -276,16 +276,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 
             CachedUserInfo userInfo 
                 = scene.CommsManager.UserProfileCacheService.GetUserDetails(userFirstName, userLastName);
-            //userInfo.FetchInventory();
-            /*
-            for (int i = 0 ; i < 50 ; i++)
-            {
-                if (userInfo.HasReceivedInventory == true)
-                    break;
-                Thread.Sleep(200);
-            }
-            Assert.That(userInfo.HasReceivedInventory, Is.True, "FetchInventory timed out (10 seconds)");
-            */
+
             InventoryItemBase foundItem = userInfo.RootFolder.FindItemByPath(itemName);
             Assert.That(foundItem, Is.Not.Null, "Didn't find loaded item");
             Assert.That(
@@ -395,17 +386,6 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
                 userInfo = UserProfileTestUtils.CreateUserWithInventory(commsManager, InventoryReceived);
                 Monitor.Wait(this, 60000);
             }
-           
-            //userInfo.FetchInventory();
-            /*
-            for (int i = 0 ; i < 50 ; i++)
-            {
-                if (userInfo.HasReceivedInventory == true)
-                    break;
-                Thread.Sleep(200);
-            }
-            Assert.That(userInfo.HasReceivedInventory, Is.True, "FetchInventory timed out (10 seconds)");
-            */
             
             Console.WriteLine("userInfo.RootFolder 1: {0}", userInfo.RootFolder);
             
@@ -429,22 +409,15 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 
             Console.WriteLine("userInfo.RootFolder 2: {0}", userInfo.RootFolder);
 
-            try
-            {
-                new InventoryArchiveReadRequest(userInfo, null, (Stream)null, null, null)
-                    .ReplicateArchivePathToUserInventory(itemArchivePath, false, userInfo.RootFolder, foldersCreated, nodesLoaded);           
-
-                Console.WriteLine("userInfo.RootFolder 3: {0}", userInfo.RootFolder);
-                InventoryFolderImpl folder1 = userInfo.RootFolder.FindFolderByPath("a");
-                Assert.That(folder1, Is.Not.Null, "Could not find folder a");
-                InventoryFolderImpl folder2 = folder1.FindFolderByPath("b");            
-                Assert.That(folder2, Is.Not.Null, "Could not find folder b");
-            }
-            catch (NullReferenceException e)
-            {
-                // Non fatal for now until we resolve the race condition
-                Console.WriteLine("Test failed with {0}", e);
-            }
+            new InventoryArchiveReadRequest(userInfo, null, (Stream)null, null, null)
+                .ReplicateArchivePathToUserInventory(
+                    itemArchivePath, false, userInfo.RootFolder, foldersCreated, nodesLoaded);
+
+            Console.WriteLine("userInfo.RootFolder 3: {0}", userInfo.RootFolder);
+            InventoryFolderImpl folder1 = userInfo.RootFolder.FindFolderByPath("a");
+            Assert.That(folder1, Is.Not.Null, "Could not find folder a");
+            InventoryFolderImpl folder2 = folder1.FindFolderByPath("b");            
+            Assert.That(folder2, Is.Not.Null, "Could not find folder b");
         }
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 919075c..18d7bad 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -1038,6 +1038,10 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// Send out simstats data to all clients
+        /// </summary>
+        /// <param name="stats">Stats on the Simulator's performance</param>
         private void SendSimStatsPackets(SimStats stats)
         {
             List<ScenePresence> StatSendAgents = GetScenePresences();
@@ -1050,6 +1054,9 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// Recount SceneObjectPart in parcel aabb
+        /// </summary>
         private void UpdateLand()
         {
             if (LandChannel != null)
@@ -1061,11 +1068,17 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// Update the terrain if it needs to be updated.
+        /// </summary>
         private void UpdateTerrain()
         {
             EventManager.TriggerTerrainTick();
         }
 
+        /// <summary>
+        /// Back up queued up changes
+        /// </summary>
         private void UpdateStorageBackup()
         {
             if (!m_backingup)
@@ -1078,6 +1091,9 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// Sends out the OnFrame event to the modules
+        /// </summary>
         private void UpdateEvents()
         {
             m_eventManager.TriggerOnFrame();
@@ -1133,6 +1149,10 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// Synchronous force backup.  For deletes and links/unlinks
+        /// </summary>
+        /// <param name="group">Object to be backed up</param>
         public void ForceSceneObjectBackup(SceneObjectGroup group)
         {
             if (group != null)
@@ -1141,6 +1161,13 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// Return object to avatar Message
+        /// </summary>
+        /// <param name="agentID">Avatar Unique Id</param>
+        /// <param name="objectName">Name of object returned</param>
+        /// <param name="location">Location of object returned</param>
+        /// <param name="reason">Reasion for object return</param>
         public void AddReturn(UUID agentID, string objectName, Vector3 location, string reason)
         {
             lock (m_returns)
@@ -1167,6 +1194,9 @@ namespace OpenSim.Region.Framework.Scenes
 
         #region Load Terrain
 
+        /// <summary>
+        /// Store the terrain in the persistant data store
+        /// </summary>
         public void SaveTerrain()
         {
             m_storageManager.DataStore.StoreTerrain(Heightmap.GetDoubles(), RegionInfo.RegionID);
@@ -1269,6 +1299,10 @@ namespace OpenSim.Region.Framework.Scenes
 
         #region Load Land
 
+        /// <summary>
+        /// Loads all Parcel data from the datastore for region identified by regionID
+        /// </summary>
+        /// <param name="regionID">Unique Identifier of the Region to load parcel data for</param>
         public void loadAllLandObjectsFromStorage(UUID regionID)
         {
             m_log.Info("[SCENE]: Loading land objects from storage");
@@ -1322,6 +1356,20 @@ namespace OpenSim.Region.Framework.Scenes
             m_log.Info("[SCENE]: Loaded " + PrimsFromDB.Count.ToString() + " SceneObject(s)");
         }
 
+
+        /// <summary>
+        /// Gets a new rez location based on the raycast and the size of the object that is being rezzed.
+        /// </summary>
+        /// <param name="RayStart"></param>
+        /// <param name="RayEnd"></param>
+        /// <param name="RayTargetID"></param>
+        /// <param name="rot"></param>
+        /// <param name="bypassRayCast"></param>
+        /// <param name="RayEndIsIntersection"></param>
+        /// <param name="frontFacesOnly"></param>
+        /// <param name="scale"></param>
+        /// <param name="FaceCenter"></param>
+        /// <returns></returns>
         public Vector3 GetNewRezLocation(Vector3 RayStart, Vector3 RayEnd, UUID RayTargetID, Quaternion rot, byte bypassRayCast, byte RayEndIsIntersection, bool frontFacesOnly, Vector3 scale, bool FaceCenter)
         {
             Vector3 pos = Vector3.Zero;
@@ -1412,6 +1460,19 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+
+        /// <summary>
+        /// Create a New SceneObjectGroup/Part by raycasting
+        /// </summary>
+        /// <param name="ownerID"></param>
+        /// <param name="groupID"></param>
+        /// <param name="RayEnd"></param>
+        /// <param name="rot"></param>
+        /// <param name="shape"></param>
+        /// <param name="bypassRaycast"></param>
+        /// <param name="RayStart"></param>
+        /// <param name="RayTargetID"></param>
+        /// <param name="RayEndIsIntersection"></param>
         public virtual void AddNewPrim(UUID ownerID, UUID groupID, Vector3 RayEnd, Quaternion rot, PrimitiveBaseShape shape,
                                        byte bypassRaycast, Vector3 RayStart, UUID RayTargetID,
                                        byte RayEndIsIntersection)
@@ -1829,6 +1890,12 @@ namespace OpenSim.Region.Framework.Scenes
             return true;
         }
 
+        /// <summary>
+        /// Attachment rezzing
+        /// </summary>
+        /// <param name="userID">Agent Unique ID</param>
+        /// <param name="itemID">Object ID</param>
+        /// <returns>False</returns>
         public virtual bool IncomingCreateObject(UUID userID, UUID itemID)
         {
             ScenePresence sp = GetScenePresence(userID);
@@ -1841,6 +1908,13 @@ namespace OpenSim.Region.Framework.Scenes
             return false;
         }
 
+        /// <summary>
+        /// Adds a Scene Object group to the Scene.
+        /// Verifies that the creator of the object is not banned from the simulator.
+        /// Checks if the item is an Attachment
+        /// </summary>
+        /// <param name="sceneObject"></param>
+        /// <returns>True if the SceneObjectGroup was added, False if it was not</returns>
         public bool AddSceneObject(SceneObjectGroup sceneObject)
         {
             // If the user is banned, we won't let any of their objects
@@ -1933,6 +2007,10 @@ namespace OpenSim.Region.Framework.Scenes
 
         #region Add/Remove Avatar Methods
 
+        /// <summary>
+        /// Adding a New Client and Create a Presence for it.
+        /// </summary>
+        /// <param name="client"></param>
         public override void AddNewClient(IClientAPI client)
         {
             SubscribeToClientEvents(client);
@@ -1977,6 +2055,10 @@ namespace OpenSim.Region.Framework.Scenes
             EventManager.TriggerOnNewClient(client);
         }
 
+        /// <summary>
+        /// Register for events from the client
+        /// </summary>
+        /// <param name="client">The IClientAPI of the connected client</param>
         protected virtual void SubscribeToClientEvents(IClientAPI client)
         {
             client.OnRegionHandShakeReply += SendLayerData;
@@ -2070,8 +2152,8 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Teleport an avatar to their home region
         /// </summary>
-        /// <param name="agentId"></param>
-        /// <param name="client"></param>
+        /// <param name="agentId">The avatar's Unique ID</param>
+        /// <param name="client">The IClientAPI for the client</param>
         public virtual void TeleportClientHome(UUID agentId, IClientAPI client)
         {
             UserProfileData UserProfile = CommsManager.UserService.GetUserProfile(agentId);
@@ -2099,6 +2181,21 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// Duplicates object specified by localID at position raycasted against RayTargetObject using 
+        /// RayEnd and RayStart to determine what the angle of the ray is
+        /// </summary>
+        /// <param name="localID">ID of object to duplicate</param>
+        /// <param name="dupeFlags"></param>
+        /// <param name="AgentID">Agent doing the duplication</param>
+        /// <param name="GroupID">Group of new object</param>
+        /// <param name="RayTargetObj">The target of the Ray</param>
+        /// <param name="RayEnd">The ending of the ray (farthest away point)</param>
+        /// <param name="RayStart">The Beginning of the ray (closest point)</param>
+        /// <param name="BypassRaycast">Bool to bypass raycasting</param>
+        /// <param name="RayEndIsIntersection">The End specified is the place to add the object</param>
+        /// <param name="CopyCenters">Position the object at the center of the face that it's colliding with</param>
+        /// <param name="CopyRotates">Rotate the object the same as the localID object</param>
         public void doObjectDuplicateOnRay(uint localID, uint dupeFlags, UUID AgentID, UUID GroupID,
                                            UUID RayTargetObj, Vector3 RayEnd, Vector3 RayStart,
                                            bool BypassRaycast, bool RayEndIsIntersection, bool CopyCenters, bool CopyRotates)
@@ -2170,6 +2267,14 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// Sets the Home Point.   The GridService uses this to know where to put a user when they log-in
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="regionHandle"></param>
+        /// <param name="position"></param>
+        /// <param name="lookAt"></param>
+        /// <param name="flags"></param>
         public virtual void SetHomeRezPoint(IClientAPI remoteClient, ulong regionHandle, Vector3 position, Vector3 lookAt, uint flags)
         {
             UserProfileData UserProfile = CommsManager.UserService.GetUserProfile(remoteClient.AgentId);
@@ -2340,6 +2445,12 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// Removes region from an avatar's known region list.  This coincides with child agents.  For each child agent, there will be a known region entry.
+        /// 
+        /// </summary>
+        /// <param name="avatarID"></param>
+        /// <param name="regionslst"></param>
         public void HandleRemoveKnownRegionsFromAvatar(UUID avatarID, List<ulong> regionslst)
         {
             ScenePresence av = GetScenePresence(avatarID);
@@ -2355,12 +2466,19 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// Closes all endpoints with the circuitcode provided.
+        /// </summary>
+        /// <param name="circuitcode">Circuit Code of the endpoint to close</param>
         public override void CloseAllAgents(uint circuitcode)
         {
             // Called by ClientView to kill all circuit codes
             ClientManager.CloseAllAgents(circuitcode);
         }
 
+        /// <summary>
+        /// Inform all other ScenePresences on this Scene that someone else has changed position on the minimap.
+        /// </summary>
         public void NotifyMyCoarseLocationChange()
         {
             ForEachScenePresence(delegate(ScenePresence presence) { presence.CoarseLocationChange(); });
@@ -2455,9 +2573,10 @@ namespace OpenSim.Region.Framework.Scenes
         /// The return bool should allow for connections to be refused, but as not all calling paths
         /// take proper notice of it let, we allowed banned users in still.
         /// </summary>
-        /// <param name="regionHandle"></param>
-        /// <param name="agent"></param>
-        /// <param name="reason"></param>
+        /// <param name="agent">CircuitData of the agent who is connecting</param>
+        /// <param name="reason">Outputs the reason for the false response on this string</param>
+        /// <returns>True if the region accepts this agent.  False if it does not.  False will 
+        /// also return a reason.</returns>
         public bool NewUserConnection(AgentCircuitData agent, out string reason)
         {
             // Don't disable this log message - it's too helpful
@@ -2530,6 +2649,13 @@ namespace OpenSim.Region.Framework.Scenes
             return true;
         }
 
+        /// <summary>
+        /// Verifies that the user has a session on the Grid
+        /// </summary>
+        /// <param name="agent">Circuit Data of the Agent we're verifying</param>
+        /// <param name="reason">Outputs the reason for the false response on this string</param>
+        /// <returns>True if the user has a session on the grid.  False if it does not.  False will 
+        /// also return a reason.</returns>
         public virtual bool AuthenticateUser(AgentCircuitData agent, out string reason)
         {
             reason = String.Empty;
@@ -2542,6 +2668,13 @@ namespace OpenSim.Region.Framework.Scenes
             return result;
         }
 
+        /// <summary>
+        /// Verify if the user can connect to this region.  Checks the banlist and ensures that the region is set for public access
+        /// </summary>
+        /// <param name="agent">The circuit data for the agent</param>
+        /// <param name="reason">outputs the reason to this string</param>
+        /// <returns>True if the region accepts this agent.  False if it does not.  False will 
+        /// also return a reason.</returns>
         protected virtual bool AuthorizeUser(AgentCircuitData agent, out string reason)
         {
             reason = String.Empty;
@@ -2600,16 +2733,32 @@ namespace OpenSim.Region.Framework.Scenes
             return true;
         }
 
+        /// <summary>
+        /// Update an AgentCircuitData object with new information
+        /// </summary>
+        /// <param name="data">Information to update the AgentCircuitData with</param>
         public void UpdateCircuitData(AgentCircuitData data)
         {
             m_authenticateHandler.UpdateAgentData(data);
         }
 
+        /// <summary>
+        /// Change the Circuit Code for the user's Circuit Data
+        /// </summary>
+        /// <param name="oldcc">The old Circuit Code.  Must match a previous circuit code</param>
+        /// <param name="newcc">The new Circuit Code.  Must not be an already existing circuit code</param>
+        /// <returns>True if we successfully changed it.  False if we did not</returns>
         public bool ChangeCircuitCode(uint oldcc, uint newcc)
         {
             return m_authenticateHandler.TryChangeCiruitCode(oldcc, newcc);
         }
 
+        /// <summary>
+        /// The Grid has requested that we log-off a user.  Log them off.
+        /// </summary>
+        /// <param name="AvatarID">Unique ID of the avatar to log-off</param>
+        /// <param name="RegionSecret">SecureSessionID of the user, or the RegionSecret text when logging on to the grid</param>
+        /// <param name="message">message to display to the user.  Reason for being logged off</param>
         public void HandleLogOffUserFromGrid(UUID AvatarID, UUID RegionSecret, string message)
         {
             ScenePresence loggingOffUser = null;
@@ -2675,6 +2824,13 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// We've got an update about an agent that sees into this region, 
+        /// send it to ScenePresence for processing  It's the full data.
+        /// </summary>
+        /// <param name="cAgentData">Agent that contains all of the relevant things about an agent.  
+        /// Appearance, animations, position, etc.</param>
+        /// <returns>true if we handled it.</returns>
         public virtual bool IncomingChildAgentDataUpdate(AgentData cAgentData)
         {
 //            m_log.DebugFormat(
@@ -2692,6 +2848,12 @@ namespace OpenSim.Region.Framework.Scenes
             return false;
         }
 
+        /// <summary>
+        /// We've got an update about an agent that sees into this region, 
+        /// send it to ScenePresence for processing  It's only positional data
+        /// </summary>
+        /// <param name="cAgentData">AgentPosition that contains agent positional data so we can know what to send</param>
+        /// <returns>true if we handled it.</returns>
         public virtual bool IncomingChildAgentDataUpdate(AgentPosition cAgentData)
         {
             //m_log.Debug(" XXX Scene IncomingChildAgentDataUpdate POSITION in " + RegionInfo.RegionName);
diff --git a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
index 0140faa..c1e39a9 100644
--- a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
@@ -48,6 +48,9 @@ namespace OpenSim.Region.Framework.Scenes
 
     public delegate void RemoveKnownRegionsFromAvatarList(UUID avatarID, List<ulong> regionlst);
 
+    /// <summary>
+    /// Class that Region communications runs through
+    /// </summary>
     public class SceneCommunicationService //one instance per region
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
@@ -60,15 +63,46 @@ namespace OpenSim.Region.Framework.Scenes
 
         protected List<UUID> m_agentsInTransit;
 
+        /// <summary>
+        /// An agent is crossing into this region
+        /// </summary>
         public event AgentCrossing OnAvatarCrossingIntoRegion;
+
+        /// <summary>
+        /// A user will arrive shortly, set up appropriate credentials so it can connect
+        /// </summary>
         public event ExpectUserDelegate OnExpectUser;
+
+        /// <summary>
+        /// A Prim will arrive shortly
+        /// </summary>
         public event ExpectPrimDelegate OnExpectPrim;
         public event CloseAgentConnection OnCloseAgentConnection;
+
+        /// <summary>
+        /// A new prim has arrived
+        /// </summary>
         public event PrimCrossing OnPrimCrossingIntoRegion;
+
+        /// <summary>
+        /// A New Region is up and available
+        /// </summary>
         public event RegionUp OnRegionUp;
+
+        /// <summary>
+        /// We have a child agent for this avatar and we're getting a status update about it
+        /// </summary>
         public event ChildAgentUpdate OnChildAgentUpdate;
         //public event RemoveKnownRegionsFromAvatarList OnRemoveKnownRegionFromAvatar;
+
+        /// <summary>
+        /// Time to log one of our users off.   Grid Service sends this mostly
+        /// </summary>
         public event LogOffUser OnLogOffUser;
+
+        /// <summary>
+        /// A region wants land data from us!
+        /// </summary>
         public event GetLandData OnGetLandData;
 
         private AgentCrossing handlerAvatarCrossingIntoRegion = null; // OnAvatarCrossingIntoRegion;
@@ -123,11 +157,20 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// Returns a region with the name closest to string provided
+        /// </summary>
+        /// <param name="name">Partial Region Name for matching</param>
+        /// <returns>Region Information for the region</returns>
         public RegionInfo RequestClosestRegion(string name)
         {
             return m_commsProvider.GridService.RequestClosestRegion(name);
         }
 
+        /// <summary>
+        /// This region is shutting down, de-register all events!
+        /// De-Register region from Grid!
+        /// </summary>
         public void Close()
         {
             if (regionCommsHost != null)
@@ -159,10 +202,9 @@ namespace OpenSim.Region.Framework.Scenes
         #region CommsManager Event handlers
 
         /// <summary>
-        ///
+        /// A New User will arrive shortly, Informs the scene that there's a new user on the way
         /// </summary>
-        /// <param name="regionHandle"></param>
-        /// <param name="agent"></param>
+        /// <param name="agent">Data we need to ensure that the agent can connect</param>
         ///
         protected void NewUserConnection(AgentCircuitData agent)
         {
@@ -174,6 +216,12 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// The Grid has requested us to log-off the user
+        /// </summary>
+        /// <param name="AgentID">Unique ID of agent to log-off</param>
+        /// <param name="RegionSecret">The secret string that the region establishes with the grid when registering</param>
+        /// <param name="message">The message to send to the user that tells them why they were logged off</param>
         protected void GridLogOffUser(UUID AgentID, UUID RegionSecret, string message)
         {
             handlerLogOffUser = OnLogOffUser;
@@ -183,6 +231,11 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// A New Region is now available.  Inform the scene that there is a new region available.
+        /// </summary>
+        /// <param name="region">Information about the new region that is available</param>
+        /// <returns>True if the event was handled</returns>
         protected bool newRegionUp(RegionInfo region)
         {
             handlerRegionUp = OnRegionUp;
@@ -194,6 +247,11 @@ namespace OpenSim.Region.Framework.Scenes
             return true;
         }
 
+        /// <summary>
+        /// Inform the scene that we've got an update about a child agent that we have
+        /// </summary>
+        /// <param name="cAgentData"></param>
+        /// <returns></returns>
         protected bool ChildAgentUpdate(ChildAgentDataUpdate cAgentData)
         {
             handlerChildAgentUpdate = OnChildAgentUpdate;
@@ -204,6 +262,7 @@ namespace OpenSim.Region.Framework.Scenes
             return true;
         }
 
+
         protected void AgentCrossing(UUID agentID, Vector3 position, bool isFlying)
         {
             handlerAvatarCrossingIntoRegion = OnAvatarCrossingIntoRegion;
@@ -213,6 +272,13 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// We have a new prim from a neighbor
+        /// </summary>
+        /// <param name="primID">unique ID for the primative</param>
+        /// <param name="objXMLData">XML2 encoded data of the primative</param>
+        /// <param name="XMLMethod">An Int that represents the version of the XMLMethod</param>
+        /// <returns>True if the prim was accepted, false if it was not</returns>
         protected bool IncomingPrimCrossing(UUID primID, String objXMLData, int XMLMethod)
         {
             handlerExpectPrim = OnExpectPrim;
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTests.cs
index a3672d5..88452d2 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTests.cs
@@ -113,6 +113,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             agent.InventoryFolder = UUID.Zero;
             agent.startpos = Vector3.Zero;
             agent.CapsPath = GetRandomCapsObjectPath();
+            agent.ChildrenCapSeeds = new Dictionary<ulong, string>();
 
             string reason;
             scene.NewUserConnection(agent, out reason);
diff --git a/OpenSim/Region/Framework/Scenes/Tests/StandaloneTeleportTests.cs b/OpenSim/Region/Framework/Scenes/Tests/StandaloneTeleportTests.cs
index ed2d317..23eab90 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/StandaloneTeleportTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/StandaloneTeleportTests.cs
@@ -38,6 +38,7 @@ using OpenSim.Region.CoreModules.ServiceConnectorsOut.Interregion;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
 using OpenSim.Tests.Common.Setup;
+using System.Threading;
 
 namespace OpenSim.Region.Framework.Scenes.Tests
 {
@@ -55,56 +56,130 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         public void TestSimpleNotNeighboursTeleport()
         {
             TestHelper.InMethod();
+            ThreadRunResults results = new ThreadRunResults();
+            results.Result = false;
+            results.Message = "Test did not run";
+            TestRunning testClass = new TestRunning(results);
 
+            Thread testThread = new Thread(testClass.run);
+
+            try
+            {
+                // Seems kind of redundant to start a thread and then join it, however..   We need to protect against
+                // A thread abort exception in the simulator code.
+                testThread.Start();
+                testThread.Join();
+            } 
+            catch (ThreadAbortException)
+            {
+                
+            }
+            Assert.That(testClass.results.Result, Is.EqualTo(true), testClass.results.Message);
             // Console.WriteLine("Beginning test {0}", MethodBase.GetCurrentMethod());
+        }
+
+    }
+
+    public class ThreadRunResults
+    {
+        public bool Result = false;
+        public string Message = string.Empty;
+    }
+
+    public class TestRunning
+    {
+        public ThreadRunResults results;
+        public TestRunning(ThreadRunResults t)
+        {
+            results = t;
+        }
+        public void run(object o)
+        {
             
+            //results.Result = true;
             log4net.Config.XmlConfigurator.Configure();
-            
+
             UUID sceneAId = UUID.Parse("00000000-0000-0000-0000-000000000100");
             UUID sceneBId = UUID.Parse("00000000-0000-0000-0000-000000000200");
             TestCommunicationsManager cm = new TestCommunicationsManager();
 
             // shared module
             ISharedRegionModule interregionComms = new RESTInterregionComms();
-            
+
             Scene sceneA = SceneSetupHelpers.SetupScene("sceneA", sceneAId, 1000, 1000, cm);
             SceneSetupHelpers.SetupSceneModules(sceneA, new IniConfigSource(), interregionComms);
             sceneA.RegisterRegionWithGrid();
-            
+
             Scene sceneB = SceneSetupHelpers.SetupScene("sceneB", sceneBId, 1010, 1010, cm);
             SceneSetupHelpers.SetupSceneModules(sceneB, new IniConfigSource(), interregionComms);
             sceneB.RegisterRegionWithGrid();
- 
-            UUID agentId = UUID.Parse("00000000-0000-0000-0000-000000000041");                      
+
+            UUID agentId = UUID.Parse("00000000-0000-0000-0000-000000000041");
             TestClient client = SceneSetupHelpers.AddRootAgent(sceneA, agentId);
- 
+
             ICapabilitiesModule sceneACapsModule = sceneA.RequestModuleInterface<ICapabilitiesModule>();
+
+            results.Result = (sceneACapsModule.GetCapsPath(agentId) == client.CapsSeedUrl);
             
+            if (!results.Result)
+            {
+                results.Message = "Incorrect caps object path set up in sceneA";
+                return;
+            }
+
+            /*
             Assert.That(
-                sceneACapsModule.GetCapsPath(agentId), 
-                Is.EqualTo(client.CapsSeedUrl), 
+                sceneACapsModule.GetCapsPath(agentId),
+                Is.EqualTo(client.CapsSeedUrl),
                 "Incorrect caps object path set up in sceneA");
-                        
+            */
             // FIXME: This is a hack to get the test working - really the normal OpenSim mechanisms should be used.
-            client.TeleportTargetScene = sceneB;            
-            client.Teleport(sceneB.RegionInfo.RegionHandle, new Vector3(100, 100, 100), new Vector3(40, 40, 40));
             
-            Assert.That(sceneB.GetScenePresence(agentId), Is.Not.Null, "Client does not have an agent in sceneB");                                   
-            Assert.That(sceneA.GetScenePresence(agentId), Is.Null, "Client still had an agent in sceneA");
+
+            client.TeleportTargetScene = sceneB;
+            client.Teleport(sceneB.RegionInfo.RegionHandle, new Vector3(100, 100, 100), new Vector3(40, 40, 40));
+
+            results.Result = (sceneB.GetScenePresence(agentId) != null);
+            if (!results.Result)
+            {
+                results.Message = "Client does not have an agent in sceneB";
+                return;
+            }
+
+            //Assert.That(sceneB.GetScenePresence(agentId), Is.Not.Null, "Client does not have an agent in sceneB");
             
+            //Assert.That(sceneA.GetScenePresence(agentId), Is.Null, "Client still had an agent in sceneA");
+
+            results.Result = (sceneA.GetScenePresence(agentId) == null);
+            if (!results.Result)
+            {
+                results.Message = "Client still had an agent in sceneA";
+                return;
+            }
+
             ICapabilitiesModule sceneBCapsModule = sceneB.RequestModuleInterface<ICapabilitiesModule>();
-            
+
+
+            results.Result = ("http://" + sceneB.RegionInfo.ExternalHostName + ":" + sceneB.RegionInfo.HttpPort +
+                              "/CAPS/" + sceneBCapsModule.GetCapsPath(agentId) + "0000/" == client.CapsSeedUrl);
+            if (!results.Result)
+            {
+                results.Message = "Incorrect caps object path set up in sceneB";
+                return;
+            }
+
             // Temporary assertion - caps url construction should at least be doable through a method.
+            /*
             Assert.That(
-                "http://" + sceneB.RegionInfo.ExternalHostName + ":" + sceneB.RegionInfo.HttpPort + "/CAPS/" + sceneBCapsModule.GetCapsPath(agentId) + "0000/", 
-                Is.EqualTo(client.CapsSeedUrl), 
-                "Incorrect caps object path set up in sceneB");  
-            
+                "http://" + sceneB.RegionInfo.ExternalHostName + ":" + sceneB.RegionInfo.HttpPort + "/CAPS/" + sceneBCapsModule.GetCapsPath(agentId) + "0000/",
+                Is.EqualTo(client.CapsSeedUrl),
+                "Incorrect caps object path set up in sceneB");
+            */
             // This assertion will currently fail since we don't remove the caps paths when no longer needed
             //Assert.That(sceneACapsModule.GetCapsPath(agentId), Is.Null, "sceneA still had a caps object path");
-            
+
             // TODO: Check that more of everything is as it should be
-            
+
             // TODO: test what happens if we try to teleport to a region that doesn't exist
         }
     }
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
index ff85b96..691732a 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
@@ -125,9 +125,9 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             if (lease.CurrentState == LeaseState.Initial)
             {
-                lease.InitialLeaseTime = TimeSpan.FromMinutes(1.0);
-                lease.RenewOnCallTime = TimeSpan.FromSeconds(10.0);
-                lease.SponsorshipTimeout = TimeSpan.FromMinutes(1.0);
+                lease.InitialLeaseTime = TimeSpan.FromMinutes(0);
+//                lease.RenewOnCallTime = TimeSpan.FromSeconds(10.0);
+//                lease.SponsorshipTimeout = TimeSpan.FromMinutes(1.0);
             }
             return lease;
         }
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
index 6539bda..6e3a3ab 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
@@ -166,9 +166,9 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             if (lease.CurrentState == LeaseState.Initial)
             {
-                lease.InitialLeaseTime = TimeSpan.FromMinutes(1.0);
-                lease.RenewOnCallTime = TimeSpan.FromSeconds(10.0);
-                lease.SponsorshipTimeout = TimeSpan.FromMinutes(1.0);
+                lease.InitialLeaseTime = TimeSpan.FromMinutes(0);
+//                lease.RenewOnCallTime = TimeSpan.FromSeconds(10.0);
+//                lease.SponsorshipTimeout = TimeSpan.FromMinutes(1.0);
             }
             return lease;
         }
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/ScriptBase.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/ScriptBase.cs
index d119a77..838cafb 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/ScriptBase.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/ScriptBase.cs
@@ -42,16 +42,17 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
     public partial class ScriptBaseClass : MarshalByRefObject, IScript
     {
         private Dictionary<string, MethodInfo> inits = new Dictionary<string, MethodInfo>();
-        private ScriptSponsor m_sponser;
+//        private ScriptSponsor m_sponser;
 
         public override Object InitializeLifetimeService()
         {
             ILease lease = (ILease)base.InitializeLifetimeService();
             if (lease.CurrentState == LeaseState.Initial)
             {
-                lease.InitialLeaseTime = TimeSpan.FromMinutes(1.0);
-                lease.RenewOnCallTime = TimeSpan.FromSeconds(10.0);
-                lease.SponsorshipTimeout = TimeSpan.FromMinutes(1.0);
+                // Infinite
+                lease.InitialLeaseTime = TimeSpan.FromMinutes(0);
+//                lease.RenewOnCallTime = TimeSpan.FromSeconds(10.0);
+//                lease.SponsorshipTimeout = TimeSpan.FromMinutes(1.0);
             }
             return lease;
         }
@@ -79,7 +80,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
                 }
             }
 
-            m_sponser = new ScriptSponsor();
+//            m_sponser = new ScriptSponsor();
         }
 
         private Executor m_Executor = null;
@@ -112,7 +113,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
                 return;
 
             ILease lease = (ILease)RemotingServices.GetLifetimeService(data as MarshalByRefObject);
-            lease.Register(m_sponser);
+//            lease.Register(m_sponser);
 
             MethodInfo mi = inits[api];
 
@@ -126,7 +127,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
 
         public void Close()
         {
-            m_sponser.Close();
+//            m_sponser.Close();
         }
 
         public Dictionary<string, object> GetVars()
diff --git a/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs b/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
index 4211ced..225126d 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
@@ -53,7 +53,7 @@ using OpenSim.Region.ScriptEngine.Interfaces;
 
 namespace OpenSim.Region.ScriptEngine.Shared.Instance
 {
-    public class ScriptInstance : MarshalByRefObject, IScriptInstance, ISponsor
+    public class ScriptInstance : MarshalByRefObject, IScriptInstance
     {
         // private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
         
@@ -261,7 +261,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
                     "SecondLife.Script");
 
                 ILease lease = (ILease)RemotingServices.GetLifetimeService(m_Script as ScriptBaseClass);
-                lease.Register(this);
+//                lease.Register(this);
             }
             catch (Exception)
             {
@@ -1006,10 +1006,5 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
         {
             return true;
         }
-
-        public TimeSpan Renewal(ILease lease)
-        {
-            return lease.InitialLeaseTime;
-        }
     }
 }
diff --git a/OpenSim/Region/ScriptEngine/XEngine/Tests/XEngineTest.cs b/OpenSim/Region/ScriptEngine/XEngine/Tests/XEngineTest.cs
index aac52a4..045abb4 100644
--- a/OpenSim/Region/ScriptEngine/XEngine/Tests/XEngineTest.cs
+++ b/OpenSim/Region/ScriptEngine/XEngine/Tests/XEngineTest.cs
@@ -40,6 +40,8 @@ namespace OpenSim.Region.ScriptEngine.XEngine.Tests
     /// <summary>
     /// Scene presence tests
     /// </summary>
+    /// Commented out XEngineTests that don't do anything
+    /*
     [TestFixture]
     public class XEngineTest
     {
@@ -65,4 +67,5 @@ namespace OpenSim.Region.ScriptEngine.XEngine.Tests
             xengine.RegionLoaded(scene);
         }
     }
+    */
 }
diff --git a/OpenSim/Services/Interfaces/IAssetService.cs b/OpenSim/Services/Interfaces/IAssetService.cs
index ec8a71b..6dfe78d 100644
--- a/OpenSim/Services/Interfaces/IAssetService.cs
+++ b/OpenSim/Services/Interfaces/IAssetService.cs
@@ -34,25 +34,53 @@ namespace OpenSim.Services.Interfaces
 
     public interface IAssetService
     {
-        // Three different ways to retrieve an asset
-        //
+        /// <summary>
+        /// Get an asset synchronously.
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
         AssetBase Get(string id);
+
+        /// <summary>
+        /// Get an asset's metadata
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
         AssetMetadata GetMetadata(string id);
+        
         byte[] GetData(string id);
 
+        /// <summary>
+        /// Get an asset asynchronously
+        /// </summary>
+        /// <param name="id">The asset id</param>
+        /// <param name="sender">Represents the requester.  Passed back via the handler</param>
+        /// <param name="handler">The handler to call back once the asset has been retrieved</param>
+        /// <returns>True if the id was parseable, false otherwise</returns>
         bool Get(string id, Object sender, AssetRetrieved handler);
 
-        // Creates a new asset
-        // Returns a random ID if none is passed into it
-        //
+        /// <summary>
+        /// Creates a new asset
+        /// </summary>
+        /// Returns a random ID if none is passed into it
+        /// <param name="asset"></param>
+        /// <returns></returns>
         string Store(AssetBase asset);
 
-        // Attachments and bare scripts need this!!
-        //
+        /// <summary>
+        /// Update an asset's content
+        /// </summary>
+        /// Attachments and bare scripts need this!!
+        /// <param name="id"> </param>
+        /// <param name="data"></param>
+        /// <returns></returns>
         bool UpdateContent(string id, byte[] data);
 
-        // Kill an asset
-        //
+        /// <summary>
+        /// Delete an asset
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
         bool Delete(string id);
     }
 }
diff --git a/OpenSim/Tests/Common/Mock/TestAssetService.cs b/OpenSim/Tests/Common/Mock/TestAssetService.cs
index 5f1184b..81f123a 100644
--- a/OpenSim/Tests/Common/Mock/TestAssetService.cs
+++ b/OpenSim/Tests/Common/Mock/TestAssetService.cs
@@ -45,7 +45,13 @@ namespace OpenSim.Tests.Common.Mock
         
         public AssetBase Get(string id)
         {
-            return Assets[ id ];
+            AssetBase asset;
+            if (Assets.ContainsKey(id))
+                asset = Assets[id];
+            else
+                asset = null;            
+            
+            return asset;
         }
 
         public AssetMetadata GetMetadata(string id)
@@ -59,8 +65,10 @@ namespace OpenSim.Tests.Common.Mock
         }
 
         public bool Get(string id, object sender, AssetRetrieved handler)
-        {
-            throw new NotImplementedException();
+        {            
+            handler(id, sender, Get(id));
+            
+            return true;
         }
 
         public string Store(AssetBase asset)