+ With NFluent, you can also write checks like this:
+
+
+var persons = new List<Person>
+ {
+ new Person { Name = "Thomas", Age = 38 },
+ new Person { Name = "Achille", Age = 10, Nationality = Nationality.French },
+ new Person { Name = "Anton", Age = 7, Nationality = Nationality.French },
+ new Person { Name = "Arjun", Age = 7, Nationality = Nationality.Indian }
+ };
+
+Check.That(persons.Properties("Name")).ContainsExactly("Thomas", "Achille", "Anton", "Arjun");
+Check.That(persons.Properties("Age")).ContainsExactly(38, 10, 7, 7);
+Check.That(persons.Properties("Nationality")).ContainsExactly(Nationality.Unknown, Nationality.French, Nationality.French, Nationality.Indian);
+
+// more fluent than the following classical NUnit way, isn't it?
+// CollectionAssert.AreEquivalent(persons.Properties("Age"), new[] { 38, 10, 7, 7 });
+
+// it's maybe even more fluent than the java versions
+
+// FEST fluent assert v 2.x:
+// assertThat(extractProperty("name" , String.class).from(inn.getItems())).containsExactly("+5 Dexterity Vest", "Aged Brie", "Elixir of the Mongoose", "Sulfuras, Hand of Ragnaros", "Backstage passes to a TAFKAL80ETC concert", "Conjured Mana Cake");
+
+// FEST fluent assert v 1.x:
+// assertThat(inn.getItems()).onProperty("name").containsExactly("+5 Dexterity Vest", "Aged Brie", "Elixir of the Mongoose", "Sulfuras, Hand of Ragnaros", "Backstage passes to a TAFKAL80ETC concert", "Conjured Mana Cake");
+
+ Or like this:
+
+
+// Works also with lambda for exception checking
+Check.That(() => { thrownew InvalidOperationException(); }).Throws<InvalidOperationException>();
+
+// or execution duration checking
+Check.That(() => Thread.Sleep(30)).LastsLessThan(60, TimeUnit.Milliseconds);
+
NFluent is also extensible to your specific needs
@@ -249,20 +313,34 @@
We aim to release the most fluent .NET assertion lib ever ;-)
Indeed:
we think that writing a lambda expression within an check statement is not really a fluent experience (neither on a reading perspective).
-
we think that those other check libraries have not chosen the proper vocabulary (.Should().... why don't they choose Must instead?!?). And thus, you'd rather rely on a stronger semantic for your checks (i.e. NFluent's Check.That).
+
we think that those other check libraries have not chosen the proper vocabulary (.Should().... why don't they choose Must instead?!?). And thus, you'd rather rely on a stronger semantic for your checks (i.e. NFluent's Check.That).
Is the next statement fluent to write for you?!?
- new[] { 1, 2, 3 }.Should().Contain(item => item > 3, "at least {0} item should be larger than 3", 1);
+
+
+var myArray = new[] { 1, 2, 3 };
+
+myArray.Should().Contain(item => item > 3, "at least {0} item should be larger than 3", 1);
+
+ We don't think so, and we prefer the NFluent version:
+
+
+Check.That(myArray).IsGreaterThan(3);
+
+ Other example: are you happy to type new[] {...} as a method argument like does another famous "fluent" library?
- Are you happy to type new[] {...} as a method argument like this?!?
-
- ints.Should().Have.SameSequenceAs(new[] { 1, 2, 3 });
-
+
+
To Rui CARVALHO, for the nice NFluent logo he has designed.
To the mates that gave me ideas and feedbacks to make this lib as fluent as possible: Joel COSTIGLIOLA (former active contributor of Java FEST Assert, which now works on his AssertJ fork), Benoit LABAERE ...
To Omer RAVIV, which supports the NFluent project by offering us some free licenses for the nice OzCode debugging extension for Visual Studio.
+
To the awesome and truly addictive NCrunch, that really helps me in my day-to-day TDD.
To Jetbrains, which still creates some of the coolest tools for developers (whatever the language), and which supports our NFluent project by providing us some space within their teamcity code better instance (note: you can enter as guest).
+ You should follow what's gonna be delivered soon by the NFluent team... Cause based on Rui's reflexions, we decided to develop a NFluent plugin (whether a Visual Studio or R#).
+
This plugin should definitely revolutionize the way we TDD!