Added an overload to CheckReference in the PersistenceSpecificationExtensions so you can specify the properties of the reference to compare without creating a custom IEqualityComparer.

Author: RyanHauert

src/FluentNHibernate.Testing/Testing/PersistenceSpecificationTester.cs

@@ -168,6 +168,15 @@ public void VerifyTheMappings_returns_instance()
 			var cat = _spec.CheckProperty(x => x.FirstKitten, _cat.FirstKitten).VerifyTheMappings();
 			cat.ShouldNotBeNull();
     	}
+
+        [Test]
+        public void Comparing_reference_should_use_the_specified_property_comparisons()
+        {
+            _spec.CheckReference(cat => cat.FirstKitten, _cat.FirstKitten, x => x.Id).VerifyTheMappings();
+
+            Assert.Throws<ApplicationException>(() => _spec.CheckReference(cat => cat.FirstKitten, _cat.FirstKitten, x => x.Id, x => x.Name)
+                .VerifyTheMappings());
+        }
     }
 
     [TestFixture]

src/FluentNHibernate/Testing/PersistenceSpecificationExtensions.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 using FluentNHibernate.Testing.Values;
 using FluentNHibernate.Utils;
@@ -81,6 +82,19 @@ public static PersistenceSpecification<T> CheckReference<T>(this PersistenceSpec
             return spec.RegisterCheckedProperty(new ReferenceProperty<T, object>(property, propertyValue), propertyComparer);
         }
 
+        public static PersistenceSpecification<T> CheckReference<T, TReference>(this PersistenceSpecification<T> spec,
+                                                                   Expression<Func<T, object>> expression,
+                                                                   TReference propertyValue,
+                                                                   params Func<TReference, object>[] propertiesToCompare)
+        {
+            // Because of the params keyword, the compiler will 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.CheckReference(expression, propertyValue, (IEqualityComparer)null);
+
+            return spec.CheckReference(expression, propertyValue, new FuncEqualityComparer<TReference>(propertiesToCompare));
+        }
+
         public static PersistenceSpecification<T> CheckReference<T, TProperty>(this PersistenceSpecification<T> spec,
                                                                                 Expression<Func<T, TProperty>> expression,
                                                                                 TProperty propertyValue,
@@ -254,5 +268,25 @@ public static PersistenceSpecification<T> CheckEnumerable<T, TItem>(this Persist
         {
             return spec.CheckList(expression, itemsToAdd, addAction);
         }
+
+        private class FuncEqualityComparer<T> : EqualityComparer<T>
+        {
+            readonly IEnumerable<Func<T, object>> comparisons;
+
+            public FuncEqualityComparer(IEnumerable<Func<T, object>> comparisons)
+            {
+                this.comparisons = comparisons;
+            }
+
+            public override bool Equals(T x, T y)
+            {
+                return comparisons.All(func => object.Equals(func(x), func(y)));
+            }
+
+            public override int GetHashCode(T obj)
+            {
+                throw new NotSupportedException();
+            }
+        }
     }
 }