Refactor FluentNHibernate.Testing.Values List & ReferenceBag to avoid using non-generic IEnumerable (#687)

+semver:patch

Author: hazzik

src/FluentNHibernate/Testing/Values/List.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using FluentNHibernate.Utils;
@@ -21,29 +20,7 @@ public override Action<T, Accessor, IEnumerable<TListElement>> ValueSetter
             }
 
             return (target, propertyAccessor, value) =>
-            {
-                object collection;
-
-                // sorry guys - create an instance of the collection type because we can't rely
-                // on the user to pass in the correct collection type (especially if they're using
-                // an interface). I've tried to create the common ones, but I'm sure this won't be
-                // infallible.
-                if (propertyAccessor.PropertyType.IsAssignableFrom(typeof(ISet<TListElement>)))
-                {
-                    collection = new HashSet<TListElement>(Expected.ToList());
-                }
-                else if (propertyAccessor.PropertyType.IsArray)
-                {
-                    collection = Array.CreateInstance(typeof(TListElement), Expected.Count());
-                    Array.Copy((Array)Expected, (Array)collection, Expected.Count());
-                }
-                else
-                {
-                    collection = new List<TListElement>(Expected);
-                }
-
-                propertyAccessor.SetValue(target, collection);
-            };
+                propertyAccessor.SetValue(target, CreateCollection(propertyAccessor.PropertyType));
         }
         set => _valueSetter = value;
     }
@@ -52,11 +29,11 @@ public override Action<T, Accessor, IEnumerable<TListElement>> ValueSetter
 
     public override void CheckValue(object target)
     {
-        var actual = PropertyAccessor.GetValue(target) as IEnumerable;
+        var actual = PropertyAccessor.GetValue(target) as IEnumerable<TListElement>;
         AssertGenericListMatches(actual, Expected);
     }
 
-    void AssertGenericListMatches(IEnumerable actualEnumerable, IEnumerable<TListElement> expectedEnumerable)
+    void AssertGenericListMatches(IEnumerable<TListElement> actualEnumerable, IEnumerable<TListElement> expectedEnumerable)
     {
         if (actualEnumerable is null)
         {
@@ -69,20 +46,17 @@ void AssertGenericListMatches(IEnumerable actualEnumerable, IEnumerable<TListEle
                 "Actual and expected are not equal (expected was null).");
         }
 
-        List<object> actualList = new List<object>();
-        foreach (var item in actualEnumerable)
-        {
-            actualList.Add(item);
-        }
-
+        var actualList = actualEnumerable.ToList();
         var expectedList = expectedEnumerable.ToList();
 
         if (actualList.Count != expectedList.Count)
         {
-            throw new ApplicationException(String.Format("Actual count ({0}) does not equal expected count ({1})", actualList.Count, expectedList.Count));
+            throw new ApplicationException($"Actual count ({actualList.Count}) does not equal expected count ({expectedList.Count})");
         }
 
-        var equalsFunc = (EntityEqualityComparer is not null) ? ((a, b) => EntityEqualityComparer.Equals(a, b)): new Func<object, object, bool>(Equals);
+        Func<object, object, bool> equalsFunc = EntityEqualityComparer is not null
+            ? EntityEqualityComparer.Equals
+            : Equals;
 
         for (var i = 0; i < actualList.Count; i++)
         {
@@ -91,12 +65,27 @@ void AssertGenericListMatches(IEnumerable actualEnumerable, IEnumerable<TListEle
                 continue;
             }
 
-            var message = String.Format("Expected '{0}' but got '{1}' at position {2}",
-                expectedList[i],
-                actualList[i],
-                i);
-
+            var message = $"Expected '{expectedList[i]}' but got '{actualList[i]}' at position {i}";
             throw new ApplicationException(message);
         }
     }
+
+    IEnumerable<TListElement> CreateCollection(Type type)
+    {
+        // sorry guys - create an instance of the collection type because we can't rely
+        // on the user to pass in the correct collection type (especially if they're using
+        // an interface). I've tried to create the common ones, but I'm sure this won't be
+        // infallible.
+        if (type.IsAssignableFrom(typeof(ISet<TListElement>)))
+        {
+            return new HashSet<TListElement>(Expected);
+        }
+
+        if (type.IsArray)
+        {
+            return Expected.ToArray();
+        }
+
+        return Expected.ToList();
+    }
 }

src/FluentNHibernate/Testing/Values/ReferenceBag.cs

@@ -11,11 +11,11 @@ public class ReferenceBag<T, TListElement>(Accessor property, IEnumerable<TListE
 {
     public override void CheckValue(object target)
     {
-        var actual = PropertyAccessor.GetValue(target) as IEnumerable;
+        var actual = PropertyAccessor.GetValue(target) as IEnumerable<TListElement>;
         AssertGenericListMatches(actual, Expected);
     }
 
-    void AssertGenericListMatches(IEnumerable actualEnumerable, IEnumerable<TListElement> expectedEnumerable)
+    void AssertGenericListMatches(IEnumerable<TListElement> actualEnumerable, IEnumerable<TListElement> expectedEnumerable)
     {
         if (actualEnumerable is null)
         {
@@ -28,24 +28,23 @@ void AssertGenericListMatches(IEnumerable actualEnumerable, IEnumerable<TListEle
                 "Actual and expected are not equal (expected was null).");
         }
 
-        var actualList = actualEnumerable.Cast<object>().ToList();
+        var actualList = actualEnumerable.ToList();
 
         var expectedList = expectedEnumerable.ToList();
 
         if (actualList.Count != expectedList.Count)
         {
-            throw new ApplicationException(String.Format("Actual count ({0}) does not equal expected count ({1})", actualList.Count, expectedList.Count));
+            throw new ApplicationException($"Actual count ({actualList.Count}) does not equal expected count ({expectedList.Count})");
         }
 
-        var equalsFunc = (EntityEqualityComparer is not null)
-            ? new Func<object, object, bool>((a, b) => EntityEqualityComparer.Equals(a, b))
-            : new Func<object, object, bool>(Equals);
-
+        Func<object, object, bool> equalsFunc = EntityEqualityComparer is not null
+            ? EntityEqualityComparer.Equals
+            : Equals;
 
         var result = actualList.FirstOrDefault(item => actualList.Count(x => equalsFunc(item, x)) != expectedList.Count(x => equalsFunc(item, x)));
         if (result is not null)
         {
-            throw new ApplicationException(String.Format("Actual count of item {0} ({1}) does not equal expected item count ({2})",result, actualList.Count(x => x == result), expectedList.Count(x => (object)x == result)));
+            throw new ApplicationException($"Actual count of item {result} ({actualList.Count(x => ReferenceEquals(x, result))}) does not equal expected item count ({expectedList.Count(x => ReferenceEquals(x, result))})");
         }
     }
 }