Make JTokenDifferentiator an instance class

jnyrup · jnyrup · commit e9e43102eb40 · 2022-02-26T19:06:23.000+01:00
diff --git a/Src/FluentAssertions.Json/JTokenAssertions.cs b/Src/FluentAssertions.Json/JTokenAssertions.cs
@@ -114,7 +114,8 @@ private AndConstraint<JTokenAssertions> BeEquivalentTo(JToken expected, bool ign
             string because = "",
             params object[] becauseArgs)
         {
-            Difference difference = JTokenDifferentiator.FindFirstDifference(Subject, expected, ignoreExtraProperties, config);
+            var differentiator = new JTokenDifferentiator(ignoreExtraProperties, config);
+            Difference difference = differentiator.FindFirstDifference(Subject, expected);
 
             var expectation = ignoreExtraProperties ? "was expected to contain" : "was expected to be equivalent to";
 
diff --git a/Src/FluentAssertions.Json/JTokenDifferentiator.cs b/Src/FluentAssertions.Json/JTokenDifferentiator.cs
@@ -6,10 +6,20 @@
 
 namespace FluentAssertions.Json
 {
-    // REFACTOR: Change to non-static and make parameters fields
-    internal static class JTokenDifferentiator
+    internal class JTokenDifferentiator
     {
-        public static Difference FindFirstDifference(JToken actual, JToken expected, bool ignoreExtraProperties, Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)
+        private readonly bool ignoreExtraProperties;
+
+        private readonly Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config;
+
+        public JTokenDifferentiator(bool ignoreExtraProperties,
+            Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)
+        {
+            this.ignoreExtraProperties = ignoreExtraProperties;
+            this.config = config;
+        }
+
+        public Difference FindFirstDifference(JToken actual, JToken expected)
         {
             var path = new JPath();
 
@@ -28,24 +38,22 @@ public static Difference FindFirstDifference(JToken actual, JToken expected, boo
                 return new Difference(DifferenceKind.ExpectedIsNull, path);
             }
 
-            return FindFirstDifference(actual, expected, path, ignoreExtraProperties, config);
+            return FindFirstDifference(actual, expected, path);
         }
 
-        private static Difference FindFirstDifference(JToken actual, JToken expected, JPath path, bool ignoreExtraProperties, Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)
+        private Difference FindFirstDifference(JToken actual, JToken expected, JPath path)
         {
             return actual switch
             {
-                JArray actualArray => FindJArrayDifference(actualArray, expected, path, ignoreExtraProperties, config),
-                JObject actualObject => FindJObjectDifference(actualObject, expected, path, ignoreExtraProperties, config),
-                JProperty actualProperty => FindJPropertyDifference(actualProperty, expected, path, ignoreExtraProperties, config),
-                JValue actualValue => FindValueDifference(actualValue, expected, path, config),
+                JArray actualArray => FindJArrayDifference(actualArray, expected, path),
+                JObject actualObject => FindJObjectDifference(actualObject, expected, path),
+                JProperty actualProperty => FindJPropertyDifference(actualProperty, expected, path),
+                JValue actualValue => FindValueDifference(actualValue, expected, path),
                 _ => throw new NotSupportedException(),
             };
         }
 
-        private static Difference FindJArrayDifference(JArray actualArray, JToken expected, JPath path,
-            bool ignoreExtraProperties,
-            Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)
+        private Difference FindJArrayDifference(JArray actualArray, JToken expected, JPath path)
         {
             if (expected is not JArray expectedArray)
             {
@@ -54,15 +62,15 @@ private static Difference FindJArrayDifference(JArray actualArray, JToken expect
 
             if (ignoreExtraProperties)
             {
-                return CompareExpectedItems(actualArray, expectedArray, path, config);
+                return CompareExpectedItems(actualArray, expectedArray, path);
             }
             else
             {
-                return CompareItems(actualArray, expectedArray, path, config);
+                return CompareItems(actualArray, expectedArray, path);
             }
         }
 
-        private static Difference CompareExpectedItems(JArray actual, JArray expected, JPath path, Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)
+        private Difference CompareExpectedItems(JArray actual, JArray expected, JPath path)
         {
             JToken[] actualChildren = actual.Children().ToArray();
             JToken[] expectedChildren = expected.Children().ToArray();
@@ -74,7 +82,7 @@ private static Difference CompareExpectedItems(JArray actual, JArray expected, J
                 bool match = false;
                 for (int actualIndex = matchingIndex; actualIndex < actualChildren.Length; actualIndex++)
                 {
-                    var difference = FindFirstDifference(actualChildren[actualIndex], expectedChild, true, config);
+                    var difference = FindFirstDifference(actualChildren[actualIndex], expectedChild);
 
                     if (difference == null)
                     {
@@ -88,7 +96,7 @@ private static Difference CompareExpectedItems(JArray actual, JArray expected, J
                 {
                     if (matchingIndex >= actualChildren.Length)
                     {
-                        if (actualChildren.Any(actualChild => FindFirstDifference(actualChild, expectedChild, true, config) == null))
+                        if (actualChildren.Any(actualChild => FindFirstDifference(actualChild, expectedChild) == null))
                         {
                             return new Difference(DifferenceKind.WrongOrder, path.AddIndex(expectedIndex));
                         }
@@ -97,15 +105,14 @@ private static Difference CompareExpectedItems(JArray actual, JArray expected, J
                     }
 
                     return FindFirstDifference(actualChildren[matchingIndex], expectedChild,
-                        path.AddIndex(expectedIndex), true, config);
+                        path.AddIndex(expectedIndex));
                 }
             }
 
             return null;
         }
 
-        private static Difference CompareItems(JArray actual, JArray expected, JPath path,
-            Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)
+        private Difference CompareItems(JArray actual, JArray expected, JPath path)
         {
             JToken[] actualChildren = actual.Children().ToArray();
             JToken[] expectedChildren = expected.Children().ToArray();
@@ -117,8 +124,7 @@ private static Difference CompareItems(JArray actual, JArray expected, JPath pat
 
             for (int i = 0; i < actualChildren.Length; i++)
             {
-                Difference firstDifference = FindFirstDifference(actualChildren[i], expectedChildren[i],
-                    path.AddIndex(i), false, config);
+                Difference firstDifference = FindFirstDifference(actualChildren[i], expectedChildren[i], path.AddIndex(i));
 
                 if (firstDifference != null)
                 {
@@ -129,20 +135,17 @@ private static Difference CompareItems(JArray actual, JArray expected, JPath pat
             return null;
         }
 
-        private static Difference FindJObjectDifference(JObject actual, JToken expected, JPath path, bool ignoreExtraProperties,
-            Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)
+        private Difference FindJObjectDifference(JObject actual, JToken expected, JPath path)
         {
             if (expected is not JObject expectedObject)
             {
                 return new Difference(DifferenceKind.OtherType, path, Describe(actual.Type), Describe(expected.Type));
             }
 
-            return CompareProperties(actual?.Properties(), expectedObject.Properties(), path, ignoreExtraProperties, config);
+            return CompareProperties(actual?.Properties(), expectedObject.Properties(), path);
         }
 
-        private static Difference CompareProperties(IEnumerable<JProperty> actual, IEnumerable<JProperty> expected, JPath path,
-            bool ignoreExtraProperties,
-            Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)
+        private Difference CompareProperties(IEnumerable<JProperty> actual, IEnumerable<JProperty> expected, JPath path)
         {
             var actualDictionary = actual?.ToDictionary(p => p.Name, p => p.Value) ?? new Dictionary<string, JToken>();
             var expectedDictionary = expected?.ToDictionary(p => p.Name, p => p.Value) ?? new Dictionary<string, JToken>();
@@ -168,7 +171,7 @@ private static Difference CompareProperties(IEnumerable<JProperty> actual, IEnum
                 JToken actualValue = actualDictionary[expectedPair.Key];
 
                 Difference firstDifference = FindFirstDifference(actualValue, expectedPair.Value,
-                    path.AddProperty(expectedPair.Key), ignoreExtraProperties, config);
+                    path.AddProperty(expectedPair.Key));
 
                 if (firstDifference != null)
                 {
@@ -179,9 +182,7 @@ private static Difference CompareProperties(IEnumerable<JProperty> actual, IEnum
             return null;
         }
 
-        private static Difference FindJPropertyDifference(JProperty actualProperty, JToken expected, JPath path,
-            bool ignoreExtraProperties,
-            Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)
+        private Difference FindJPropertyDifference(JProperty actualProperty, JToken expected, JPath path)
         {
             if (expected is not JProperty expectedProperty)
             {
@@ -193,20 +194,20 @@ private static Difference FindJPropertyDifference(JProperty actualProperty, JTok
                 return new Difference(DifferenceKind.OtherName, path);
             }
 
-            return FindFirstDifference(actualProperty.Value, expectedProperty.Value, path, ignoreExtraProperties, config);
+            return FindFirstDifference(actualProperty.Value, expectedProperty.Value, path);
         }
 
-        private static Difference FindValueDifference(JValue actualValue, JToken expected, JPath path, Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)
+        private Difference FindValueDifference(JValue actualValue, JToken expected, JPath path)
         {
             if (expected is not JValue expectedValue)
             {
                 return new Difference(DifferenceKind.OtherType, path, Describe(actualValue.Type), Describe(expected.Type));
             }
 
-            return CompareValues(actualValue, expectedValue, path, config);
+            return CompareValues(actualValue, expectedValue, path);
         }
 
-        private static Difference CompareValues(JValue actual, JValue expected, JPath path, Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)
+        private Difference CompareValues(JValue actual, JValue expected, JPath path)
         {
             if (actual.Type != expected.Type)
             {
@@ -216,7 +217,9 @@ private static Difference CompareValues(JValue actual, JValue expected, JPath pa
             bool hasMismatches;
             using (var scope = new AssertionScope())
             {
-                actual.Value.Should().BeEquivalentTo(expected.Value, options => (JsonAssertionOptions<object>)config.Invoke(new JsonAssertionOptions<object>(options)));
+                actual.Value.Should().BeEquivalentTo(expected.Value, options =>
+                    (JsonAssertionOptions<object>)config.Invoke(new JsonAssertionOptions<object>(options)));
+
                 hasMismatches = scope.Discard().Length > 0;
             }
 

Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,8 @@ private AndConstraint<JTokenAssertions> BeEquivalentTo(JToken expected, bool ign`
`114`	`114`	`string because = "",`
`115`	`115`	`params object[] becauseArgs)`
`116`	`116`	`{`
`117`		`- Difference difference = JTokenDifferentiator.FindFirstDifference(Subject, expected, ignoreExtraProperties, config);`
	`117`	`+ var differentiator = new JTokenDifferentiator(ignoreExtraProperties, config);`
	`118`	`+ Difference difference = differentiator.FindFirstDifference(Subject, expected);`
`118`	`119`
`119`	`120`	`var expectation = ignoreExtraProperties ? "was expected to contain" : "was expected to be equivalent to";`
`120`	`121`
Original file line number	Diff line number	Diff line change
`@@ -6,10 +6,20 @@`
`6`	`6`
`7`	`7`	`namespace FluentAssertions.Json`
`8`	`8`	`{`
`9`		`- // REFACTOR: Change to non-static and make parameters fields`
`10`		`- internal static class JTokenDifferentiator`
	`9`	`+ internal class JTokenDifferentiator`
`11`	`10`	`{`
`12`		`- public static Difference FindFirstDifference(JToken actual, JToken expected, bool ignoreExtraProperties, Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)`
	`11`	`+ private readonly bool ignoreExtraProperties;`
	`12`	`+`
	`13`	`+ private readonly Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config;`
	`14`	`+`
	`15`	`+ public JTokenDifferentiator(bool ignoreExtraProperties,`
	`16`	`+ Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)`
	`17`	`+ {`
	`18`	`+ this.ignoreExtraProperties = ignoreExtraProperties;`
	`19`	`+ this.config = config;`
	`20`	`+ }`
	`21`	`+`
	`22`	`+ public Difference FindFirstDifference(JToken actual, JToken expected)`
`13`	`23`	`{`
`14`	`24`	`var path = new JPath();`
`15`	`25`
`@@ -28,24 +38,22 @@ public static Difference FindFirstDifference(JToken actual, JToken expected, boo`
`28`	`38`	`return new Difference(DifferenceKind.ExpectedIsNull, path);`
`29`	`39`	`}`
`30`	`40`
`31`		`- return FindFirstDifference(actual, expected, path, ignoreExtraProperties, config);`
	`41`	`+ return FindFirstDifference(actual, expected, path);`
`32`	`42`	`}`
`33`	`43`
`34`		`- private static Difference FindFirstDifference(JToken actual, JToken expected, JPath path, bool ignoreExtraProperties, Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)`
	`44`	`+ private Difference FindFirstDifference(JToken actual, JToken expected, JPath path)`
`35`	`45`	`{`
`36`	`46`	`return actual switch`
`37`	`47`	`{`
`38`		`- JArray actualArray => FindJArrayDifference(actualArray, expected, path, ignoreExtraProperties, config),`
`39`		`- JObject actualObject => FindJObjectDifference(actualObject, expected, path, ignoreExtraProperties, config),`
`40`		`- JProperty actualProperty => FindJPropertyDifference(actualProperty, expected, path, ignoreExtraProperties, config),`
`41`		`- JValue actualValue => FindValueDifference(actualValue, expected, path, config),`
	`48`	`+ JArray actualArray => FindJArrayDifference(actualArray, expected, path),`
	`49`	`+ JObject actualObject => FindJObjectDifference(actualObject, expected, path),`
	`50`	`+ JProperty actualProperty => FindJPropertyDifference(actualProperty, expected, path),`
	`51`	`+ JValue actualValue => FindValueDifference(actualValue, expected, path),`
`42`	`52`	`_ => throw new NotSupportedException(),`
`43`	`53`	`};`
`44`	`54`	`}`
`45`	`55`
`46`		`- private static Difference FindJArrayDifference(JArray actualArray, JToken expected, JPath path,`
`47`		`- bool ignoreExtraProperties,`
`48`		`- Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)`
	`56`	`+ private Difference FindJArrayDifference(JArray actualArray, JToken expected, JPath path)`
`49`	`57`	`{`
`50`	`58`	`if (expected is not JArray expectedArray)`
`51`	`59`	`{`
`@@ -54,15 +62,15 @@ private static Difference FindJArrayDifference(JArray actualArray, JToken expect`
`54`	`62`
`55`	`63`	`if (ignoreExtraProperties)`
`56`	`64`	`{`
`57`		`- return CompareExpectedItems(actualArray, expectedArray, path, config);`
	`65`	`+ return CompareExpectedItems(actualArray, expectedArray, path);`
`58`	`66`	`}`
`59`	`67`	`else`
`60`	`68`	`{`
`61`		`- return CompareItems(actualArray, expectedArray, path, config);`
	`69`	`+ return CompareItems(actualArray, expectedArray, path);`
`62`	`70`	`}`
`63`	`71`	`}`
`64`	`72`
`65`		`- private static Difference CompareExpectedItems(JArray actual, JArray expected, JPath path, Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)`
	`73`	`+ private Difference CompareExpectedItems(JArray actual, JArray expected, JPath path)`
`66`	`74`	`{`
`67`	`75`	`JToken[] actualChildren = actual.Children().ToArray();`
`68`	`76`	`JToken[] expectedChildren = expected.Children().ToArray();`
`@@ -74,7 +82,7 @@ private static Difference CompareExpectedItems(JArray actual, JArray expected, J`
`74`	`82`	`bool match = false;`
`75`	`83`	`for (int actualIndex = matchingIndex; actualIndex < actualChildren.Length; actualIndex++)`
`76`	`84`	`{`
`77`		`- var difference = FindFirstDifference(actualChildren[actualIndex], expectedChild, true, config);`
	`85`	`+ var difference = FindFirstDifference(actualChildren[actualIndex], expectedChild);`
`78`	`86`
`79`	`87`	`if (difference == null)`
`80`	`88`	`{`
`@@ -88,7 +96,7 @@ private static Difference CompareExpectedItems(JArray actual, JArray expected, J`
`88`	`96`	`{`
`89`	`97`	`if (matchingIndex >= actualChildren.Length)`
`90`	`98`	`{`
`91`		`- if (actualChildren.Any(actualChild => FindFirstDifference(actualChild, expectedChild, true, config) == null))`
	`99`	`+ if (actualChildren.Any(actualChild => FindFirstDifference(actualChild, expectedChild) == null))`
`92`	`100`	`{`
`93`	`101`	`return new Difference(DifferenceKind.WrongOrder, path.AddIndex(expectedIndex));`
`94`	`102`	`}`
`@@ -97,15 +105,14 @@ private static Difference CompareExpectedItems(JArray actual, JArray expected, J`
`97`	`105`	`}`
`98`	`106`
`99`	`107`	`return FindFirstDifference(actualChildren[matchingIndex], expectedChild,`
`100`		`- path.AddIndex(expectedIndex), true, config);`
	`108`	`+ path.AddIndex(expectedIndex));`
`101`	`109`	`}`
`102`	`110`	`}`
`103`	`111`
`104`	`112`	`return null;`
`105`	`113`	`}`
`106`	`114`
`107`		`- private static Difference CompareItems(JArray actual, JArray expected, JPath path,`
`108`		`- Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)`
	`115`	`+ private Difference CompareItems(JArray actual, JArray expected, JPath path)`
`109`	`116`	`{`
`110`	`117`	`JToken[] actualChildren = actual.Children().ToArray();`
`111`	`118`	`JToken[] expectedChildren = expected.Children().ToArray();`
`@@ -117,8 +124,7 @@ private static Difference CompareItems(JArray actual, JArray expected, JPath pat`
`117`	`124`
`118`	`125`	`for (int i = 0; i < actualChildren.Length; i++)`
`119`	`126`	`{`
`120`		`- Difference firstDifference = FindFirstDifference(actualChildren[i], expectedChildren[i],`
`121`		`- path.AddIndex(i), false, config);`
	`127`	`+ Difference firstDifference = FindFirstDifference(actualChildren[i], expectedChildren[i], path.AddIndex(i));`
`122`	`128`
`123`	`129`	`if (firstDifference != null)`
`124`	`130`	`{`
`@@ -129,20 +135,17 @@ private static Difference CompareItems(JArray actual, JArray expected, JPath pat`
`129`	`135`	`return null;`
`130`	`136`	`}`
`131`	`137`
`132`		`- private static Difference FindJObjectDifference(JObject actual, JToken expected, JPath path, bool ignoreExtraProperties,`
`133`		`- Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)`
	`138`	`+ private Difference FindJObjectDifference(JObject actual, JToken expected, JPath path)`
`134`	`139`	`{`
`135`	`140`	`if (expected is not JObject expectedObject)`
`136`	`141`	`{`
`137`	`142`	`return new Difference(DifferenceKind.OtherType, path, Describe(actual.Type), Describe(expected.Type));`
`138`	`143`	`}`
`139`	`144`
`140`		`- return CompareProperties(actual?.Properties(), expectedObject.Properties(), path, ignoreExtraProperties, config);`
	`145`	`+ return CompareProperties(actual?.Properties(), expectedObject.Properties(), path);`
`141`	`146`	`}`
`142`	`147`
`143`		`- private static Difference CompareProperties(IEnumerable<JProperty> actual, IEnumerable<JProperty> expected, JPath path,`
`144`		`- bool ignoreExtraProperties,`
`145`		`- Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)`
	`148`	`+ private Difference CompareProperties(IEnumerable<JProperty> actual, IEnumerable<JProperty> expected, JPath path)`
`146`	`149`	`{`
`147`	`150`	`var actualDictionary = actual?.ToDictionary(p => p.Name, p => p.Value) ?? new Dictionary<string, JToken>();`
`148`	`151`	`var expectedDictionary = expected?.ToDictionary(p => p.Name, p => p.Value) ?? new Dictionary<string, JToken>();`
`@@ -168,7 +171,7 @@ private static Difference CompareProperties(IEnumerable<JProperty> actual, IEnum`
`168`	`171`	`JToken actualValue = actualDictionary[expectedPair.Key];`
`169`	`172`
`170`	`173`	`Difference firstDifference = FindFirstDifference(actualValue, expectedPair.Value,`
`171`		`- path.AddProperty(expectedPair.Key), ignoreExtraProperties, config);`
	`174`	`+ path.AddProperty(expectedPair.Key));`
`172`	`175`
`173`	`176`	`if (firstDifference != null)`
`174`	`177`	`{`
`@@ -179,9 +182,7 @@ private static Difference CompareProperties(IEnumerable<JProperty> actual, IEnum`
`179`	`182`	`return null;`
`180`	`183`	`}`
`181`	`184`
`182`		`- private static Difference FindJPropertyDifference(JProperty actualProperty, JToken expected, JPath path,`
`183`		`- bool ignoreExtraProperties,`
`184`		`- Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)`
	`185`	`+ private Difference FindJPropertyDifference(JProperty actualProperty, JToken expected, JPath path)`
`185`	`186`	`{`
`186`	`187`	`if (expected is not JProperty expectedProperty)`
`187`	`188`	`{`
`@@ -193,20 +194,20 @@ private static Difference FindJPropertyDifference(JProperty actualProperty, JTok`
`193`	`194`	`return new Difference(DifferenceKind.OtherName, path);`
`194`	`195`	`}`
`195`	`196`
`196`		`- return FindFirstDifference(actualProperty.Value, expectedProperty.Value, path, ignoreExtraProperties, config);`
	`197`	`+ return FindFirstDifference(actualProperty.Value, expectedProperty.Value, path);`
`197`	`198`	`}`
`198`	`199`
`199`		`- private static Difference FindValueDifference(JValue actualValue, JToken expected, JPath path, Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)`
	`200`	`+ private Difference FindValueDifference(JValue actualValue, JToken expected, JPath path)`
`200`	`201`	`{`
`201`	`202`	`if (expected is not JValue expectedValue)`
`202`	`203`	`{`
`203`	`204`	`return new Difference(DifferenceKind.OtherType, path, Describe(actualValue.Type), Describe(expected.Type));`
`204`	`205`	`}`
`205`	`206`
`206`		`- return CompareValues(actualValue, expectedValue, path, config);`
	`207`	`+ return CompareValues(actualValue, expectedValue, path);`
`207`	`208`	`}`
`208`	`209`
`209`		`- private static Difference CompareValues(JValue actual, JValue expected, JPath path, Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config)`
	`210`	`+ private Difference CompareValues(JValue actual, JValue expected, JPath path)`
`210`	`211`	`{`
`211`	`212`	`if (actual.Type != expected.Type)`
`212`	`213`	`{`
`@@ -216,7 +217,9 @@ private static Difference CompareValues(JValue actual, JValue expected, JPath pa`
`216`	`217`	`bool hasMismatches;`
`217`	`218`	`using (var scope = new AssertionScope())`
`218`	`219`	`{`
`219`		`- actual.Value.Should().BeEquivalentTo(expected.Value, options => (JsonAssertionOptions<object>)config.Invoke(new JsonAssertionOptions<object>(options)));`
	`220`	`+ actual.Value.Should().BeEquivalentTo(expected.Value, options =>`
	`221`	`+ (JsonAssertionOptions<object>)config.Invoke(new JsonAssertionOptions<object>(options)));`
	`222`	`+`
`220`	`223`	`hasMismatches = scope.Discard().Length > 0;`
`221`	`224`	`}`
`222`	`225`