NFluent 2.2.0

This package has no dependencies.

## V 2.2.0

---------------

Flexible property and field based comparison is now available. Examples:

* Check.That(sut)**.Considering().Public.Properties**.IsEqualTo(expected);

* Check.That(sut)**.Considering().Public.Fields.And.Public.Properties**.IsEqualTo(expected);

* Check.That(sut)**.Considering().Public.Fields.Excluding("coordX", "child.address")**.IsEqualTo(expected);

Syntax is:

* Check.That(sut)**.Considering().(Public|NonPublic|All).(Fields.Properties)[.And.(Public|NonPublic|All).(Fields.Properties)][Excluding("fielda", "sub.fieldb")]**.IsEqualTo(expected);

* **Considering()** is supported by: _IsEqualTo(), IsNotEqualTo(), AsSameValueAs(), HasDifferentValueThan(), IsInstanceOf\<type\>()_ [checks if fields/properties are present],

_IsNotInstanceOf\<type\>()_,  _HasSameValueAs()_, _IsSameReferenceAs(), _IsDistinctFrom()_, _HasDifferentValueThan()_

### New feature(s)

* **Object**

* New check **IsInstanceOfType(Type type)** which is equivalent to *IsInstanceOf\<type\>()*, in a non generic form for parameterized tests.

* New check **IsNoInstanceOfType(Type type)** which is equivalent to *IsNotInstanceOf\<type\>()*, in a non generic form for parameterized tests.

* New check **InheritsFromType(Type type)** which is equivalent to *InheritsFrom\<type\>()*, in a non generic form for parameterized tests.

* **Enum**

- New check **HasFlag(xxx)** that checks if a flag is present in an enum value.

* **Code**

* New check **ThrowsType(Type type)** which is equivalent to *Throws\<type\>*, in a non generic form for parameterized tests.

### Changes

* Improved error messages for missing fields(and properties) for reflection based checks.

### Fixes

