Is.EqualTo(...).Using(StructuralComparisons.StructuralEqualityComparer or StructuralComparer) not working

[marklam]

System.Collections.Immutable.ImmutableArray implements both reference equality and structural equality via IStructuralEquatable.

I want to be able to check two arrays for structural equality, but only some of the overloads of EqualConstraint.Using work as expected.

The two overloads that take IEqualityComparer or IComparer don't use the correct comparison, whereas the versions that take delegates do.

The attached code (which was built with packages NUnit 3.12.0 and System.Collections.Immutable 1.7.0 fails the last two tests.

using System;
using System.Collections;
using System.Collections.Immutable;
using NUnit.Framework;

namespace NUnitStructural
{
    [TestFixture]
    public class Test
    {
        [Test]
        public void ImmutableArrayNotReferenceEquality()
        {
            var x = ImmutableArray.Create(1, 2, 3);
            var y = ImmutableArray.Create(1, 2, 3);

            Assert.That(x != y);
        }

        [Test]
        public void ImmutableArrayWithStructuralEqualityComparison()
        {
            var x = ImmutableArray.Create(1, 2, 3);
            var y = ImmutableArray.Create(1, 2, 3);

            Comparison<ImmutableArray<int>> comparison = (a, b) => StructuralComparisons.StructuralComparer.Compare(a, b);
            Assert.That(x, Is.EqualTo(y).Using(comparison));
        }

        [Test]
        public void ImmutableArrayWithStructuralEqualityComparerEquals()
        {
            var x = ImmutableArray.Create(1, 2, 3);
            var y = ImmutableArray.Create(1, 2, 3);

            var del = new Func<ImmutableArray<int>, ImmutableArray<int>, bool>((a, b) => StructuralComparisons.StructuralEqualityComparer.Equals(a, b));
            Assert.That(x, Is.EqualTo(y).Using<ImmutableArray<int>>(del));
        }

        [Test]
        public void ImmutableArrayWithStructuralComparerEquals()
        {
            var x = ImmutableArray.Create(1, 2, 3);
            var y = ImmutableArray.Create(1, 2, 3);

            var del = new Func<ImmutableArray<int>, ImmutableArray<int>, bool>((a, b) => StructuralComparisons.StructuralComparer.Compare(a, b) == 0);
            Assert.That(x, Is.EqualTo(y).Using<ImmutableArray<int>>(del));
        }

        [Test]
        public void ImmutableArrayWithStructuralEqualityComparer()
        {
            var x = ImmutableArray.Create(1, 2, 3);
            var y = ImmutableArray.Create(1, 2, 3);

            Assert.That(x, Is.EqualTo(y).Using(StructuralComparisons.StructuralEqualityComparer));
        }

        [Test]
        public void ImmutableArrayWithStructuralComparer()
        {
            var x = ImmutableArray.Create(1, 2, 3);
            var y = ImmutableArray.Create(1, 2, 3);

            Assert.That(x, Is.EqualTo(y).Using(StructuralComparisons.StructuralComparer));
        }
    }
}

[mikkelbu]

I can confirm the issue. Looking at the code I guess that the problem is that EqualityAdapter only handles strings and the derived classes EqualityComparerAdapter and ComparerAdapter used in the last two cases does not override CanCompare, so the code does not think that the supplied method can be used.

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

Lines 50 to 59 in 1581016

	public virtual bool CanCompare(object x, object y)
	{
	if (x is string && y is string)
	return true;
	if (x is IEnumerable || y is IEnumerable)
	return false;
	return true;
	}

[CharliePoole]

It handles all classes except IEnumerables, unless the IEnumerable is a string. That's because the intent is to pass the equality test down to each item returned by the IEnumerable.

[stevenaw]

I just ran into this myself. Seems the issue is isolated to ImmutableArray (possibly other value types which implement IEquatable) as the other immutable collections are all reference types and pass without requiring structural equality:

        // Fails
        [Test]
        public void ImmutableArrayEquals()
        {
            var x = ImmutableArray.Create(1, 2, 3);
            var y = ImmutableArray.Create(1, 2, 3);

            Assert.That(x, Is.EqualTo(y));
        }

        // Passes
        [Test]
        public void ImmutableListEquals()
        {
            var x = ImmutableList.Create(1, 2, 3);
            var y = ImmutableList.Create(1, 2, 3);

            Assert.That(x, Is.EqualTo(y));
        }

[stevenaw]

I've been experimenting with this periodically the last few weeks. Happy to have it formally assigned to me for investigation.