InRange-Constraint must work with object

[NUnitTester]

The following code does work even if myObj is from a class no special interface is implemented:

Assert.That(myObj, Is.EqualTo(expcted).Using(myComparer));
Assert.That(myObj, Is.InRange(expcted1, expcted2).Using(myComparer));

There must be a inheritance of IComparable, or it does not compile. (NUnit 3.4.1)
This is an error, because it must also work with objects.

• the type of myObj and expected1 I cannot change, because it is a external type from a library
• a comparer is supported, so it should work
• the constructor of InRangeConstraint calls the Compare-Methode of IComparable of expected1 not regarding the comparer in the Using to check the relation between from and to. This is a big bug in my eyes, using the wrong comparer.

[CharliePoole]

This has been the definition of RangeConstraint for many years. I take it you are saying that it should be sufficient for the two expected values to implement IComparable. Is that right?

Can you post a bit of code that shows what you would like to see working differently?

As possibly a second issue, I think you are saying that the comparer in Using is being ignored. Again, an example we can work from would help.

[NUnitTester]

First issue: There is no possible way that I can add a IComparable to a class because it is from a library or not useful in productive case. So I wrote a Comparer for NUnit-Test only wanting to be used in Range-Asserts.

public class MyVersionClass /* : IComparable */ { ... }

MyVersionClass expectedObject = ...;

Assert.That(myObject, Is.InRange(expectedObject, expectedObject) .Using(myComparer));
Error, does not compile, but
Assert.That(myObject, Is.EqualTo(expectedObject) .Using(myComparer));
does!

[NUnitTester]

Second issue: Look at the constructor of the RangeConstraint, then the error is obvious:

public RangeConstraint(IComparable from, IComparable to) : base((object) from, (object) to) { **if (this.comparer.Compare((object) from, (object) to) > 0) throw new ArgumentException("from must be less than to");** this.from = from; this.to = to; }
The Comparer ist called to check if from is not greater than to. It is not right because the comparer given by using does give other results. And of cause, see issue 1, the objects should not be comparable at all. It should also work only with a given comparer in using.

[CharliePoole]

@NUnitTester
First Issue: Does this work if you use Is.GreaterThanOrEqualTo(from).And.LessThanOrEqualTo(to)?

We should definitely handle these two expressions consistently.

Second issue:
So, we are using the default comparer before it's replaced. That's an error for sure.

[NUnitTester]

Assert.That(myObject, Is.GreaterThanOrEqualTo(from).And.LessThanOrEqualTo(to).Using(myComparer));
myObject is < than from. Passes Assert because LessThanOrEqualTo uses not the given Comparer, only GreaterThanOrEqualTo.

The correct way to write and working seems to be:
Assert.That(myObject, Is.GreaterThanOrEqualTo(from).Using(myComparer)).And.LessThanOrEqualTo(to).Using(myComparer));

[CharliePoole]

Yes, Using applies to each comparison separately due to the left-to-right processing of the expression. That's one of the main reasons for having a range constraint.

I think this definitely shows the problem as a bug. If the expanded expression works, the range expression is expected to work.

[JustinRChou]

Gave up on the default comparer.

Would it be possible to check if the user did use Using for objects that did not implement IComparable?

Or default it to a IComparer comparing on the ToString()?

[NUnitTester]

If Using is used, always the comparer given by using must be used. Only if there is no using at all, IComparable is used.
It is also a common case to give an other comparer for nunit as the implementation does by implementing IComparable.

In my eyes, the test, if from is smaller or equal tomust be done later, not in constructor at all.