fluentassertions · dennisdoomen · Mar 26, 2023 · Mar 11, 2023 · Mar 11, 2023 · jnyrup
diff --git a/FluentAssertions.sln.DotSettings b/FluentAssertions.sln.DotSettings
@@ -182,4 +182,5 @@ public void When_$scenario$_it_should_$behavior$()&#xD;
 	<s:String x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=012E3B0572DEF2448B0B5D9AA88E6210/Scope/=C3001E7C0DA78E4487072B7E050D86C5/Type/@EntryValue">InCSharpFile</s:String>
 	<s:String x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=012E3B0572DEF2448B0B5D9AA88E6210/Scope/=C3001E7C0DA78E4487072B7E050D86C5/CustomProperties/=minimumLanguageVersion/@EntryIndexedValue">2.0</s:String>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Comparands/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/UserDictionary/Words/=enumerables/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=enumerables/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=inequivalency/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
diff --git a/Src/FluentAssertions/Equivalency/EquivalencyValidator.cs b/Src/FluentAssertions/Equivalency/EquivalencyValidator.cs
@@ -45,11 +45,11 @@ public void RecursivelyAssertEquality(Comparands comparands, IEquivalencyValidat
     private static bool ShouldCompareNodesThisDeep(INode currentNode, IEquivalencyAssertionOptions options,
         AssertionScope assertionScope)
     {
-        bool shouldRecurse = options.AllowInfiniteRecursion || currentNode.Depth < MaxDepth;
+        bool shouldRecurse = options.AllowInfiniteRecursion || currentNode.Depth <= MaxDepth;
 
         if (!shouldRecurse)
         {
-            assertionScope.FailWith("The maximum recursion depth was reached.  ");
+            assertionScope.FailWith($"The maximum recursion depth of {MaxDepth} was reached.  ");
         }
 
         return shouldRecurse;

diff --git a/Src/FluentAssertions/Equivalency/INode.cs b/Src/FluentAssertions/Equivalency/INode.cs
@@ -56,6 +56,10 @@ public interface INode
     /// <summary>
     /// Gets a zero-based number representing the depth within the object graph
     /// </summary>
+    /// <remarks>
+    /// The root object has a depth of <c>0</c>, the next nested object a depth of <c>1</c>, etc.
+    /// See also <a href="https://www.geeksforgeeks.org/height-and-depth-of-a-node-in-a-binary-tree/">this article</a>
+    /// </remarks>
     int Depth { get; }
 
     /// <summary>

diff --git a/Tests/FluentAssertions.Equivalency.Specs/BasicSpecs.cs b/Tests/FluentAssertions.Equivalency.Specs/BasicSpecs.cs
@@ -9,6 +9,36 @@ namespace FluentAssertions.Equivalency.Specs;
 
 public class BasicSpecs
 {
+    [Fact]
+    public void A_null_configuration_is_invalid()
+    {
+        // Arrange
+        var actual = new { };
+        var expectation = new { };
+
+        // Act
+        Action act = () => actual.Should().BeEquivalentTo(expectation, config: null);
+
+        // Assert
+        act.Should().ThrowExactly<ArgumentNullException>()
+            .WithParameterName("config");
+    }
+
+    [Fact]
+    public void A_null_as_the_configuration_is_not_valid_for_inequivalency_assertions()
+    {
+        // Arrange
+        var actual = new { };
+        var expectation = new { };
+
+        // Act
+        Action act = () => actual.Should().NotBeEquivalentTo(expectation, config: null);
+
+        // Assert
+        act.Should().ThrowExactly<ArgumentNullException>()
+            .WithParameterName("config");
+    }
+
     [Fact]
     public void When_expectation_is_null_it_should_throw()
     {

diff --git a/Tests/FluentAssertions.Equivalency.Specs/CyclicReferencesSpecs.cs b/Tests/FluentAssertions.Equivalency.Specs/CyclicReferencesSpecs.cs
@@ -9,42 +9,32 @@ namespace FluentAssertions.Equivalency.Specs;
 public class CyclicReferencesSpecs
 {
     [Fact]
-    public void When_validating_nested_properties_that_have_cyclic_references_it_should_throw()
+    public void Graphs_up_to_the_maximum_depth_are_supported()
     {
         // Arrange
-        var cyclicRoot = new CyclicRoot
-        {
-            Text = "Root"
-        };
-
-        cyclicRoot.Level = new CyclicLevel1
-        {
-            Text = "Level1",
-            Root = cyclicRoot
-        };
+        var actual = new ClassWithFiniteRecursiveProperty(recursiveDepth: 10);
+        var expectation = new ClassWithFiniteRecursiveProperty(recursiveDepth: 10);
 
-        var cyclicRootDto = new CyclicRootDto
-        {
-            Text = "Root"
-        };
+        // Act/Assert
+        actual.Should().BeEquivalentTo(expectation);
+    }
 
-        cyclicRootDto.Level = new CyclicLevel1Dto
-        {
-            Text = "Level1",
-            Root = cyclicRootDto
-        };
+    [Fact]
+    public void Graphs_deeper_than_the_maximum_depth_are_not_supported()
+    {
+        // Arrange
+        var actual = new ClassWithFiniteRecursiveProperty(recursiveDepth: 11);
+        var expectation = new ClassWithFiniteRecursiveProperty(recursiveDepth: 11);
 
         // Act
-        Action act = () => cyclicRoot.Should().BeEquivalentTo(cyclicRootDto);
+        Action act = () => actual.Should().BeEquivalentTo(expectation);
 
         // Assert
-        act
-            .Should().Throw<XunitException>()
-            .WithMessage("Expected property cyclicRoot.Level.Root to be*but it contains a cyclic reference*");
+        act.Should().Throw<XunitException>().WithMessage("*maximum*depth*10*");
     }
 
     [Fact]
-    public void When_validating_nested_properties_and_ignoring_cyclic_references_it_should_succeed()
+    public void By_default_cyclic_references_are_not_valid()
     {
         // Arrange
         var cyclicRoot = new CyclicRoot
@@ -70,15 +60,16 @@ public void When_validating_nested_properties_and_ignoring_cyclic_references_it_
         };
 
         // Act
-        Action act = () =>
-            cyclicRoot.Should().BeEquivalentTo(cyclicRootDto, options => options.IgnoringCyclicReferences());
+        Action act = () => cyclicRoot.Should().BeEquivalentTo(cyclicRootDto);
 
         // Assert
-        act.Should().NotThrow();
+        act
+            .Should().Throw<XunitException>()
+            .WithMessage("Expected property cyclicRoot.Level.Root to be*but it contains a cyclic reference*");
     }
 
     [Fact]
-    public void When_two_cyclic_graphs_are_equivalent_when_ignoring_cycle_references_it_should_succeed()
+    public void Two_graphs_with_ignored_cyclic_references_can_be_compared()
     {
         // Arrange
         var actual = new Parent();
@@ -98,28 +89,28 @@ public void When_two_cyclic_graphs_are_equivalent_when_ignoring_cycle_references
         act.Should().NotThrow();
     }
 
-    public class Parent
+    private class Parent
     {
         public Child Child1 { get; set; }
 
         public Child Child2 { get; set; }
     }
 
-    public class Child
+    private class Child
     {
         public Child(Parent parent, int stuff = 0)
         {
             Parent = parent;
             Stuff = stuff;
         }
 
-        public Parent Parent { get; set; }
+        public Parent Parent { get; }
 
-        public int Stuff { get; set; }
+        public int Stuff { get; }
     }
 
     [Fact]
-    public void When_validating_nested_properties_that_are_null_it_should_not_throw_on_cyclic_references()
+    public void Nested_properties_that_are_null_are_not_treated_as_cyclic_references()
     {
         // Arrange
         var actual = new CyclicRoot
@@ -142,15 +133,12 @@ public void When_validating_nested_properties_that_are_null_it_should_not_throw_
             }
         };
 
-        // Act
-        Action act = () => actual.Should().BeEquivalentTo(expectation);
-
-        // Assert
-        act.Should().NotThrow();
+        // Act / Assert
+        actual.Should().BeEquivalentTo(expectation);
     }
 
     [Fact]
-    public void When_the_graph_contains_the_same_value_object_it_should_not_be_treated_as_a_cyclic_reference()
+    public void Equivalent_value_objects_are_not_treated_as_cyclic_references()
     {
         // Arrange
         var actual = new CyclicRootWithValueObject
@@ -173,15 +161,12 @@ public void When_the_graph_contains_the_same_value_object_it_should_not_be_treat
             }
         };
 
-        // Act
-        Action act = () => actual.Should().BeEquivalentTo(expectation);
-
-        // Assert
-        act.Should().NotThrow();
+        // Act  / Assert
+        actual.Should().BeEquivalentTo(expectation);
     }
 
     [Fact]
