Added an overload of CheckList to match the added overload of CheckReference

Author: RyanHauert

src/FluentNHibernate.Testing/Testing/PersistenceSpecificationTester.cs

@@ -145,6 +145,16 @@ public void should_not_be_equal_without_the_equality_comparer()
                 _spec.CheckList(x => x.AllKittens, _cat.AllKittens).VerifyTheMappings());
         }
 
+        [Test]
+        public void Comparing_objects_in_two_lists_should_use_the_specified_comparisons()
+        {
+            _spec.CheckList(x => x.AllKittens, _cat.AllKittens, kitten => kitten.Id).VerifyTheMappings();
+
+            // Should fail because the names don't match.
+            Assert.Throws<ApplicationException>(() => _spec.CheckList(x => x.AllKittens, _cat.AllKittens, kitten => kitten.Id, kitten => kitten.Name)
+                .VerifyTheMappings());
+        }
+
         [Test]
         public void Can_test_enumerable()
         {
@@ -174,6 +184,7 @@ public void Comparing_reference_should_use_the_specified_property_comparisons()
         {
             _spec.CheckReference(cat => cat.FirstKitten, _cat.FirstKitten, x => x.Id).VerifyTheMappings();
 
+            // Should fail because the names don't match.
             Assert.Throws<ApplicationException>(() => _spec.CheckReference(cat => cat.FirstKitten, _cat.FirstKitten, x => x.Id, x => x.Name)
                 .VerifyTheMappings());
         }

src/FluentNHibernate/Testing/PersistenceSpecificationExtensions.cs

@@ -135,6 +135,19 @@ public static PersistenceSpecification<T> CheckList<T, TListElement>(this Persis
             return spec.RegisterCheckedProperty(new ReferenceList<T, TListElement>(property, propertyValue), elementComparer);
         }
 
+        public static PersistenceSpecification<T> CheckList<T, TListElement>(this PersistenceSpecification<T> spec,
+                                                                            Expression<Func<T, IEnumerable<TListElement>>> expression,
+                                                                            IEnumerable<TListElement> propertyValue,
+                                                                            params Func<TListElement, object>[] propertiesToCompare)
+        {
+            // Because of the params keyword, the compiler can select this overload
+            // instead of the one above, even when no funcs are supplied in the method call.
+            if (propertiesToCompare == null || propertiesToCompare.Length == 0)
+                return spec.CheckList(expression, propertyValue, (IEqualityComparer)null);
+
+            return spec.CheckList(expression, propertyValue, new FuncEqualityComparer<TListElement>(propertiesToCompare));
+        }
+
         public static PersistenceSpecification<T> CheckList<T, TListElement>(this PersistenceSpecification<T> spec,
                                                                               Expression<Func<T, IEnumerable<TListElement>>> expression,
                                                                               IEnumerable<TListElement> propertyValue,