1 files changed, 79 insertions, 22 deletions

diff --git a/OpenSim/Data/Tests/ScrambleForTesting.cs b/OpenSim/Data/Tests/PropertyScrambler.cs
index 3a22347..72aaff1 100644
--- a/OpenSim/Data/Tests/ScrambleForTesting.cs
+++ b/OpenSim/Data/Tests/PropertyScrambler.cs
@@ -27,18 +27,58 @@
 
 using System;
 using System.Collections;
+using System.Collections.Generic;
+using System.Linq.Expressions;
 using System.Reflection;
 using System.Text;
 using NUnit.Framework;
+using NUnit.Framework.SyntaxHelpers;
 using OpenMetaverse;
 using OpenSim.Framework;
 
 namespace OpenSim.Data.Tests
 {
-    public static class ScrambleForTesting
+
+    //This is generic so that the lambda expressions will work right in IDEs.
+    public class PropertyScrambler<T>
     {
-        private static readonly Random random = new Random();
-        public static void Scramble(object obj)
+        readonly System.Collections.Generic.List<string> membersToNotScramble = new List<string>();
+        
+        private void AddExpressionToNotScrableList(Expression expression)
+        {
+            UnaryExpression unaryExpression = expression as UnaryExpression;
+            if (unaryExpression != null)
+            {
+                AddExpressionToNotScrableList(unaryExpression.Operand);
+                return;
+            }
+
+            MemberExpression memberExpression = expression as MemberExpression;
+            if (memberExpression != null)
+            {
+                if (!(memberExpression.Member is PropertyInfo))
+                {
+                    throw new NotImplementedException("I don't know how deal with a MemberExpression that is a " + expression.Type);
+                }
+                membersToNotScramble.Add(memberExpression.Member.Name);
+                return;
+            }
+
+            throw new NotImplementedException("I don't know how to parse a " + expression.Type);
+        }
+
+        public PropertyScrambler<T> DontScramble(Expression<Func<T, object>> expression)
+        {
+            AddExpressionToNotScrableList(expression.Body);
+            return this;
+        }
+
+        public void Scramble(T obj)
+        {
+            internalScramble(obj);
+        }
+
+        private void internalScramble(object obj)
         {
             PropertyInfo[] properties = obj.GetType().GetProperties();
             foreach (var property in properties)
@@ -57,13 +97,16 @@ namespace OpenSim.Data.Tests
             {
                 foreach (object value in enumerable)
                 {
-                    Scramble(value);
+                    internalScramble(value);
                 }
             }
         }
 
-        private static void RandomizeProperty(object obj, PropertyInfo property, object[] index)
-        {
+        private readonly Random random = new Random();
+        private void RandomizeProperty(object obj, PropertyInfo property, object[] index)
+        {//I'd like a better way to compare, but I had lots of problems with InventoryFolderBase because the ID is inherited.
+            if (membersToNotScramble.Contains(property.Name))
+                return;
             Type t = property.PropertyType;
             if (!property.CanWrite)
                 return;
@@ -71,39 +114,39 @@ namespace OpenSim.Data.Tests
             if (value == null)
                 return;
 
-            if (t == typeof (string))
+            if (t == typeof(string))
                 property.SetValue(obj, RandomName(), index);
-            else if (t == typeof (UUID))
+            else if (t == typeof(UUID))
                 property.SetValue(obj, UUID.Random(), index);
-            else if (t == typeof (sbyte))
+            else if (t == typeof(sbyte))
                 property.SetValue(obj, (sbyte)random.Next(sbyte.MinValue, sbyte.MaxValue), index);
-            else if (t == typeof (short))
+            else if (t == typeof(short))
                 property.SetValue(obj, (short)random.Next(short.MinValue, short.MaxValue), index);
-            else if (t == typeof (int))
+            else if (t == typeof(int))
                 property.SetValue(obj, random.Next(), index);
-            else if (t == typeof (long))
+            else if (t == typeof(long))
                 property.SetValue(obj, random.Next() * int.MaxValue, index);
-            else if (t == typeof (byte))
+            else if (t == typeof(byte))
                 property.SetValue(obj, (byte)random.Next(byte.MinValue, byte.MaxValue), index);
-            else if (t == typeof (ushort))
+            else if (t == typeof(ushort))
                 property.SetValue(obj, (ushort)random.Next(ushort.MinValue, ushort.MaxValue), index);
-            else if (t == typeof (uint))
+            else if (t == typeof(uint))
                 property.SetValue(obj, Convert.ToUInt32(random.Next()), index);
-            else if (t == typeof (ulong))
+            else if (t == typeof(ulong))
                 property.SetValue(obj, Convert.ToUInt64(random.Next()) * Convert.ToUInt64(UInt32.MaxValue), index);
-            else if (t == typeof (bool))
+            else if (t == typeof(bool))
                 property.SetValue(obj, true, index);
-            else if (t == typeof (byte[]))
+            else if (t == typeof(byte[]))
             {
                 byte[] bytes = new byte[30];
                 random.NextBytes(bytes);
                 property.SetValue(obj, bytes, index);
             }
             else
-                Scramble(value);
+                internalScramble(value);
         }
 
-        private static string RandomName()
+        private string RandomName()
         {
             StringBuilder name = new StringBuilder();
             int size = random.Next(5, 12);
@@ -117,13 +160,27 @@ namespace OpenSim.Data.Tests
     }
 
     [TestFixture]
-    public class ScrableForTestingTest
+    public class PropertyScramblerTests
     {
         [Test]
         public void TestScramble()
         {
             AssetBase actual = new AssetBase(UUID.Random(), "asset one");
-            ScrambleForTesting.Scramble(actual);
+            new PropertyScrambler<AssetBase>().Scramble(actual);
+        }
+
+        [Test]
+        public void DontScramble()
+        {
+            UUID uuid = UUID.Random();
+            AssetBase asset = new AssetBase();
+            asset.FullID = uuid;
+            new PropertyScrambler<AssetBase>()
+                .DontScramble(x => x.Metadata)
+                .DontScramble(x => x.FullID)
+                .DontScramble(x => x.ID)
+                .Scramble(asset);
+            Assert.That(asset.FullID, Is.EqualTo(uuid));
         }
     }
 }
\ No newline at end of file