如何在IEqualityComparer上实现单元测试？

Question

I have a class and a comparer for this class that implements IEqualityComparer :

class Foo
{
    public int Int { get; set; }
    public string Str { get; set; }

    public Foo(int i, string s)
    {
        Int = i;
        Str = s;
    }

    private sealed class FooEqualityComparer : IEqualityComparer<Foo>
    {
        public bool Equals(Foo x, Foo y)
        {
            if (ReferenceEquals(x, y)) return true;
            if (ReferenceEquals(x, null)) return false;
            if (ReferenceEquals(y, null)) return false;
            if (x.GetType() != y.GetType()) return false;
            return x.Int == y.Int && string.Equals(x.Str, y.Str);
        }

        public int GetHashCode(Foo obj)
        {
            unchecked
            {
                return (obj.Int * 397) ^ (obj.Str != null ? obj.Str.GetHashCode() : 0);
            }
        }
    }

    public static IEqualityComparer<Foo> Comparer { get; } = new FooEqualityComparer();
}

The two methods Equals and GetHashCode are used for example in List.Except via an instance of the comparer.

My question is: how to implement properly unit tests on this comparer? I want to detect if someone adds a public property in Foo without modifying the comparer, because in this case the comparer becomes invalid.

If I do something like:

Assert.That(new Foo(42, "answer"), Is.EqualTo(new Foo(42, "answer")));

This cannot detect that a new property was added, and that this property differs in the two objects.

Is there any way to do this?

If it is possible, can we add an attribute to a property to say that this property is not relevant in the comparison?

Answer 1

Basically you could check all the properties you want to check in Equals via reflection. To filter some of them out use an attribute on those properties:

class Foo
{
    [MyAttribute]
    public string IgnoredProperty { get; set; }
    public string MyProperty { get; set; }
}

Now in your comparer check for that specific attribute. Afterwards compare every property that is contained in the remaining list via PropertyInfo.GetValue

class MyComparer : IEqualityComparer<Foo>
{
    public bool Equals(Foo x, Foo y)
    {
        var properties = this.GetType().GetProperties()
                .Where(x => "Attribute.IsDefined(x, typeof(MyAttribute));
        var equal = true;
        foreach(var p in properties)
           equal &= p.GetValue(x, null) == p.GetValue(y, null);
        return equal;
    }
}

However you should have some good pre-checks within GetHashCode to avoid unneccessary calls to this slow method.

EDIT: As you´ve mentioned ReSharper, I assume as you provide the actual properties to be validated at runtime even R# doesn´t know a good way to implement GetHashCode . You will need some properties that will allways be available on your type and that provide a good enough idea of what might be considered equal. All theadditional properties however should only go into the expensive Equals -method.

EDIT2: As mentioned in the comments doing reflection within Equals or even GetHashCode is a bad idea as it´s usually quite slow and can often be avoided. If you know the properties to be checked for eqality at compile-time you should definitly include them within those two methods as doing so gives you much more safety. When you find yourself really to need this because you have to many properties you probably have some basic problem as your class is doing too much.

Answer 2

You can use reflection to get the properties of the type, eg:

var knownPropNames = new string[]
{
    "Int", 
    "Str", 
};
var props = typeof(Foo).GetProperties(BindingFlags.Public | BindingFlags.Instance);
var unknownProps = props
                    .Where(x => !knownPropNames.Contains(x.Name))
                    .Select(x => x.Name)
                    .ToArray();
// Use assertion instead of Console.WriteLine
Console.WriteLine("Unknown props: {0}", string.Join("; ", unknownProps));

This way, you can implement a test that fails if any properties are added. Of course, you'd have to add new properties to the array at the beginning. As using reflection is an expensive operation from a performance point of view, I'd propose to use it in the test, not in the comparer itself if you need to compare lots of objects.

Please also note the use of the BindingFlags parameter so you can restrict the properties to only the public ones and the ones on instance-level.

Also, you can define a custom attribute that you use to mark properties that are not relevant. For example:

[AttributeUsage(AttributeTargets.Property)]
public class ComparerIgnoreAttribute : Attribute {}

You can apply it to a property:

[ComparerIgnore]
public decimal Dec { get; set; }

In addition, you'd have to extend the code that discovers unknown properties:

var unknownProps = props
                    .Where(x => !knownPropNames.Contains(x.Name) 
                        && !x.GetCustomAttributes(typeof(ComparerIgnoreAttribute)).Any())
                    .Select(x => x.Name)
                    .ToArray();

Answer 3

I guess you can check properties count inside the comparer. Something like this:

private sealed class FooEqualityComparer : IEqualityComparer<Foo>
{
    private List<bool> comparisonResults = new List<bool>();
    private List<Func<Foo, Foo, bool>> conditions = new List<Func<Foo, Foo, bool>>{
        (x, y) => x.Int == y.Int,
        (x, y) => string.Equals(x.Str, y.Str)
    };
    private int propertiesCount = typeof(Foo)
                .GetProperties(BindingFlags.Public | BindingFlags.Instance)
                //.Where(someLogicToExclde(e.g attribute))
                .Count();

    public bool Equals(Foo x, Foo y)
    {
        if (ReferenceEquals(x, y)) return true;
        if (ReferenceEquals(x, null)) return false;
        if (ReferenceEquals(y, null)) return false;
        if (x.GetType() != y.GetType()) return false;   
        //has new property which is not presented in the conditions list and not excluded
        if (conditions.Count() != propertiesCount) return false;    

        foreach(var func in conditions)
            if(!func(x, y)) return false;//returns false on first mismatch

        return true;//only if all conditions are satisfied
    }

    public int GetHashCode(Foo obj)
    {
        unchecked
        {
            return (obj.Int * 397) ^ (obj.Str != null ? obj.Str.GetHashCode() : 0);
        }
    }
}