NUnitEx : actual.Should().EqualTo(expected)

After this thread, I have begun a new project on GoogleCode: NUnitEx.

The intention of the project is to be a “base-line” of a possible API implementation for NUnit3.0. As me, Charlie Poole, think that  “to have the code available is different than few-words and with this project we can "test" the acceptance of a possible API based on .Net3.5” (the phrase is mine and Charlie simply said “great!”).

NUnitEx is working on-top of NUnit, so you can mix NUnit classic assertions (Assert.That(…)) with NUnitEx assertions.

The short story

The first problem was define which should be the entry point… exactly… Should(), Should().Be, ShouldBe(), Should().Not.Be, ShouldBe().Not, Should().Contains, Should().EqualTo(exepected).WithMessage(message), Should().EqualTo(exepected).Because(message) and so on. The decision I have taken, so far, is: make it less verbose as possible maintaining Should() as the entry point.

The second problem was how much complicated should be the implementation. I have studied some NUnit2.4 internals and then I have compared it with NUnit2.5… well… to be short, the decision I have taken is: make it less complicated as possible and use NUnit from a point more external as possible.

Highlight

NUnit assertions/constraints are generics and polymorphic; generics because you can apply the same to everything (or near to it), polymorphic because the same constraint may change its behavior depending on the System.Type of actual/expected. Using NUnitEx this is not ever possible.

Take a look to the follows classic assertions :

Assert.That(true, Is.Null);
Assert.That(new object(), Is.True);

You can’t write the same using NUnitEx simply because an System.Boolean can’t be null or an System.Object can’t be a System.Boolean (the intellisense is your friend).

State of the art

Commons, and more used, constraints are implemented and the framework is usable.

So far the code-coverage is 100%.

Before begin the full implementation, of all constraints, a refactoring is needed in order to manage a more deeper methods-chaining leaving all methods with, at most, one parameter.

The discussion over the API is open; feel free to express your opinion.

To run NUnitEx tests you need to download the last available release of NUnit-Gui (2.5.0) available here.

When the heavy work will be done I’m planning to open a branch to support NUnit2.4.8.

Examples

DateTime.Today.Should().LessThan(DateTime.Now);
(5.0).Should().EqualTo(5);
((uint)10).Should().GreaterThan((short)4);
5.Should().LessThan(10);
(23.0m).Should().LessThan(double.MaxValue);

int? negableInt = 10;
negableInt.Should().EqualTo(10);
5.Should().LessThan(negableInt);
11.Should().GreaterThan(negableInt);
negableInt.HasValue.Should().True();

"a".Should().EqualTo("a");
"a".Should().Not.Empty();
"a".Should().Not.Null();
"".Should().Empty();
"".Should().Not.EqualTo("a");
((string) null).Should().Null();

var ints = new[] {1, 2, 3};
ints.Should().SequenceEqualTo(ints);
ints.Should().Not.SequenceEqualTo(new[] { 3, 2, 1 });
ints.Should().Not.Null();
ints.Should().Not.Empty();
(new int[0]).Should().Empty();
((IEnumerable<int>) null).Should().Null();

var ints = new[] { 1, 2, 3 };
ints.Should().Contains(2);
ints.Should().Not.Contains(4);

Where find NUnitEx

The project is really fresh, bins and sources are available here.