♻️ better error messages for deep equivalence

- also, perhaps a bug? when testing the output, I noticed two different
  collections not triggering failure, and it's likely because they were
  collections of ints where the default value is not null; at any rate,
  rewriting seems to have solved this

src/NExpect/CollectionDeepEqualityMatchers.cs

@@ -223,7 +223,7 @@ object[] customEqualityComparers
                             }
 
                             var result =
-                                AreDeepEqual(
+                                Compare(
                                     cur.Item1,
                                     cur.Item2,
                                     customEqualityComparers,

src/NExpect/CollectionDeepEquivalenceMatchers.cs

@@ -90,16 +90,22 @@ params object[] customEqualityComparers
                     expected,
                     customEqualityComparers
                 );
+                var errors = result.Errors.Any()
+                    ? new[]
+                    {
+                        ""
+                    }.Concat(result.Errors).ToArray()
+                    : result.Errors;
                 return new MatcherResult(
                     result.AreEqual,
                     () => FinalMessageFor(
                         new[]
                         {
                             "Expected",
                             collection.LimitedPrint(),
-                            $"{result.AreEqual.AsNot()} to be deep equivalent to",
+                            $"\n{result.AreEqual.AsNot()}to be deep equivalent to\n",
                             expected.LimitedPrint()
-                        }.Concat(result.Errors).ToArray(),
+                        }.Concat(errors).ToArray(),
                         customMessageGenerator
                     )
                 );
@@ -147,25 +153,53 @@ object[] customEqualityComparers
                     }
 
                     var ignoreProperties = currentMaster.FindOrAddPropertyIgnoreListMetadata();
-                    var compareMatch = compare.FirstOrDefault(
-                        c => AreDeepEqual(
-                            currentMaster,
-                            c,
-                            customEqualityComparers,
-                            ignoreProperties
-                        ).AreEqual
+                    var hasMatch = HasDeepEqualValueInCollection(
+                        compare,
+                        currentMaster,
+                        customEqualityComparers,
+                        ignoreProperties,
+                        out var matched
                     );
-                    if (compareMatch == null)
+                    if (!hasMatch)
                     {
-                        return new DeepTestResult(false, $"no match for item {currentMaster.Stringify()}");
+                        return new DeepTestResult(
+                            false,
+                            $"no match for item {currentMaster.Stringify()}"
+                        );
                     }
 
                     master.Remove(currentMaster);
-                    compare.Remove(compareMatch);
+                    compare.Remove(matched);
                 }
 
                 return DeepTestResult.Pass;
             }
         );
     }
+
+    private static bool HasDeepEqualValueInCollection<T>(
+        IEnumerable<T> collection,
+        T find,
+        object[] customEqualityComparers,
+        HashSet<string> ignoreProperties,
+        out T matched
+    )
+    {
+        matched = default;
+        foreach (var item in collection)
+        {
+            if (Compare(
+                    find,
+                    item,
+                    customEqualityComparers,
+                    ignoreProperties
+                ).AreEqual)
+            {
+                matched = item;
+                return true;
+            }
+        }
+
+        return false;
+    }
 }

src/NExpect/CollectionIntersectionEquivalenceExtensions.cs

@@ -93,16 +93,22 @@ params object[] customEqualityComparers
                     expectedArray,
                     customEqualityComparers
                 );
+                var errors = result.Errors.Any()
+                    ? new[]
+                    {
+                        ""
+                    }.Concat(result.Errors).ToArray()
+                    : result.Errors;
                 return new MatcherResult(
                     result.AreEqual,
                     FinalMessageFor(
                         () => new[]
                         {
                             "Expected",
                             actualArray.LimitedPrint(),
-                            $"{result.AreEqual.AsNot()} to be intersection equivalent to",
+                            $"\n{result.AreEqual.AsNot()} to be intersection equivalent to\n",
                             expectedArray.LimitedPrint()
-                        }.Concat(result.Errors).ToArray(),
+                        }.Concat(errors).ToArray(),
                         customMessageGenerator
                     )
                 );

src/NExpect/CollectionMatchers.cs

@@ -1345,7 +1345,7 @@ params object[] customEqualityComparers
             (o1, o2) =>
             {
                 var ignoreProperties = o1.FindOrAddPropertyIgnoreListMetadata();
-                return DeepTestHelpers.AreDeepEqual(
+                return DeepTestHelpers.Compare(
                     o1,
                     o2,
                     customEqualityComparers,

src/NExpect/DeepEqualityMatchers.cs

@@ -147,7 +147,7 @@ params object[] customEqualityComparers
             actual =>
             {
                 var ignoreProperties = actual.FindOrAddPropertyIgnoreListMetadata();
-                var deepEqualResult = DeepTestHelpers.AreDeepEqual(
+                var deepEqualResult = DeepTestHelpers.Compare(
                     actual,
                     expected,
                     customEqualityComparers,

src/NExpect/Helpers/DeepTestHelpers.cs

@@ -61,22 +61,22 @@ HashSet<string> ignoreProperties
         );
     }
 
-    internal static DeepTestResult AreDeepEqual(
+    internal static DeepTestResult Compare(
         object item1,
         object item2,
         object[] customEqualityComparers,
         HashSet<string> ignoreProperties
     )
     {
-        return AreDeepEqual(
+        return Compare(
             item1,
             item2,
             customEqualityComparers,
             ignoreProperties.ToArray()
         );
     }
 
-    internal static DeepTestResult AreDeepEqual(
+    internal static DeepTestResult Compare(
         object item1,
         object item2,
         object[] customEqualityComparers,
@@ -148,7 +148,7 @@ Func<List<T>, List<T>, DeepTestResult> finalComparison
         {
             return DeepTestResult.Fail(
                 expected == null
-                    ? $"Expected collection is null but actual is not"
+                    ? "Expected collection is null but actual is not"
                     : "Actual collection is null but expected is not"
             );
         }