Improved the robustness of the cyclic detection algorithm. Closes #78

dennisdoomen · dennisdoomen · commit 02e71b30159e · 2014-03-11T21:18:45.000+01:00
diff --git a/FluentAssertions.Core/Equivalency/ObjectReference.cs b/FluentAssertions.Core/Equivalency/ObjectReference.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 
 using FluentAssertions.Common;
 
@@ -10,12 +11,12 @@ namespace FluentAssertions.Equivalency
     internal class ObjectReference
     {
         private readonly object @object;
-        private readonly string propertyPath;
+        private readonly string[] path;
 
-        public ObjectReference(object @object, string propertyPath)
+        public ObjectReference(object @object, string path)
         {
             this.@object = @object;
-            this.propertyPath = propertyPath;
+            this.path = path.ToLower().Split('.');
         }
 
         /// <summary>
@@ -29,12 +30,13 @@ public override bool Equals(object obj)
         {
             var other = (ObjectReference)obj;
 
-            int firstDot = other.propertyPath.IndexOf(".");
-            string firstPartOfOtherPropertyPath = (firstDot >= 0) ? other.propertyPath.Substring(0, firstDot) : "";
+            return ReferenceEquals(@object, other.@object) && IsParentOf(other);
 
-            return ReferenceEquals(@object, other.@object) &&
-                   (propertyPath.Length > 0) && 
-                   firstPartOfOtherPropertyPath.Equals(propertyPath, StringComparison.CurrentCultureIgnoreCase);
+        }
+
+        private bool IsParentOf(ObjectReference other)
+        {
+            return (other.path.Length > path.Length) && other.path.Take(path.Length).SequenceEqual(path);
         }
 
         /// <summary>
@@ -48,10 +50,15 @@ public override int GetHashCode()
         {
             unchecked
             {
-                return (@object.GetHashCode() * 397) ^ propertyPath.GetHashCode();
+                return (@object.GetHashCode() * 397) ^ path.GetHashCode();
             }
         }
 
+        public override string ToString()
+        {
+            return string.Format("{{\"{0}\", {1}}}", path, @object);
+        }
+
         public bool IsReference
         {
             get { return !ReferenceEquals(@object, null) && @object.GetType().IsComplexType(); }
diff --git a/FluentAssertions.Net40.Specs/EquivalencySpecs.cs b/FluentAssertions.Net40.Specs/EquivalencySpecs.cs
@@ -2550,6 +2550,55 @@ public LogbookCode(string key)
             public string Key { get; protected set; }
         }
 
+        private class MyCompany
+        {
+            public string Name { get; set; }
+            public MyCompanyLogo Logo { get; set; }
+            public List<MyUser> Users { get; set; }
+        }
+
+        private class MyUser
+        {
+            public string Name { get; set; }
+            public MyCompany Company { get; set; }
+        }
+
+        private class MyCompanyLogo
+        {
+            public string Url { get; set; }
+            public MyCompany Company { get; set; }
+            public MyUser CreatedBy { get; set; }
+        }
+
+        [TestMethod]
+        public void When_the_root_object_is_referenced_from_a_nested_object_it_should_treat_it_as_a_cyclic_reference()
+        {
+            //-----------------------------------------------------------------------------------------------------------
+            // Arrange
+            //-----------------------------------------------------------------------------------------------------------
+            var company1 = new MyCompany { Name = "Company" };
+            var user1 = new MyUser { Name = "User", Company = company1 };
+            company1.Users = new List<MyUser> { user1 };
+            var logo1 = new MyCompanyLogo { Url = "blank", Company = company1, CreatedBy = user1 };
+            company1.Logo = logo1;
+
+            var company2 = new MyCompany { Name = "Company" };
+            var user2 = new MyUser { Name = "User", Company = company2 };
+            company2.Users = new List<MyUser> { user2 };
+            var logo2 = new MyCompanyLogo { Url = "blank", Company = company2, CreatedBy = user2 };
+            company2.Logo = logo2;
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Act
+            //-----------------------------------------------------------------------------------------------------------
+            Action action = () => company1.ShouldBeEquivalentTo(company2, o => o.IgnoringCyclicReferences());
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Assert
+            //-----------------------------------------------------------------------------------------------------------
+            action.ShouldNotThrow();
+        }
+
         #endregion
 
         #region Nested Enumerables

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using System;`
	`2`	`+using System.Linq;`
`2`	`3`
`3`	`4`	`using FluentAssertions.Common;`
`4`	`5`
`@@ -10,12 +11,12 @@ namespace FluentAssertions.Equivalency`
`10`	`11`	`internal class ObjectReference`
`11`	`12`	`{`
`12`	`13`	`private readonly object @object;`
`13`		`- private readonly string propertyPath;`
	`14`	`+ private readonly string[] path;`
`14`	`15`
`15`		`- public ObjectReference(object @object, string propertyPath)`
	`16`	`+ public ObjectReference(object @object, string path)`
`16`	`17`	`{`
`17`	`18`	`this.@object = @object;`
`18`		`- this.propertyPath = propertyPath;`
	`19`	`+ this.path = path.ToLower().Split('.');`
`19`	`20`	`}`
`20`	`21`
`21`	`22`	`/// <summary>`
`@@ -29,12 +30,13 @@ public override bool Equals(object obj)`
`29`	`30`	`{`
`30`	`31`	`var other = (ObjectReference)obj;`
`31`	`32`
`32`		`- int firstDot = other.propertyPath.IndexOf(".");`
`33`		`- string firstPartOfOtherPropertyPath = (firstDot >= 0) ? other.propertyPath.Substring(0, firstDot) : "";`
	`33`	`+ return ReferenceEquals(@object, other.@object) && IsParentOf(other);`
`34`	`34`
`35`		`- return ReferenceEquals(@object, other.@object) &&`
`36`		`- (propertyPath.Length > 0) &&`
`37`		`- firstPartOfOtherPropertyPath.Equals(propertyPath, StringComparison.CurrentCultureIgnoreCase);`
	`35`	`+ }`
	`36`	`+`
	`37`	`+ private bool IsParentOf(ObjectReference other)`
	`38`	`+ {`
	`39`	`+ return (other.path.Length > path.Length) && other.path.Take(path.Length).SequenceEqual(path);`
`38`	`40`	`}`
`39`	`41`
`40`	`42`	`/// <summary>`
`@@ -48,10 +50,15 @@ public override int GetHashCode()`
`48`	`50`	`{`
`49`	`51`	`unchecked`
`50`	`52`	`{`
`51`		`- return (@object.GetHashCode() * 397) ^ propertyPath.GetHashCode();`
	`53`	`+ return (@object.GetHashCode() * 397) ^ path.GetHashCode();`
`52`	`54`	`}`
`53`	`55`	`}`
`54`	`56`
	`57`	`+ public override string ToString()`
	`58`	`+ {`
	`59`	`+ return string.Format("{{\"{0}\", {1}}}", path, @object);`
	`60`	`+ }`
	`61`	`+`
`55`	`62`	`public bool IsReference`
`56`	`63`	`{`
`57`	`64`	`get { return !ReferenceEquals(@object, null) && @object.GetType().IsComplexType(); }`