Order dependence of And and Or constraints should be documented

[chphe]

While playing around with the Constraint Assertion feature of NUnit, my team mates made the following remark.
When combining Null and GreaterThan (or similar constraint) the order of writing is critical when used with Or condition.

Take following examples:

[TestCase(10)]
[TestCase(null)]
public void ConstraintNUnitNull(int? i)
{
    Assert.That(i, Is.Null.Or.GreaterThan(9));
}

[TestCase(10)]
[TestCase(null, ExpectedException = typeof(ArgumentException))]
public void ConstraintNUnitNullFail(int? i)
{
    Assert.That(i, Is.GreaterThan(9).Or.Null);
}

From the perspective of fluent reading, both should work and behave the same. But in the second case, it throws an exception.
Technically I can understand why the exception is thrown, and I'm not sure this should be logged as a bug or that lazy evaluation should be documented.

I'm using NUnit Version 2.6.3.13283 and I also quickly tested the case when using Compound Constraints, it's the same...

[TestCase(10)]
[TestCase(null)]
public void ConstraintOperatorNUnitNull2(int? i)
{
    Assert.That(i, Is.Null | Is.GreaterThan(9));
}

[TestCase(10)]
[TestCase(null, ExpectedException = typeof(ArgumentException))]
public void ConstraintOperatorNUnitNull1(int? i)
{
    Assert.That(i, Is.GreaterThan(9) | Is.Null);
}

[rprouse]

Definitely a bug, thanks for the detailed report. I have marked it as status:confirm to make sure it is still happening in NUnit 3, although I suspect it is. I also set to priority low because I expect that this combination with a nullable int is probably fairly rare.

[CharliePoole]

Definitely still happening by design. The Or and And operators have always been evaluated from left to right with Or having precedence over And. We used to explain this somewhere but it may have been lost over time. We should definitely document it.

Additionally, although I understand why @chphe might have expected it to work differently, it seems not to have caused surprise to anyone since the feature was introduced with NUnit 2.4 in 2007.

[mikkelbu]

@nunit/framework-team I've updated the documentation to mention the evaluation order and the precedence of the Or and And operators. Please review https://github.com/nunit/docs/wiki/OrConstraint and https://github.com/nunit/docs/wiki/AndConstraint, and close this issue if the additions are sufficient 😄.

[ChrisMaddock]

Thanks for making the docs update Mikkel! I think your changes do a good job of recording the current behaviour.

Regarding whether this is something we should close as a docs issue, I'm less sure however. I understand the current functionality was written with intended to work in this way, however I would still consider it surprising behaviour - as the original poster did.

My gut feeling is also that it will require a very involved fix, and may not even be possible without a significant rewrite, but I'm not sure that's a reason to not consider this a change we want to make,.