-    public void When_asserting_types_with_infinite_object_graphs_are_equivalent_it_should_not_overflow_the_stack()
+    public void Cyclic_references_do_not_trigger_stack_overflows()
     {
         // Arrange
         var recursiveClass1 = new ClassWithInfinitelyRecursiveProperty();
@@ -196,24 +181,18 @@ public void When_asserting_types_with_infinite_object_graphs_are_equivalent_it_s
     }
 
     [Fact]
-    public void
-        When_asserting_equivalence_on_objects_needing_high_recursion_depth_and_disabling_recursion_depth_limit_it_should_recurse_to_completion()
+    public void Cyclic_references_can_be_ignored_in_equivalency_assertions()
     {
         // Arrange
         var recursiveClass1 = new ClassWithFiniteRecursiveProperty(15);
         var recursiveClass2 = new ClassWithFiniteRecursiveProperty(15);
 
-        // Act
-        Action act =
-            () => recursiveClass1.Should().BeEquivalentTo(recursiveClass2,
-                options => options.AllowingInfiniteRecursion());
-
-        // Assert
-        act.Should().NotThrow();
+        // Act / Assert
+        recursiveClass1.Should().BeEquivalentTo(recursiveClass2, options => options.AllowingInfiniteRecursion());
     }
 
     [Fact]