* Fix issue with overloaded member/properties for HasFieldswithSameValues(...) (#219)

### GitHub Issues

* #219, #218, #216, #215, #214, #121

## V 2.1.1

---------------

Bug fix(es):

* fix issue #215: null reference exception triggered by HasFields... on null interface fields.

V 2.1.0

--------------

New feature(s):

- Enumerable:

- Breaking change: equality for Enumerable is now content based (instead of reference based). See issue #209. You can revert adding: Check.EqualMode = EqualityMode.Equals in your test set up code

- New check ContainsOnlyElementsThatMatch which checks that all items verify a given predicate.

- New Check: IsOneOf checks if the value belongs to a list of authorized value. Check.That(sut).IsOneOf(a, b, c, ...) fails if sut is different from all valid values

- Improved error messages for IsEqualTo() on floating point types. Difference is displayed when small, suggestion to use IsCloseTo when difference is really small (#205).

- Initial support for dynamics (issue #85):

- Entry point is: Check.ThatDynamic()

- Available checks are: IsNotNull(), IsEqualTo(...), IsSameReferenceAs(...)

- And keyword is available

- Not keyword is available

- You can specify the maximum size (before truncate) for strings in error messages using **Check.StringTruncationLength** property

--------------

Bug Fixe(s):

- Fixed support of array types for HasFielsWithSameValues (issue #200)

- Fixed some stack overflow exceptions (issue #210).

- Fixed confusing examples about array item related checks in the readme

V 2.00

--------------

New feature(s):

* Support for NetStandard > 1.3

* Support for Net.Core > 1.0

* Compatible for Net > 2.0

* Built for: 2.0, 3.0, 3.5, 4.0, 4.5, NetStandard 1.3

* All: introduce: HasSameValueAs(x) that perform comparison using 'operator==' instead of 'Equals'.

* All: introduce: HasAValueDifferentFrom(x) that perform comparison using 'operator!=' instead of '!Equals'.

* Streams: introduce HasSameSequenceOfBytesAs() check.

* Numbers: introduce IsPositiveOrZero() check.

* Numbers: introduce IsNegativeOrZero() check.

* FloatingNumbers (float, double): introduce IsCloseTo(expected, within) check for estimated value.

* Exception: introduce the DueTo\<InnerException\> as an extension to Throws\<Exception\>. It verifies that the checked exception was triggered by a specific exception. This is done by scanning the 'innerException' chain until the expected type is identified. Further checking is done on the inner exception.

* Exception: introduce WithProperties( expression, expectedValue) to check the value of any exception members, thanks to a selector expression.

* IEnumerable: introduce HasElementAt(int index) which checks for an item as a specific index. Furthermore, this item can be checked as well thanks to 'Which'. E.g: Check.That(_collection).HasElementAt(3).Which.IsEqualTo("foo").

* IEnumerable: introduce HasFirstElement() which checks for the first item. Furthermore, this item can be checked as well thanks to 'Which'. E.g: Check.That(_collection).HasFirstElement().Which.IsEqualTo("foo").

* IEnumerable: introduce HasLastElement() which checks for the last item. Furthermore, this item can be checked as well thanks to 'Which'. E.g: Check.That(_collection).HasLastElement().Which.IsEqualTo("foo").

* IEnumerable: introduce HasOneElementOnly() which checks for the first and single item. Furthermore, this item can be checked as well thanks to 'Which'. E.g: Check.That(_collection).HasOneElementOnly().Which.IsEqualTo("foo").

* IEnumerable: introduce HasElementThatMatches( bool predicate()) which checks that an enumerable has at least on item matching the given predicate. You can use 'Which' to check further this item. E.g.: Check.That(_collection).HasItemThatMatches((_) => _.StartWith("foo")).Which.IsEqualTo("foobar").

* IDictionary\<K,V\>: now explicitely supported.

* IDictionary\<K,V\>: introduce ContainsEntry\<K, V\>(K key, V value) which checks that a dictionary contains a specific value for a given key.

* Hashtable: now explicitely supported.

--------------

Change(s):

* IEnumerable: improved description within error messages: partial dump around first difference for large sets

* IDictionnary: no longer supported. Hashtable is supported instead

* Numbers: introduce IsStrictlyPositive() as a substitute for IsPositive() which is now obsolete.

* Numbers: introduce IsStrictlyNegative() as a substitute for IsNegative() which is now obsolete.

* Numbers: introduce IsStrictlyGreaterThan() as a substitute for IsGreaterThan() which is now obsolete.

* Numbers: introduce IsStrictlyLessThan() as a substitute for IsLessThan() which is now obsolete.

* Floating Numbers: introduce IsCloseTo() to check if a number is close to another one.

* Check.ThatCode(...).Throws\<T\>() now requires T to be an exception. This restriction ensures only Exceptions are proposed in autocompletion.

* Improve error messages (consistency and relevance).

* Strings: generate specific error message using IsEqualTo() when the actual string is empty

* Strings: generate specific error message using IsEqualTo() when the expected string is empty

* Strings: provides part of string where first difference occurs even when strings have different lenghts

* Objects: IsSameReferenceAs supersede IsSameReferenceThan (now flagged as obsolete)

* Objects: Dump hascodes only when NFluent cannot highligth difference.

* Check.That(Action) can no longer be used (error, obsolete)

* Check.That(Func\<T\>) can no longer be used (error, obsolete)

* Simplify the way you can extend NFluent by adding your own checks. Now, you can call: var checker = ExtensibilityHelper.ExtractChecker(check);

at the beginning of your check extension method, and then rely on its ExecuteCheck() or BuildMessage() helper methods to do the job. Note: the Checker is part of the NFluent.Extensibility namespace.

* Reviewing of public elements: Some classes are no longer public. They should never have been in the first case.

* Signature of ILambdaExceptionCheck has been updated to refer the checked exception type (instead of RunTrace). This is a breaking change for edge cases, that will impact your extension method on exceptions, if any; it can also impact your tests if you use the explicit signature.

--------------

Bug Fixe(s):

* Fix the inversion between expected and actual error message for the .WithMessage checks on exception.

* Fix the issue with null value on Check.That(...).IsBefore(...)

* HasFieldsWithSameValues now recurse along the hierarchy class (Fix for #141)

* Fix stack overflow triggered by HasFieldsWithSameValues() on object with reference loop (#148)

* Properly escaped strings when generating error messages.

* GitHub issues: #124, #133, #141, #148, #153, #154, #156, #159, #164, #165, #167, #174, #177, #178, #179, #187