Support equality comparison delegate

[jnm2]

This is already possible today:

Is.EqualTo(...).Using<Foo>((x, y) => x.CompareTo(y)))

The delegate returns int which allows you to pick one: equal, greater than, or less than. It's a sorting comparison rather than an equality comparison.

I have a similar scenario with objects in a third party library that provide IsEqual but do not override Equals (:thinking:...). This should work:

Is.EqualTo(...).Using<Foo>((x, y) => x.IsEqual(y)))

But because it returns bool rather than int, it does not work. I am forced to arbitrarily convert equal/inequal to either 0/1 (equal/greater than) or 0/-1 (equal/less than). I don't like this because an ordering comparison does not make sense in this context, only a pure equality comparison.

Is.EqualTo(...).Using<Foo>((x, y) => x.IsEqual(y) ? 0 : 1))

In my opinion, I should be able to return a bool directly from any arbitrary delegate and NUnit should use it like it uses bool IEqualityComparer<>.Equals similar to the effect of this final workaround:

private sealed class FooEqualityComparer : IEqualityComparer<Foo>
{
    public static FooEqualityComparer Instance { get; } = new FooEqualityComparer();
    private FooEqualityComparer() { }

    public bool Equals(Foo x, Foo y) => x.IsEqual(y);

    // I don't even want to think about implementing the hash code on this property bag.
    public int GetHashCode(Foo obj) => 0;
}

[CharliePoole]

Makes sense to me!

[jnm2]

To implement, start by creating a new test helper called GenericEqualityComparison, imitating GenericComparison.cs. We need a delegate type with the signature (T, T) => bool. We should probably use Func<T, T, bool> since the BCL does not have an EqualityComparison<T> delegate type. Then make the GenericEqualityComparison version of this test:

nunit/src/NUnitFramework/tests/Constraints/EqualConstraintTests.cs

Lines 564 to 570 in e7c7826

	[Test]
	public void UsesProvidedGenericComparison()
	{
	var comparer = new GenericComparison<int>();
	Assert.That(2 + 2, Is.EqualTo(4).Using(comparer.Delegate));
	Assert.That(comparer.WasCalled, "Comparer was not called");
	}

And proceed to add the Func<T, T, bool> overloads to make the test pass. Along the way you'll need to create an EqualityAdapter.For overload which adapts Func<T, T, bool> to the EqualityComparer shape, just like this does for IEqualityComparer<T>:

nunit/src/NUnitFramework/framework/Constraints/EqualityAdapter.cs

Lines 187 to 206 in e7c7826

	public static EqualityAdapter For<T>(IEqualityComparer<T> comparer)
	{
	return new EqualityComparerAdapter<T>(comparer);
	}
	class EqualityComparerAdapter<T> : GenericEqualityAdapter<T>
	{
	private IEqualityComparer<T> comparer;
	public EqualityComparerAdapter(IEqualityComparer<T> comparer)
	{
	this.comparer = comparer;
	}
	public override bool AreEqual(object x, object y)
	{
	ThrowIfNotCompatible(x, y);
	return comparer.Equals((T)x, (T)y);
	}
	}

[david-proctor]

I'll take this issue if that's all right with everyone.

[jnm2]

@david-proctor Fantastic, thanks!

[david-proctor]

Submitted PR #2460.