Asserts with UsingPropertiesComparer and Tolerance crashes unxpectedly if using TimeSpan and the class contains Properties with different types.

[Taron-art]

Example:

    [TestFixture]
    public class RepeatTest
    {
        public class ClassToCheck()
        {
            public int Id { get; set; } = 1;
            public string Name { get; set; } = "Name";
            public DateTimeOffset Now { get; } = DateTimeOffset.UtcNow;
        }


        [Test]
        public void Test()
        {
            var expected = new ClassToCheck();
            var actual = new ClassToCheck();
            Assert.That(actual, Is.EqualTo(expected).UsingPropertiesComparer().Within(TimeSpan.FromSeconds(1)));
        }
    }

I expect this test to pass since I'm trying to add a tolerance for DateTime comparison. NUnit, however, tries to apply this tolerance to the int field. As a result, the test fails with the following:

Message: 
  System.InvalidCastException : Unable to cast object of type 'System.TimeSpan' to type 'System.IConvertible'.

Stack Trace: 
  Convert.ToInt32(Object value)
  Numerics.AreEqual(Int32 expected, Int32 actual, Tolerance tolerance)
  Numerics.AreEqual(Object expected, Object actual, Tolerance& tolerance)
  NumericsComparer.Equal(Object x, Object y, Tolerance& tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer)
  NUnitEqualityComparer.AreEqual(Object x, Object y, Tolerance& tolerance, ComparisonState state)
  PropertiesComparer.Equal(Object x, Object y, Tolerance& tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer)
  NUnitEqualityComparer.AreEqual(Object x, Object y, Tolerance& tolerance, ComparisonState state)
  NUnitEqualityComparer.AreEqual(Object x, Object y, Tolerance& tolerance)
  EqualConstraint.ApplyTo[TActual](TActual actual)
  Assert.That[TActual](TActual actual, IResolveConstraint expression, NUnitString message, String actualExpression, String constraintExpression)
  RepeatTest.Test() line 26
  RuntimeMethodHandle.InvokeMethod(Object target, Void** arguments, Signature sig, Boolean isConstructor)
  MethodBaseInvoker.InvokeWithNoArgs(Object obj, BindingFlags invokeAttr)

While I understand why it happened, an expected behavior would be to apply tolerance only to the applicable types. It however opens a rabbit hole (what if I want more than one tolerance for different types?). I still think this is a bug, may be it can be handled with a more user friendly error message.

[OsirisTerje]

@manfred-brands Can you comment on this ?

[manfred-brands]

The same exception is thrown when comparing values without UsingPropertiesComparer:

[TestCase(40, 42)]
public void AssertThatWithInvalidTolerance(object actual, object expected)
{
    Assert.That(actual, Is.EqualTo(expected).Within(TimeSpan.FromSeconds(1)));
}

Note that use of object as the type safe Is.EqualTo(int) does not allow specifying a Within(TimeSpan).

[manfred-brands]

While I understand why it happened, an expected behavior would be to apply tolerance only to the applicable types.

The single tolerance value specified is tried and applied to each member. If the member doesn't support tolerance, e.g. strings, the comparison is done again but this time without tolerance. If none of the members support tolerance an exception is raised.

This only works if the one numerical tolerance can be applied to all members.

In PropertiesComparer it could try to only apply the tolerance if it is appropriate for the type of the member.
So only apply TimeSpan to DateTime.

It however opens a rabbit hole (what if I want more than one tolerance for different types?)

Indeed.

We now have PropertiesComparerConfiguration, maybe it can be added to that.
Either by specifying a tolerance for specific members or a tolerance per type.

// Only use specified tolerance for `Now` member
.UsingPropertiesComparer(c => c.Within(TimeSpan.FromSeconds(1), x => x.Now))

// Use TimeSpan tolerance for DateTime members, use 0.1 for all numerics.
.UsingPropertiesComparer(c => c.Within(TimeSpan.FromSeconds(1)).Within(0.1))

may be it can be handled with a more user friendly error message.

In Numerics.AreEqual we unconditionally convert the tolerance to the type of the elements being compared.
We could do this in a try/catch and fail with a different exception indicating that the tolerance value is not appropriate.

I will improve the error and only apply tolerance if it has the correct type.

[manfred-brands]

Note that the nunit.analyzer warns at the moment when using Within with UsingPropertiesComparer():