-    public void Allowing_infinite_recursion_is_described_in_the_failure_message()
+    public void Allowing_infinite_recursion_is_reported_in_the_failure_message()
     {
         // Arrange
         var recursiveClass1 = new ClassWithFiniteRecursiveProperty(1);
@@ -229,54 +208,19 @@ public void Allowing_infinite_recursion_is_described_in_the_failure_message()
     }
 
     [Fact]
-    public void When_injecting_a_null_config_to_BeEquivalentTo_it_should_throw()
-    {
-        // Arrange
-        var recursiveClass1 = new ClassWithFiniteRecursiveProperty(15);
-        var recursiveClass2 = new ClassWithFiniteRecursiveProperty(15);
-
-        // Act
-        Action act = () => recursiveClass1.Should().BeEquivalentTo(recursiveClass2, config: null);
-
-        // Assert
-        act.Should().ThrowExactly<ArgumentNullException>()
-            .WithParameterName("config");
-    }
-
-    [Fact]
-    public void
-        When_asserting_inequivalence_on_objects_needing_high_recursion_depth_and_disabling_recursion_depth_limit_it_should_recurse_to_completion()
+    public void Can_ignore_cyclic_references_for_inequivalency_assertions()
     {
         // Arrange
         var recursiveClass1 = new ClassWithFiniteRecursiveProperty(15);
         var recursiveClass2 = new ClassWithFiniteRecursiveProperty(16);
 
-        // Act
-        Action act =
-            () => recursiveClass1.Should().NotBeEquivalentTo(recursiveClass2,
+        // Act / Assert
+        recursiveClass1.Should().NotBeEquivalentTo(recursiveClass2,
                 options => options.AllowingInfiniteRecursion());
-
-        // Assert
-        act.Should().NotThrow();
     }
 
     [Fact]
-    public void When_injecting_a_null_config_to_NotBeEquivalentTo_it_should_throw()
-    {
-        // Arrange
-        var recursiveClass1 = new ClassWithFiniteRecursiveProperty(15);
-        var recursiveClass2 = new ClassWithFiniteRecursiveProperty(16);
-
-        // Act
-        Action act = () => recursiveClass1.Should().NotBeEquivalentTo(recursiveClass2, config: null);
-
-        // Assert
-        act.Should().ThrowExactly<ArgumentNullException>()
-            .WithParameterName("config");
-    }
-
-    [Fact]
-    public void When_an_enumerable_collection_returns_itself_it_should_detect_the_cyclic_reference()
+    public void Can_detect_cyclic_references_in_enumerables()
     {
         // Act
         var instance1 = new SelfReturningEnumerable();
@@ -310,30 +254,8 @@ IEnumerator IEnumerable.GetEnumerator()
         }
     }
 
-    internal class LogbookEntryProjection
-    {
-        public virtual LogbookCode Logbook { get; set; }
-
-        public virtual ICollection<LogbookRelation> LogbookRelations { get; set; }
-    }
-
-    internal class LogbookRelation
-    {
-        public virtual LogbookCode Logbook { get; set; }
-    }
-
-    internal class LogbookCode
-    {
-        public LogbookCode(string key)
-        {
-            Key = key;
-        }
-
-        public string Key { get; protected set; }
-    }
-
     [Fact]
-    public void When_the_root_object_is_referenced_from_a_nested_object_it_should_treat_it_as_a_cyclic_reference()
+    public void Can_detect_cyclic_references_in_nested_objects_referring_to_the_root()
     {
         // Arrange
         var company1 = new MyCompany
@@ -376,11 +298,8 @@ public void When_the_root_object_is_referenced_from_a_nested_object_it_should_tr
 
         company2.Logo = logo2;
 
-        // Act
-        Action action = () => company1.Should().BeEquivalentTo(company2, o => o.IgnoringCyclicReferences());
-
-        // Assert
-        action.Should().NotThrow();
+        // Act / Assert
+        company1.Should().BeEquivalentTo(company2, o => o.IgnoringCyclicReferences());
     }
 
     [Fact]
@@ -425,7 +344,7 @@ public void Allow_ignoring_cyclic_references_in_value_types_compared_by_members(
             .Which.Message.Should().NotContain("maximum recursion depth was reached");
     }
 
-    public class ValueTypeCircularDependency
+    private class ValueTypeCircularDependency
     {
         public string Title { get; set; }
 
@@ -448,4 +367,32 @@ public override int GetHashCode()
             return Title.GetHashCode();
         }
     }
+
+    private class ClassWithInfinitelyRecursiveProperty
+    {
+        public ClassWithInfinitelyRecursiveProperty Self
+        {
+            get { return new ClassWithInfinitelyRecursiveProperty(); }
+        }
+    }
+
+    private class ClassWithFiniteRecursiveProperty
+    {
+        private readonly int depth;
+
+        public ClassWithFiniteRecursiveProperty(int recursiveDepth)
+        {
+            depth = recursiveDepth;
+        }
+
+        public ClassWithFiniteRecursiveProperty Self
+        {
+            get
+            {
+                return depth > 0
+                    ? new ClassWithFiniteRecursiveProperty(depth - 1)
+                    : null;
+            }
+        }
+    }
 }