AreEqual.Within throws on failure with non-numeric types

[manfred-brands]

This is related to #3726

Given the following code:

[Test]
public void TupleEqualsMismatch()
{
    var a = new Tuple<int, double>(1, 1.0);
    var b = new Tuple<int, double>(1, 1.5);

    Assert.That(a, Is.EqualTo(b).Within(0.2), $"{a} != {b}");
}

On NUnit 3.12 this produces:

Message: 
      (1, 1) != (1, 1.5)
      Expected: (1, 1.5d) +/- 0.20000000000000001d
      But was:  (1, 1.0d)

On NUnit 3.13 (and 3.14.0-dev-06990) this throws:

Message: 
    System.ArgumentException : Both arguments must be numeric
  Stack Trace: 
    Numerics.Difference(Object expected, Object actual, Boolean isAbsolute) line 447
    Numerics.Difference(Object expected, Object actual, ToleranceMode toleranceMode) line 436
    TextMessageWriter.WriteDifferenceLine(Object expected, Object actual, Tolerance tolerance) line 330
    TextMessageWriter.DisplayDifferences(Object expected, Object actual, Tolerance tolerance) line 181
    EqualConstraintResult.DisplayDifferences(MessageWriter writer, Object expected, Object actual, Int32 depth) line 96
    EqualConstraintResult.WriteMessageTo(MessageWriter writer) line 82
    Assert.ReportFailure(ConstraintResult result, String message, Object[] args) line 381
    Assert.That[TActual](TActual actual, IResolveConstraint expression, String message, Object[] args) line 229
    Tests.TupleEqualsMismatch() line 23

There might be other comparers where Tolerance is used, but the EqualConstraintResult.DisplayDifference cannot handle.
There are also comparers where Tolerance is completely ignored, these also fail, but in that case I would say that .Within should not be used.

[Antash]

@mikkelbu Please assign this to me as well. What do you think should be the best way of fixing this? Tolerance for the custom types like tuples or objects makes no sense as for me. But for backward compatibility with the existing codebase I think we should just don't print the diff at all.

[mikkelbu]

I agree that we should not fail. We can add a warning via the Analyzers that the using tolerance on non-numeric/datetimes has no effect.

[manfred-brands]

@Antash Tolerance for Tuples is actually used, changing my example to the below passes the test:

[Test]
public void TupleEqualsMismatch()
{
    var a = new Tuple<int, double>(1, 1.0);
    var b = new Tuple<int, double>(1, 1.1);

    Assert.That(a, Is.EqualTo(b).Within(0.2), $"{a} != {b}");
}

The TuplesComparer calls the EqualsComparer for each member and if that member happens to be numeric, the tolerance is applied.

[Antash]

@manfred-brands I see now, thank you for the explanation. I think better to limit that new difference feature which caused these bugs to DateTime types and flat Numeric types only.