3 files changed, 92 insertions, 27 deletions

diff --git a/OpenSim/Data/Tests/BasicAssetTest.cs b/OpenSim/Data/Tests/BasicAssetTest.cs
index eddb999..91b613a 100644
--- a/OpenSim/Data/Tests/BasicAssetTest.cs
+++ b/OpenSim/Data/Tests/BasicAssetTest.cs
@@ -84,7 +84,7 @@ namespace OpenSim.Data.Tests
             a1.Data = asset1;
             a2.Data = asset1;
             a3.Data = asset1;
-
+            
             a1.FullID = uuid1;
             a2.FullID = uuid2;
             a3.FullID = uuid3;
@@ -92,15 +92,40 @@ namespace OpenSim.Data.Tests
             db.CreateAsset(a1);
             db.CreateAsset(a2);
             db.CreateAsset(a3);
-
+            
             AssetBase a1a = db.FetchAsset(uuid1);
-            Assert.That(a1, Constraints.PropertyCompareConstraint(a1a));
+            Assert.That(a1a, Constraints.PropertyCompareConstraint(a1));
 
             AssetBase a2a = db.FetchAsset(uuid2);
-            Assert.That(a2, Constraints.PropertyCompareConstraint(a2a));
+            Assert.That(a2a, Constraints.PropertyCompareConstraint(a2));
 
             AssetBase a3a = db.FetchAsset(uuid3);
-            Assert.That(a3, Constraints.PropertyCompareConstraint(a3a));
+            Assert.That(a3a, Constraints.PropertyCompareConstraint(a3));
+
+            ScrambleForTesting.Scramble(a1a);
+            ScrambleForTesting.Scramble(a2a);
+            ScrambleForTesting.Scramble(a3a);
+
+            a1a.Data = asset1;
+            a2a.Data = asset1;
+            a3a.Data = asset1;
+
+            a1a.FullID = uuid1;
+            a2a.FullID = uuid2;
+            a3a.FullID = uuid3;
+
+            db.UpdateAsset(a1a);
+            db.UpdateAsset(a2a);
+            db.UpdateAsset(a3a);
+
+            AssetBase a1b = db.FetchAsset(uuid1);
+            Assert.That(a1b, Constraints.PropertyCompareConstraint(a1a));
+
+            AssetBase a2b = db.FetchAsset(uuid2);
+            Assert.That(a2b, Constraints.PropertyCompareConstraint(a2a));
+
+            AssetBase a3b = db.FetchAsset(uuid3);
+            Assert.That(a3b, Constraints.PropertyCompareConstraint(a3a));
         }
 
         [Test]
diff --git a/OpenSim/Data/Tests/BasicInventoryTest.cs b/OpenSim/Data/Tests/BasicInventoryTest.cs
index 967c6e7..21552c8 100644
--- a/OpenSim/Data/Tests/BasicInventoryTest.cs
+++ b/OpenSim/Data/Tests/BasicInventoryTest.cs
@@ -258,17 +258,59 @@ namespace OpenSim.Data.Tests
         [Test]
         public void T104_RandomUpdateItem()
         {
-            InventoryItemBase expected = db.getInventoryItem(item1);
+            UUID owner = UUID.Random();
+            UUID folder = UUID.Random();
+            UUID rootId = UUID.Random();
+            UUID rootAsset = UUID.Random();
+            InventoryFolderBase f1 = NewFolder(folder, zero, owner, name1);
+            ScrambleForTesting.Scramble(f1);
+            f1.Owner = owner;
+            f1.ParentID = zero;
+            f1.ID = folder;
+
+            // succeed with true
+            db.addInventoryFolder(f1);
+            InventoryFolderBase f1a = db.getUserRootFolder(owner);
+            Assert.That(f1a, Constraints.PropertyCompareConstraint(f1));
+
+            ScrambleForTesting.Scramble(f1a);
+            f1a.Owner = owner;
+            f1a.ParentID = zero;
+            f1a.ID = folder;
+            db.updateInventoryFolder(f1a);
+
+            InventoryFolderBase f1b = db.getUserRootFolder(owner);
+            Assert.That(f1b, Constraints.PropertyCompareConstraint(f1a));
+
+            //Now we have a valid folder to insert into, we can insert the item.
+            InventoryItemBase root = NewItem(rootId, folder, owner, iname1, rootAsset);
+            ScrambleForTesting.Scramble(root);
+            root.ID = rootId;
+            root.AssetID = rootAsset;
+            root.Owner = owner;
+            root.Folder = folder;
+            db.addInventoryItem(root);
+
+            InventoryItemBase expected = db.getInventoryItem(rootId);
+            Assert.That(expected, Constraints.PropertyCompareConstraint(root)
+                                    .IgnoreProperty(x => x.InvType)
+                                    .IgnoreProperty(x => x.CreatorIdAsUuid)
+                                    .IgnoreProperty(x => x.Description)
+                                    .IgnoreProperty(x => x.CreatorId));
+
             ScrambleForTesting.Scramble(expected);
-            expected.ID = item1;
+            expected.ID = rootId;
+            expected.AssetID = rootAsset;
+            expected.Owner = owner;
+            expected.Folder = folder;
             db.updateInventoryItem(expected);
 
-            InventoryItemBase actual = db.getInventoryItem(item1);
+            InventoryItemBase actual = db.getInventoryItem(rootId);
             Assert.That(actual, Constraints.PropertyCompareConstraint(expected)
-                .IgnoreProperty(x=>x.InvType)
-                .IgnoreProperty(x=>x.CreatorIdAsUuid)
-                .IgnoreProperty(x=>x.Description)
-                .IgnoreProperty(x=>x.CreatorId));
+                                    .IgnoreProperty(x => x.InvType)
+                                    .IgnoreProperty(x => x.CreatorIdAsUuid)
+                                    .IgnoreProperty(x => x.Description)
+                                    .IgnoreProperty(x => x.CreatorId));
         }
 
         [Test]
diff --git a/OpenSim/Data/Tests/PropertyCompareConstraint.cs b/OpenSim/Data/Tests/PropertyCompareConstraint.cs
index 5f53725..d64a51e 100644
--- a/OpenSim/Data/Tests/PropertyCompareConstraint.cs
+++ b/OpenSim/Data/Tests/PropertyCompareConstraint.cs
@@ -69,6 +69,19 @@ namespace OpenSim.Data.Tests
 
         private bool ObjectCompare(object expected, object actual, Stack<string> propertyNames)
         {
+            //If they are both null, they are equal
+            if (actual == null && expected == null)
+                return true;
+
+            //If only one is null, then they aren't
+            if (actual == null || expected == null)
+            {
+                failingPropertyName = string.Join(".", propertyNames.Reverse().ToArray());
+                failingActual = actual;
+                failingExpected = expected;
+                return false;
+            }
+
             //prevent loops...
             if(propertyNames.Count > 50)
             {
@@ -195,21 +208,6 @@ namespace OpenSim.Data.Tests
                 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;
-                }
-
                 propertyNames.Push(property.Name);
                 if (!ObjectCompare(expectedValue, actualValue, propertyNames))
                     return false;