TestSuite (Powerunit - Java Testing framework for JDK 1.8 0.1.1 API)

```
public interface TestSuite
```
This is the interface to be implemented by test class, in order to have access to the test DSL.
This interface is only used to provide the DSL capabilities for the test ; It is not used as a marker by the framework.
Several functionalities are provided here :
- Assertion capabilities (assertion on Object, Iterable, Function, Piece of code).
- Matchers to be used as end parameter of the assertion.
- before(Runnable...) to setup a before action.
- after(Runnable...) to setup a after action.
- mockitoRule() to setup mockito.
- systemPropertiesRule(String...) to restore properties system after test ; Several others method related to systemProperties exist.
- temporaryFolder() to support temporary folder.
- parametersMap(int, Function) to create Map function to be used on the stream to be provided by the @Parameters. Other variants of this method may exist.
Author:

borettim

Field Summary

Fields
Modifier and Type Field and Description

static TestSuite DSL
A static field that is a testsuite (to avoid implementing TestSuite in test, in the rare case when it may be required).

Fields
Modifier and Type	Field and Description
`static TestSuite`	`DSL` A static field that is a testsuite (to avoid implementing TestSuite in test, in the rare case when it may be required).

Method Summary

All Methods Instance Methods Default Methods
Modifier and Type	Method and Description
`default <T> java.util.function.Function<Object[],Object[]>`	`addFieldToEachEntry(T field)` Provide a way to add a field to each parameter line.
`default TestRule`	`after(Runnable... afters)` Build a after testrule.
`default <T> org.hamcrest.Matcher<T>`	`allOf(Iterable<org.hamcrest.Matcher<? super T>> matchers)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
`default <T> org.hamcrest.Matcher<T>`	`allOf(org.hamcrest.Matcher<? super T>... matchers)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
`default <T> org.hamcrest.Matcher<T>`	`allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
`default <T> org.hamcrest.Matcher<T>`	`allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
`default <T> org.hamcrest.Matcher<T>`	`allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
`default <T> org.hamcrest.Matcher<T>`	`allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth, org.hamcrest.Matcher<? super T> fifth)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
`default <T> org.hamcrest.Matcher<T>`	`allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth, org.hamcrest.Matcher<? super T> fifth, org.hamcrest.Matcher<? super T> sixth)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
`default <T> org.hamcrest.Matcher<T>`	`any(Class<T> type)` Creates a matcher that matches when the examined object is an instance of the specified `type`, as determined by calling the `Class.isInstance(Object)` method on that type, passing the the examined object.
`default <T> org.hamcrest.core.AnyOf<T>`	`anyOf(Iterable<org.hamcrest.Matcher<? super T>> matchers)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
`default <T> org.hamcrest.core.AnyOf<T>`	`anyOf(org.hamcrest.Matcher<? super T>... matchers)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
`default <T> org.hamcrest.core.AnyOf<T>`	`anyOf(org.hamcrest.Matcher<T> first, org.hamcrest.Matcher<? super T> second)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
`default <T> org.hamcrest.core.AnyOf<T>`	`anyOf(org.hamcrest.Matcher<T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
`default <T> org.hamcrest.core.AnyOf<T>`	`anyOf(org.hamcrest.Matcher<T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
`default <T> org.hamcrest.core.AnyOf<T>`	`anyOf(org.hamcrest.Matcher<T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth, org.hamcrest.Matcher<? super T> fifth)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
`default <T> org.hamcrest.core.AnyOf<T>`	`anyOf(org.hamcrest.Matcher<T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth, org.hamcrest.Matcher<? super T> fifth, org.hamcrest.Matcher<? super T> sixth)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
`default org.hamcrest.Matcher<Object>`	`anything()` Creates a matcher that always matches, regardless of the examined object.
`default org.hamcrest.Matcher<Object>`	`anything(String description)` Creates a matcher that always matches, regardless of the examined object, but describes itself with the specified `String`.
`default <T> org.hamcrest.collection.IsArray<T>`	`array(org.hamcrest.Matcher<? super T>... elementMatchers)` Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
`default <E> org.hamcrest.Matcher<E[]>`	`arrayContaining(E... items)` Creates a matcher for arrays that matcheswhen each item in the examined array is logically equal to the corresponding item in the specified items.
`default <E> org.hamcrest.Matcher<E[]>`	`arrayContaining(List<org.hamcrest.Matcher<? super E>> itemMatchers)` Creates a matcher for arrays that matches when each item in the examined array satisfies the corresponding matcher in the specified list of matchers.
`default <E> org.hamcrest.Matcher<E[]>`	`arrayContaining(org.hamcrest.Matcher<? super E>... itemMatchers)` Creates a matcher for arrays that matches when each item in the examined array satisfies the corresponding matcher in the specified matchers.
`default <E> org.hamcrest.Matcher<E[]>`	`arrayContainingInAnyOrder(Collection<org.hamcrest.Matcher<? super E>> itemMatchers)` Creates an order agnostic matcher for arrays that matches when each item in the examined array satisfies one matcher anywhere in the specified collection of matchers.
`default <E> org.hamcrest.Matcher<E[]>`	`arrayContainingInAnyOrder(E... items)` Creates an order agnostic matcher for arrays that matches when each item in the examined array is logically equal to one item anywhere in the specified items.
`default <E> org.hamcrest.Matcher<E[]>`	`arrayContainingInAnyOrder(org.hamcrest.Matcher<? super E>... itemMatchers)` Creates an order agnostic matcher for arrays that matches when each item in the examined array satisfies one matcher anywhere in the specified matchers.
`default <E> org.hamcrest.Matcher<E[]>`	`arrayWithSize(int size)` Creates a matcher for arrays that matches when the `length` of the array equals the specified `size`.
`default <E> org.hamcrest.Matcher<E[]>`	`arrayWithSize(org.hamcrest.Matcher<? super Integer> sizeMatcher)` Creates a matcher for arrays that matches when the `length` of the array satisfies the specified matcher.
`default AssertThatString`	`assertThat(String obj)` Assert the value of a String.
`default AssertThatString`	`assertThat(String msg, String obj)` Assert the value of a String.
`default <T> AssertThatObject<T>`	`assertThat(String msg, T obj)` Assert the value of an object.
`default <T> AssertThatObject<T>`	`assertThat(T obj)` Assert the value of an object.
`default <T,U,R> AssertThatObject<R>`	`assertThatBiFunction(java.util.function.BiFunction<T,U,R> function, T input1, U input2)` Assert on a bifunction.
`default <T,U,R> AssertThatObject<R>`	`assertThatBiFunction(String msg, java.util.function.BiFunction<T,U,R> function, T input1, U input2)` Assert on a bifunction.
`default <T,R> AssertThatObject<R>`	`assertThatFunction(java.util.function.Function<T,R> function, T input)` Assert on a function.
`default <T,R> AssertThatObject<R>`	`assertThatFunction(String msg, java.util.function.Function<T,R> function, T input)` Assert on a function.
`default <T> AssertThatIterable<T>`	`assertThatIterable(Iterable<T> obj)` Assert on an iterable object.
`default <T> AssertThatIterable<T>`	`assertThatIterable(String msg, Iterable<T> obj)` Assert on an iterable object.
`default <T extends Throwable> AssertThatException<T>`	`assertWhen(Statement<?,T> underTest)` Assert that a statement (a piece of code) throw an exception.
`default <P,T extends Throwable> AssertThatException<T>`	`assertWhen(Statement<P,T> underTest, P param)` Assert that a statement (a piece of code) throw an exception.
`default <T extends Throwable> AssertThatException<T>`	`assertWhen(String msg, Statement<?,T> underTest)` Assert that a statement (a piece of code) throw an exception.
`default <P,T extends Throwable> AssertThatException<T>`	`assertWhen(String msg, Statement<P,T> underTest, P param)` Assert that a statement (a piece of code) throw an exception.
`default AssertThatString`	`assumeThat(String obj)` Assume the value of a String.
`default AssertThatString`	`assumeThat(String msg, String obj)` Assume the value of a String.
`default <T> AssertThatObject<T>`	`assumeThat(String msg, T obj)` Assume the value of an object.
`default <T> AssertThatObject<T>`	`assumeThat(T obj)` Assume the value of an object.
`default <T,U,R> AssertThatObject<R>`	`assumeThatBiFunction(java.util.function.BiFunction<T,U,R> function, T input1, U input2)` Assume on a bifunction.
`default <T,U,R> AssertThatObject<R>`	`assumeThatBiFunction(String msg, java.util.function.BiFunction<T,U,R> function, T input1, U input2)` Assume on a bifunction.
`default <T,R> AssertThatObject<R>`	`assumeThatFunction(java.util.function.Function<T,R> function, T input)` Assume on a function.
`default <T,R> AssertThatObject<R>`	`assumeThatFunction(String msg, java.util.function.Function<T,R> function, T input)` Assume on a function.
`default <T> AssertThatIterable<T>`	`assumeThatIterable(Iterable<T> obj)` Assume on an iterable object.
`default <T> AssertThatIterable<T>`	`assumeThatIterable(String msg, Iterable<T> obj)` Assume on an iterable object.
`default <T extends Throwable> AssertThatException<T>`	`assumeWhen(Statement<?,T> underTest)` Assume that a statement (a piece of code) throw an exception.
`default <P,T extends Throwable> AssertThatException<T>`	`assumeWhen(Statement<P,T> underTest, P param)` Assume that a statement (a piece of code) throw an exception.
`default <T extends Throwable> AssertThatException<T>`	`assumeWhen(String msg, Statement<?,T> underTest)` Assume that a statement (a piece of code) throw an exception.
`default <P,T extends Throwable> AssertThatException<T>`	`assumeWhen(String msg, Statement<P,T> underTest, P param)` Assume that a statement (a piece of code) throw an exception.
`default TestRule`	`before(Runnable... befores)` Build a before testrule.
`default <LHS> org.hamcrest.core.CombinableMatcher.CombinableBothMatcher<LHS>`	`both(org.hamcrest.Matcher<? super LHS> matcher)` Creates a matcher that matches when both of the specified matchers match the examined object.
`default org.hamcrest.Matcher<BigDecimal>`	`closeTo(BigDecimal operand, BigDecimal error)` Creates a matcher of `BigDecimal`s that matches when an examined BigDecimal is equal to the specified `operand`, within a range of +/- `error`.
`default org.hamcrest.Matcher<Double>`	`closeTo(double operand, double error)` Creates a matcher of `Double`s that matches when an examined double is equal to the specified `operand`, within a range of +/- `error`.
`default <T extends Comparable<T>> org.hamcrest.Matcher<T>`	`comparesEqualTo(T value)` Creates a matcher of `Comparable` object that matches when the examined object is equal to the specified value, as reported by the `compareTo` method of the examined object.
`default <E> org.hamcrest.Matcher<Iterable<? extends E>>`	`contains(E... items)` Creates a matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields a series of items, each logically equal to the corresponding item in the specified items.
`default <E> org.hamcrest.Matcher<Iterable<? extends E>>`	`contains(List<org.hamcrest.Matcher<? super E>> itemMatchers)` Creates a matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields a series of items, each satisfying the corresponding matcher in the specified list of matchers.
`default <E> org.hamcrest.Matcher<Iterable<? extends E>>`	`contains(org.hamcrest.Matcher<? super E>... itemMatchers)` Creates a matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields a series of items, each satisfying the corresponding matcher in the specified matchers.
`default <E> org.hamcrest.Matcher<Iterable<? extends E>>`	`contains(org.hamcrest.Matcher<? super E> itemMatcher)` Creates a matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields a single item that satisfies the specified matcher.
`default <T> org.hamcrest.Matcher<Iterable<? extends T>>`	`containsInAnyOrder(Collection<org.hamcrest.Matcher<? super T>> itemMatchers)` Creates an order agnostic matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields a series of items, each satisfying one matcher anywhere in the specified collection of matchers.
`default <T> org.hamcrest.Matcher<Iterable<? extends T>>`	`containsInAnyOrder(org.hamcrest.Matcher<? super T>... itemMatchers)` Creates an order agnostic matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields a series of items, each satisfying one matcher anywhere in the specified matchers.
`default <T> org.hamcrest.Matcher<Iterable<? extends T>>`	`containsInAnyOrder(T... items)` Creates an order agnostic matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields a series of items, each logically equal to one item anywhere in the specified items.
`default org.hamcrest.Matcher<String>`	`containsString(String substring)` Creates a matcher that matches if the examined `String` contains the specified `String` anywhere.
`default <T> org.hamcrest.Matcher<T>`	`describedAs(String description, org.hamcrest.Matcher<T> matcher, Object... values)` Wraps an existing matcher, overriding its description with that specified.
`default <LHS> org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher<LHS>`	`either(org.hamcrest.Matcher<? super LHS> matcher)` Creates a matcher that matches when either of the specified matchers match the examined object.
`default <E> org.hamcrest.Matcher<Collection<? extends E>>`	`empty()` Creates a matcher for `Collection`s matching examined collections whose `isEmpty` method returns `true`.
`default <E> org.hamcrest.Matcher<E[]>`	`emptyArray()` Creates a matcher for arrays that matches when the `length` of the array is zero.
`default <E> org.hamcrest.Matcher<Collection<E>>`	`emptyCollectionOf(Class<E> type)` Creates a matcher for `Collection`s matching examined collections whose `isEmpty` method returns `true`.
`default <E> org.hamcrest.Matcher<Iterable<? extends E>>`	`emptyIterable()` Creates a matcher for `Iterable`s matching examined iterables that yield no items.
`default <E> org.hamcrest.Matcher<Iterable<E>>`	`emptyIterableOf(Class<E> type)` Creates a matcher for `Iterable`s matching examined iterables that yield no items.
`default org.hamcrest.Matcher<String>`	`endsWith(String suffix)` Creates a matcher that matches if the examined `String` ends with the specified `String`.
`default <T> org.hamcrest.Matcher<T>`	`equalTo(T operand)` Creates a matcher that matches when the examined object is logically equal to the specified `operand`, as determined by calling the `Object.equals(java.lang.Object)` method on the examined object.
`default org.hamcrest.Matcher<String>`	`equalToIgnoringCase(String expectedString)` Creates a matcher of `String` that matches when the examined string is equal to the specified expectedString, ignoring case.
`default org.hamcrest.Matcher<String>`	`equalToIgnoringWhiteSpace(String expectedString)` Creates a matcher of `String` that matches when the examined string is equal to the specified expectedString, when whitespace differences are (mostly) ignored.
`default org.hamcrest.Matcher<EventObject>`	`eventFrom(Class<? extends EventObject> eventClass, Object source)` Creates a matcher of `EventObject` that matches any object derived from `eventClass` announced by `source`.
`default org.hamcrest.Matcher<EventObject>`	`eventFrom(Object source)` Creates a matcher of `EventObject` that matches any EventObject announced by `source`.
`default <U> org.hamcrest.Matcher<Iterable<U>>`	`everyItem(org.hamcrest.Matcher<U> itemMatcher)` Creates a matcher for `Iterable`s that only matches when a single pass over the examined `Iterable` yields items that are all matched by the specified `itemMatcher`.
`default org.hamcrest.Matcher<Throwable>`	`exceptionMessage(org.hamcrest.Matcher<? super String> matching)` Validate the message of an exception
`default org.hamcrest.Matcher<Throwable>`	`exceptionMessage(String message)` Validate the message of an exception
`default void`	`fail()` Always produce a failure.
`default void`	`fail(String msg)` Always produce a failure.
`default void`	`fail(String msg, Throwable innerError)` Always produce a failure.
`default org.hamcrest.Matcher<File>`	`fileCanExecute(boolean canExecute)` Validate that a file can execute.
`default org.hamcrest.Matcher<File>`	`fileCanExecute(org.hamcrest.Matcher<? super Boolean> matcher)` Validate that a file can execute.
`default org.hamcrest.Matcher<File>`	`fileCanRead(boolean canRead)` Validate that a file can read.
`default org.hamcrest.Matcher<File>`	`fileCanRead(org.hamcrest.Matcher<? super Boolean> matcher)` Validate that a file can read.
`default org.hamcrest.Matcher<File>`	`fileCanWrite(boolean canWrite)` Validate that a file can write.
`default org.hamcrest.Matcher<File>`	`fileCanWrite(org.hamcrest.Matcher<? super Boolean> matcher)` Validate that a file can write.
`default org.hamcrest.Matcher<File>`	`fileContains(org.hamcrest.Matcher<String[]> matcher)` Validate that a file contains something.
`default org.hamcrest.Matcher<File>`	`fileContains(String atLeastThisName)` Validate that a file contains some other file name.
`default org.hamcrest.Matcher<File>`	`fileExists(boolean exists)` Validate that a file exists.
`default org.hamcrest.Matcher<File>`	`fileExists(org.hamcrest.Matcher<? super Boolean> matcher)` Validate that a file exists.
`default org.hamcrest.Matcher<File>`	`fileIsAbsolute(boolean absolute)` Validate that a file is absolute.
`default org.hamcrest.Matcher<File>`	`fileIsAbsolute(org.hamcrest.Matcher<? super Boolean> matcher)` Validate that a file is absolute.
`default org.hamcrest.Matcher<File>`	`fileIsDirectory(boolean isDirectory)` Validate that a file is a directory.
`default org.hamcrest.Matcher<File>`	`fileIsDirectory(org.hamcrest.Matcher<? super Boolean> matcher)` Validate that a file is a directory.
`default org.hamcrest.Matcher<File>`	`fileNamed(org.hamcrest.Matcher<? super String> matcher)` Validate that a file has some name.
`default org.hamcrest.Matcher<File>`	`fileNamed(String name)` Validate that a file has some name.
`default <T extends Comparable<T>> org.hamcrest.Matcher<T>`	`greaterThan(T value)` Creates a matcher of `Comparable` object that matches when the examined object is greater than the specified value, as reported by the `compareTo` method of the examined object.
`default <T extends Comparable<T>> org.hamcrest.Matcher<T>`	`greaterThanOrEqualTo(T value)` Creates a matcher of `Comparable` object that matches when the examined object is greater than or equal to the specified value, as reported by the `compareTo` method of the examined object.
`default <K,V> org.hamcrest.Matcher<Map<? extends K,? extends V>>`	`hasEntry(K key, V value)` Creates a matcher for `Map`s matching when the examined `Map` contains at least one entry whose key equals the specified `key` and whose value equals the specified `value`.
`default <K,V> org.hamcrest.Matcher<Map<? extends K,? extends V>>`	`hasEntry(org.hamcrest.Matcher<? super K> keyMatcher, org.hamcrest.Matcher<? super V> valueMatcher)` Creates a matcher for `Map`s matching when the examined `Map` contains at least one entry whose key satisfies the specified `keyMatcher` and whose value satisfies the specified `valueMatcher`.
`default <T> org.hamcrest.Matcher<Iterable<? super T>>`	`hasItem(org.hamcrest.Matcher<? super T> itemMatcher)` Creates a matcher for `Iterable`s that only matches when a single pass over the examined `Iterable` yields at least one item that is matched by the specified `itemMatcher`.
`default <T> org.hamcrest.Matcher<Iterable<? super T>>`	`hasItem(T item)` Creates a matcher for `Iterable`s that only matches when a single pass over the examined `Iterable` yields at least one item that is equal to the specified `item`.
`default <T> org.hamcrest.Matcher<T[]>`	`hasItemInArray(org.hamcrest.Matcher<? super T> elementMatcher)` Creates a matcher for arrays that matches when the examined array contains at least one item that is matched by the specified `elementMatcher`.
`default <T> org.hamcrest.Matcher<T[]>`	`hasItemInArray(T element)` A shortcut to the frequently used `hasItemInArray(equalTo(x))` .
`default <T> org.hamcrest.Matcher<Iterable<T>>`	`hasItems(org.hamcrest.Matcher<? super T>... itemMatchers)` Creates a matcher for `Iterable`s that matches when consecutive passes over the examined `Iterable` yield at least one item that is matched by the corresponding matcher from the specified `itemMatchers`.
`default <T> org.hamcrest.Matcher<Iterable<T>>`	`hasItems(T... items)` Creates a matcher for `Iterable`s that matches when consecutive passes over the examined `Iterable` yield at least one item that is equal to the corresponding item from the specified `items`.
`default <K> org.hamcrest.Matcher<Map<? extends K,?>>`	`hasKey(K key)` Creates a matcher for `Map`s matching when the examined `Map` contains at least one key that is equal to the specified key.
`default <K> org.hamcrest.Matcher<Map<? extends K,?>>`	`hasKey(org.hamcrest.Matcher<? super K> keyMatcher)` Creates a matcher for `Map`s matching when the examined `Map` contains at least one key that satisfies the specified matcher.
`default <T> org.hamcrest.Matcher<T>`	`hasProperty(String propertyName)` Creates a matcher that matches when the examined object has a JavaBean property with the specified name.
`default <T> org.hamcrest.Matcher<T>`	`hasProperty(String propertyName, org.hamcrest.Matcher<?> valueMatcher)` Creates a matcher that matches when the examined object has a JavaBean property with the specified name whose value satisfies the specified matcher.
`default <E> org.hamcrest.Matcher<Collection<? extends E>>`	`hasSize(int size)` Creates a matcher for `Collection`s that matches when the `size()` method returns a value equal to the specified `size`.
`default <E> org.hamcrest.Matcher<Collection<? extends E>>`	`hasSize(org.hamcrest.Matcher<? super Integer> sizeMatcher)` Creates a matcher for `Collection`s that matches when the `size()` method returns a value that satisfies the specified matcher.
`default <T> org.hamcrest.Matcher<T>`	`hasToString(org.hamcrest.Matcher<? super String> toStringMatcher)` Creates a matcher that matches any examined object whose `toString` method returns a value that satisfies the specified matcher.
`default <T> org.hamcrest.Matcher<T>`	`hasToString(String expectedToString)` Creates a matcher that matches any examined object whose `toString` method returns a value equalTo the specified string.
`default <V> org.hamcrest.Matcher<Map<?,? extends V>>`	`hasValue(org.hamcrest.Matcher<? super V> valueMatcher)` Creates a matcher for `Map`s matching when the examined `Map` contains at least one value that satisfies the specified valueMatcher.
`default <V> org.hamcrest.Matcher<Map<?,? extends V>>`	`hasValue(V value)` Creates a matcher for `Map`s matching when the examined `Map` contains at least one value that is equal to the specified value.
`default org.hamcrest.Matcher<Node>`	`hasXPath(String xPath)` Creates a matcher of `Node`s that matches when the examined node contains a node at the specified `xPath`, with any content.
`default org.hamcrest.Matcher<Node>`	`hasXPath(String xPath, org.hamcrest.Matcher<String> valueMatcher)` Creates a matcher of `Node`s that matches when the examined node has a value at the specified `xPath` that satisfies the specified `valueMatcher`.
`default org.hamcrest.Matcher<Node>`	`hasXPath(String xPath, NamespaceContext namespaceContext)` Creates a matcher of `Node`s that matches when the examined node contains a node at the specified `xPath` within the specified namespace context, with any content.
`default org.hamcrest.Matcher<Node>`	`hasXPath(String xPath, NamespaceContext namespaceContext, org.hamcrest.Matcher<String> valueMatcher)` Creates a matcher of `Node`s that matches when the examined node has a value at the specified `xPath`, within the specified `namespaceContext`, that satisfies the specified `valueMatcher`.
`default <T> org.hamcrest.Matcher<T>`	`instanceOf(Class<?> type)` Creates a matcher that matches when the examined object is an instance of the specified `type`, as determined by calling the `Class.isInstance(Object)` method on that type, passing the the examined object.
`default <T> org.hamcrest.Matcher<T>`	`is(org.hamcrest.Matcher<T> matcher)` Decorates another Matcher, retaining its behaviour, but allowing tests to be slightly more expressive.
`default <T> org.hamcrest.Matcher<T>`	`is(T value)` A shortcut to the frequently used `is(equalTo(x))`.
`default <T> org.hamcrest.Matcher<T>`	`isA(Class<T> type)` A shortcut to the frequently used `is(instanceOf(SomeClass.class))`.
`default org.hamcrest.Matcher<String>`	`isEmptyOrNullString()` Creates a matcher of `String` that matches when the examined string is `null`, or has zero length.
`default org.hamcrest.Matcher<String>`	`isEmptyString()` Creates a matcher of `String` that matches when the examined string has zero length.
`default <T> org.hamcrest.Matcher<T>`	`isIn(Collection<T> collection)` Creates a matcher that matches when the examined object is found within the specified collection.
`default <T> org.hamcrest.Matcher<T>`	`isIn(T[] param1)`
`default <T> org.hamcrest.Matcher<T>`	`isOneOf(T... elements)` Creates a matcher that matches when the examined object is equal to one of the specified elements.
`default <E> org.hamcrest.Matcher<Iterable<E>>`	`iterableWithSize(int size)` Creates a matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields an item count that is equal to the specified `size` argument.
`default <E> org.hamcrest.Matcher<Iterable<E>>`	`iterableWithSize(org.hamcrest.Matcher<? super Integer> sizeMatcher)` Creates a matcher for `Iterable`s that matches when a single pass over the examined `Iterable` yields an item count that satisfies the specified matcher.
`default <T extends Comparable<T>> org.hamcrest.Matcher<T>`	`lessThan(T value)` Creates a matcher of `Comparable` object that matches when the examined object is less than the specified value, as reported by the `compareTo` method of the examined object.
`default <T extends Comparable<T>> org.hamcrest.Matcher<T>`	`lessThanOrEqualTo(T value)` Creates a matcher of `Comparable` object that matches when the examined object is less than or equal to the specified value, as reported by the `compareTo` method of the examined object.
`default <T> java.util.function.Predicate<T>`	`matcherPredicate(org.hamcrest.Matcher<T> matcher)` Expose a matcher as a predicate.
`default org.hamcrest.Matcher<String>`	`matchesRegex(Pattern pattern)` Validate a string with a `Pattern`.
`default org.hamcrest.Matcher<String>`	`matchesRegex(String regex)` Validate a string with a regex.
`default TestRule`	`mockitoRule()` Create a rule to support mockito.
`default <T> org.hamcrest.Matcher<T>`	`not(org.hamcrest.Matcher<T> matcher)` Creates a matcher that wraps an existing matcher, but inverts the logic by which it will match.
`default <T> org.hamcrest.Matcher<T>`	`not(T value)` A shortcut to the frequently used `not(equalTo(x))`.
`default org.hamcrest.Matcher<Object>`	`notNullValue()` A shortcut to the frequently used `not(nullValue())`.
`default <T> org.hamcrest.Matcher<T>`	`notNullValue(Class<T> type)` A shortcut to the frequently used `not(nullValue(X.class)).`
`default org.hamcrest.Matcher<Object>`	`nullValue()` Creates a matcher that matches if examined object is `null`.
`default <T> org.hamcrest.Matcher<T>`	`nullValue(Class<T> type)` Creates a matcher that matches if examined object is `null`.
`default org.hamcrest.Matcher<OptionalDouble>`	`optionalDoubleIs(org.hamcrest.Matcher<? super Double> subMatcher)` Check that the passed optional is accepted by some matcher.
`default org.hamcrest.Matcher<OptionalDouble>`	`optionalDoubleIsNotPresent()` Check that the passed optional is not present.
`default org.hamcrest.Matcher<OptionalDouble>`	`optionalDoubleIsPresent()` Check that the passed optional is present.
`default org.hamcrest.Matcher<OptionalInt>`	`optionalIntIs(Integer target)` Check that the passed optional is some target value.
`default org.hamcrest.Matcher<OptionalInt>`	`optionalIntIs(org.hamcrest.Matcher<? super Integer> subMatcher)` Check that the passed optional is accepted by some matcher.
`default org.hamcrest.Matcher<OptionalInt>`	`optionalIntIsNotPresent()` Check that the passed optional is not present.
`default org.hamcrest.Matcher<OptionalInt>`	`optionalIntIsPresent()` Check that the passed optional is present.
`default <T> org.hamcrest.Matcher<Optional<? super T>>`	`optionalIs(org.hamcrest.Matcher<? super T> subMatcher)` Check that the passed optional is accepted by some matcher.
`default <T> org.hamcrest.Matcher<Optional<? super T>>`	`optionalIs(T target)` Check that the passed optional is some target value.
`default <T> org.hamcrest.Matcher<Optional<T>>`	`optionalIsNotPresent()` Check that the passed optional is not present.
`default <T> org.hamcrest.Matcher<Optional<T>>`	`optionalIsPresent()` Check that the passed optional is present.
`default org.hamcrest.Matcher<OptionalLong>`	`optionalLongIs(Long target)` Check that the passed optional is some target value.
`default org.hamcrest.Matcher<OptionalLong>`	`optionalLongIs(org.hamcrest.Matcher<? super Long> subMatcher)` Check that the passed optional is accepted by some matcher.
`default org.hamcrest.Matcher<OptionalLong>`	`optionalLongIsNotPresent()` Check that the passed optional is not present.
`default org.hamcrest.Matcher<OptionalLong>`	`optionalLongIsPresent()` Check that the passed optional is present.
`default java.util.function.Predicate<Object[]>`	`parametersFilterUsingMatcher(org.hamcrest.Matcher<Object[]> matcher)` Provide a filter for stream parameters, to keep only parameters accepted by a matcher.
`default <T,R> StreamParametersMapFunction<T>`	`parametersMap(int idx, java.util.function.Function<T,R> mapFunction)` Start building a Parameter Mapper function, with an initial converter.
`default org.hamcrest.Matcher<Path>`	`pathMatchedAsFile(org.hamcrest.Matcher<? super File> matcher)` This is a special matcher that apply the toFile() method to the in matching path, and then apply the specified matcher.
`default <T> org.hamcrest.Matcher<T>`	`sameInstance(T target)` Creates a matcher that matches only when the examined object is the same instance as the specified target object.
`default <T> org.hamcrest.Matcher<T>`	`samePropertyValuesAs(T expectedBean)` Creates a matcher that matches when the examined object has values for all of its JavaBean properties that are equal to the corresponding values of the specified bean.
`default void`	`skip()` Always produce a skip.
`default void`	`skip(String msg)` Always produce a skip.
`default org.hamcrest.Matcher<String>`	`startsWith(String prefix)` Creates a matcher that matches if the examined `String` starts with the specified `String`.
`default org.hamcrest.Matcher<String>`	`stringContainsInOrder(Iterable<String> substrings)` Creates a matcher of `String` that matches when the examined string contains all of the specified substrings, regardless of the order of their appearance.
`default StreamParametersMapFunction<String>`	`stringToParameterMap(Class<?> testClass)` Start building a Parameter Mapper function, assuming that the input are String, and using the type of the `@Parameter` field.
`default TestRule`	`systemPropertiesRule(String... propertiesName)` Create a rule to restore some system properties after the test
`default TestRule`	`systemProperty(String propertyName, String propertyValue)` Set a property before the run and ensure correct restore.
`default TestRule`	`systemProperty(String propertyName, java.util.function.Supplier<String> propertyValue)` Set a property before the run and ensure correct restore.
`default TemporaryFolder`	`temporaryFolder()` Produces a new rule for the temporary folder.
`default TemporaryFolder.TemporaryFolderBuilder`	`temporaryFolderBuilder()` Produces a new rule builder for the temporary folder.
`default <T> org.hamcrest.Matcher<T>`	`theInstance(T target)` Creates a matcher that matches only when the examined object is the same instance as the specified target object.
`default <T> org.hamcrest.Matcher<Class<?>>`	`typeCompatibleWith(Class<T> baseType)` Creates a matcher of `Class` that matches when the specified baseType is assignable from the examined class.

- Field Detail
  - DSL
```
static final TestSuite DSL
```
    A static field that is a testsuite (to avoid implementing TestSuite in test, in the rare case when it may be required).
    The main use case is to access the stream functionnalities from a @Parameters annotated method, has this method must be static.
- Method Detail
  - before
```
default TestRule before(Runnable... befores)
```
    Build a before testrule.
    The passed runnable will be used before each test. The exact location of the execution is depending on where this used on the testRule chain.
    In the much simple case (just one method to be executed before each test), the syntax is :
```
 @Rule
 public TestRule rule = before(this::beforeMethodName);
 
```
    Parameters:
    
    befores - the befores
    
    Returns:
    
    the rule chain.
    
    See Also:
    
    Rule
  - after
```
default TestRule after(Runnable... afters)
```
    Build a after testrule.
    The passed runnable will be used after each test. The exact location of the execution is depending on where this used on the testRule chain.
    In the much simple case (just one method to be executed after each test), the syntax is :
```
 @Rule
 public TestRule rule = after(this::afterMethodName);
 
```
    Parameters:
    
    afters - the afters
    
    Returns:
    
    the rule chain.
    
    See Also:
    
    Rule
  - mockitoRule
```
default TestRule mockitoRule()
```
    Create a rule to support mockito.
    This provide a way to setup Mockito before each test.
    
    Returns:
    
    the rule chain.
    
    See Also:
    
    Rule
  - temporaryFolder
```
default TemporaryFolder temporaryFolder()
```
    Produces a new rule for the temporary folder.
    As the TemporaryFolder rule provides several methods that are required for the test, except in the case when only this rule is required, a direct usage in the rule DSL is not adapted. For instance, assuming that it is required to mix a before and the TemporaryFolder rule, the code will look like :
```
 private TemporaryFolder temporary = temporaryFolder();
 
 @Rule
 public TestRule rule = before(this::beforeMethodName).around(temporary);
 
```
    This is required to ensure that the method of the TemporaryFolder object can be used (using the field named temporary).
    Returns:
    
    the temporary folder rule.
    
    See Also:
    
    Rule
  - temporaryFolderBuilder
```
default TemporaryFolder.TemporaryFolderBuilder temporaryFolderBuilder()
```
    Produces a new rule builder for the temporary folder.
    As the TemporaryFolder rule provides several methods that are required for the test, except in the case when only this rule is required, a direct usage in the rule DSL is not adapted. For instance, assuming that it is required to mix a before and the TemporaryFolder rule, the code will look like :
```
 private TemporaryFolder temporary = temporaryFolderBuilder().build();
 
 @Rule
 public TestRule rule = before(this::beforeMethodName).around(temporary);
 
```
    This is required to ensure that the method of the TemporaryFolder object can be used (using the field named temporary).
    The builder provide several capabilities to create initial folder structure at the same time than the temporary folder itself.
    Returns:
    
    the temporary folder rule builder.
    
    See Also:
    
    Rule
  - systemPropertiesRule
```
default TestRule systemPropertiesRule(String... propertiesName)
```
    Create a rule to restore some system properties after the test
    
    Parameters:
    
    propertiesName - the properties to be restored
    
    Returns:
    
    the rule chain.
    
    See Also:
    
    Rule
  - systemProperty
```
default TestRule systemProperty(String propertyName,
                                java.util.function.Supplier<String> propertyValue)
```
    Set a property before the run and ensure correct restore.
    
    Parameters:
    
    propertyName - the name of the property
    
    propertyValue - the value of the property
    
    Returns:
    
    the rule chain.
    
    See Also:
    
    Rule
  - systemProperty
```
default TestRule systemProperty(String propertyName,
                                String propertyValue)
```
    Set a property before the run and ensure correct restore.
    
    Parameters:
    
    propertyName - the name of the property
    
    propertyValue - the value of the property
    
    Returns:
    
    the rule chain.
    
    See Also:
    
    Rule
  - parametersMap
```
default <T,R> StreamParametersMapFunction<T> parametersMap(int idx,
                                                           java.util.function.Function<T,R> mapFunction)
```
    Start building a Parameter Mapper function, with an initial converter.
    Not specified index are considered transformed by identity function.
    
    Type Parameters:
    
    T - The input type for the function
    
    R - the result type for the function
    
    Parameters:
    
    idx - The parameter index
    
    mapFunction - the function to be applied
    
    Returns:
    
    the function on the parameter array
  - stringToParameterMap
```
default StreamParametersMapFunction<String> stringToParameterMap(Class<?> testClass)
```
    Start building a Parameter Mapper function, assuming that the input are String, and using the type of the @Parameter field.
    Fields not supported will not be mapped and must be handled manually, using andMap method to avoid any unexpected error.
    The goal of this method is to provide a way to receive so generic parameter and not having to care about typing. Let's take for example the following use case :
    - As an input for the test parameters, a CSV file is used. In this case, a framework like OpenCSV can be used to load all the parameters, but they are all String.
    - On the produced stream, the map method can be used to transform the received data into another format. Here, using the result of this method as parameter of the map method will ensure the transformation of the String to the right type, for simple type.
    - For undetected field type, it is possible to use the method andMap (on the returned object of this method), to add manual transformation.
    In this context, as the @Parameters annotated method must be static, access to this method can be done using DSL. prefix.
    Parameters:
    
    testClass - the testClass, as this method is to be used in static mode.
    
    Returns:
    
    the function on the parameter array
    
    See Also:
    
    Supported automated conversion
  - addFieldToEachEntry
```
default <T> java.util.function.Function<Object[],Object[]> addFieldToEachEntry(T field)
```
    Provide a way to add a field to each parameter line.
    
    Type Parameters:
    
    T - The object type to be added.
    
    Parameters:
    
    field - The field to be added.
    
    Returns:
    
    the function that can be used on the stream ( Stream.map(Function)).
    
    Since:
    
    0.1.0
  - parametersFilterUsingMatcher
```
default java.util.function.Predicate<Object[]> parametersFilterUsingMatcher(org.hamcrest.Matcher<Object[]> matcher)
```
    Provide a filter for stream parameters, to keep only parameters accepted by a matcher.
    
    Parameters:
    
    matcher - the matcher
    
    Returns:
    
    the stream filter
  - matcherPredicate
```
default <T> java.util.function.Predicate<T> matcherPredicate(org.hamcrest.Matcher<T> matcher)
```
    Expose a matcher as a predicate.
    
    Type Parameters:
    
    T - The target object type
    
    Parameters:
    
    matcher - the matcher.
    
    Returns:
    
    the predicate
  - assertThat
```
default <T> AssertThatObject<T> assertThat(T obj)
```
    Assert the value of an object.
    For instance
```
 assertThat(myObject).is(myOtherObject);
 
```
    This will check that myObject is myOtherObject (using the equalTo Hamcrest matcher).
    Type Parameters:
    
    T - the object type.
    
    Parameters:
    
    obj - the object
    
    Returns:
    
    the assert DSL on this object
  - assertThat
```
default <T> AssertThatObject<T> assertThat(String msg,
                                           T obj)
```
    Assert the value of an object.
    For instance
```
 assertThat("msg", myObject).is(myOtherObject);
 
```
    This will check that myObject is myOtherObject (using the equalTo Hamcrest matcher).
    Type Parameters:
    
    T - the object type.
    
    Parameters:
    
    msg - a message
    
    obj - the object
    
    Returns:
    
    the assert DSL on this object
  - assertThat
```
default AssertThatString assertThat(String obj)
```
    Assert the value of a String.
    For instance
```
 assertThat(myString).is("");
 
```
    This will check that myString is "" (using the equalTo Hamcrest matcher).
    Parameters:
    
    obj - the String
    
    Returns:
    
    the assert DSL on this object
  - assertThat
```
default AssertThatString assertThat(String msg,
                                    String obj)
```
    Assert the value of a String.
    For instance
```
 assertThat("msg", myString).is("");
 
```
    This will check that myString is "" (using the equalTo Hamcrest matcher).
    Parameters:
    
    msg - a message
    
    obj - the String
    
    Returns:
    
    the assert DSL on this object
  - assertThatIterable
```
default <T> AssertThatIterable<T> assertThatIterable(Iterable<T> obj)
```
    Assert on an iterable object.
    For instance
```
 assertThatIterable(myIterable).hasSize(0);
 
```
    This will check that myIterable has a size of 0.
    Type Parameters:
    
    T - the element type.
    
    Parameters:
    
    obj - the object (Iterable)
    
    Returns:
    
    the assert DSL on this iterable
  - assertThatIterable
```
default <T> AssertThatIterable<T> assertThatIterable(String msg,
                                                     Iterable<T> obj)
```
    Assert on an iterable object.
    For instance
```
 assertThatIterable("msg", myIterable).hasSize(0);
 
```
    This will check that myIterable has a size of 0.
    Type Parameters:
    
    T - the element type.
    
    Parameters:
    
    msg - a message
    
    obj - the object (Iterable)
    
    Returns:
    
    the assert DSL on this iterable
  - assertThatFunction
```
default <T,R> AssertThatObject<R> assertThatFunction(java.util.function.Function<T,R> function,
                                                     T input)
```
    Assert on a function.
    The purpose of this variant of assertThat provides a way to apply a function on some input and to check the result.
    For instance
```
 assertThatFunction((a) -> a + "x", "b").is("bx")
 
```
    This will pass the b string to the passed function (which add a x add the end of the string and then it will check that this string is bx (which is the case).
    Type Parameters:
    
    T - the object type of the input of the function
    
    R - the object type of the result
    
    Parameters:
    
    function - the function
    
    input - the input to the function
    
    Returns:
    
    then assert DSL on the result of the function
  - assertThatFunction
```
default <T,R> AssertThatObject<R> assertThatFunction(String msg,
                                                     java.util.function.Function<T,R> function,
                                                     T input)
```
    Assert on a function.
    The purpose of this variant of assertThat provides a way to apply a function on some input and to check the result.
    For instance
```
 assertThatFunction("msg", (a) -> a + "x", "b").is("bx")
 
```
    This will pass the b string to the passed function (which add a x add the end of the string and then it will check that this string is bx (which is the case).
    Type Parameters:
    
    T - the object type of the input of the function
    
    R - the object type of the result
    
    Parameters:
    
    msg - a message
    
    function - the function
    
    input - the input to the function
    
    Returns:
    
    then assert DSL on the result of the function
  - assertThatBiFunction
```
default <T,U,R> AssertThatObject<R> assertThatBiFunction(java.util.function.BiFunction<T,U,R> function,
                                                         T input1,
                                                         U input2)
```
    Assert on a bifunction.
    The purpose of this variant of assertThat provides a way to apply a bifunction on some input and to check the result.
    For instance
```
 assertThatBiFunction((a, b) -> a + b, "a", "b").is("ab")
 
```
    This will pass the b string to the passed function (which add a x add the end of the string and then it will check that this string is bx (which is the case).
    Type Parameters:
    
    T - the object type of the first input of the function
    
    U - the object type fo the second input of the function
    
    R - the object type of the result
    
    Parameters:
    
    function - the function
    
    input1 - the first input to the function
    
    input2 - the second input to the function
    
    Returns:
    
    then assert DSL on the result of the bifunction
  - assertThatBiFunction
```
default <T,U,R> AssertThatObject<R> assertThatBiFunction(String msg,
                                                         java.util.function.BiFunction<T,U,R> function,
                                                         T input1,
                                                         U input2)
```
    Assert on a bifunction.
    The purpose of this variant of assertThat provides a way to apply a bifunction on some input and to check the result.
    For instance
```
 assertThatBiFunction((a, b) -> a + b, "a", "b").is("ab")
 
```
    This will pass the b string to the passed function (which add a x add the end of the string and then it will check that this string is bx (which is the case).
    Type Parameters:
    
    T - the object type of the first input of the function
    
    U - the object type fo the second input of the function
    
    R - the object type of the result
    
    Parameters:
    
    msg - a message
    
    function - the function
    
    input1 - the first input to the function
    
    input2 - the second input to the function
    
    Returns:
    
    then assert DSL on the result of the bifunction
  - assertWhen
```
default <T extends Throwable> AssertThatException<T> assertWhen(Statement<?,T> underTest)
```
    Assert that a statement (a piece of code) throw an exception.
    The goal of assertWhen is to provide a way to validate that an exception is thrown.
    For instance
```
 assertWhen((p) -> {
     throw new Throwable("test");
 }).throwException(exceptionMessage("test"));
 
```
    Will run a piece of code that always thrown an exception and then validate that the message of the exception is test.
    Type Parameters:
    
    T - the exception type
    
    Parameters:
    
    underTest - the Statement (p)->{}
    
    Returns:
    
    the assert DSL on the exception
  - assertWhen
```
default <P,T extends Throwable> AssertThatException<T> assertWhen(Statement<P,T> underTest,
                                                                  P param)
```
    Assert that a statement (a piece of code) throw an exception.
    The goal of assertWhen is to provide a way to validate that an exception is thrown.
    For instance
```
 assertWhen((p) -> {
     throw new Throwable("test");
 }, null).throwException(exceptionMessage("test"));
 
```
    Will run a piece of code, passing null as parameter, that always thrown an exception and then validate that the message of the exception is test.
    Type Parameters:
    
    P - the type of the parameter
    
    T - the exception type
    
    Parameters:
    
    underTest - the Statement (p)->{}
    
    param - the parameter for the statement underTest
    
    Returns:
    
    the assert DSL on the exception
  - assertWhen
```
default <T extends Throwable> AssertThatException<T> assertWhen(String msg,
                                                                Statement<?,T> underTest)
```
    Assert that a statement (a piece of code) throw an exception.
    The goal of assertWhen is to provide a way to validate that an exception is thrown.
    For instance
```
 assertWhen("msg", (p) -> {
     throw new Throwable("test");
 }).throwException(exceptionMessage("test"));
 
```
    Will run a piece of code that always thrown an exception and then validate that the message of the exception is test.
    Type Parameters:
    
    T - the exception type
    
    Parameters:
    
    msg - a message
    
    underTest - the statement (p)->{}
    
    Returns:
    
    the assert DSL on the exception
  - assertWhen
```
default <P,T extends Throwable> AssertThatException<T> assertWhen(String msg,
                                                                  Statement<P,T> underTest,
                                                                  P param)
```
    Assert that a statement (a piece of code) throw an exception.
    The goal of assertWhen is to provide a way to validate that an exception is thrown.
    For instance
```
 assertWhen("msg", (p) -> {
     throw new Throwable("test");
 }, null).throwException(exceptionMessage("test"));
 
```
    Will run a piece of code, passing null as parameter, that always thrown an exception and then validate that the message of the exception is test.
    Type Parameters:
    
    P - the type of the parameter
    
    T - the exception type
    
    Parameters:
    
    msg - a message
    
    underTest - the statement (p)->{}
    
    param - the parameter for the statement underTest
    
    Returns:
    
    the assert DSL on the exception
  - fail
```
default void fail()
```
    Always produce a failure.
    For instance :
```
 fail();
 
```
    will immediately fail the current test.
  - fail
```
default void fail(String msg)
```
    Always produce a failure.
    For instance :
```
 fail("my message");
 
```
    will immediately fail the current test.
    Parameters:
    
    msg - a message
  - fail
```
default void fail(String msg,
                  Throwable innerError)
```
    Always produce a failure.
    For instance :
```
 fail("my message", t);
 
```
    will immediately fail the current test.
    Parameters:
    
    msg - a message
    
    innerError - the error cause
  - assumeThat
```
default <T> AssertThatObject<T> assumeThat(T obj)
```
    Assume the value of an object. This is used to skipped the test if the assumption fail.
    For instance
```
 assumeThat(myObject).is(myOtherObject);
 
```
    This will check that myObject is myOtherObject (using the equalTo Hamcrest matcher).
    Type Parameters:
    
    T - the object type.
    
    Parameters:
    
    obj - the object
    
    Returns:
    
    the assert DSL on this object
  - assumeThat
```
default <T> AssertThatObject<T> assumeThat(String msg,
                                           T obj)
```
    Assume the value of an object. This is used to skipped the test if the assumption fail.
    For instance
```
 assumeThat("msg", myObject).is(myOtherObject);
 
```
    This will check that myObject is myOtherObject (using the equalTo Hamcrest matcher).
    Type Parameters:
    
    T - the object type.
    
    Parameters:
    
    msg - a message
    
    obj - the object
    
    Returns:
    
    the assert DSL on this object
  - assumeThat
```
default AssertThatString assumeThat(String obj)
```
    Assume the value of a String.
    For instance
```
 assumeThat(myString).is("");
 
```
    This will check that myString is "" (using the equalTo Hamcrest matcher).
    Parameters:
    
    obj - the String
    
    Returns:
    
    the assert DSL on this object
  - assumeThat
```
default AssertThatString assumeThat(String msg,
                                    String obj)
```
    Assume the value of a String.
    For instance
```
 assumeThat("msg", myString).is("");
 
```
    This will check that myString is "" (using the equalTo Hamcrest matcher).
    Parameters:
    
    msg - a message
    
    obj - the String
    
    Returns:
    
    the assert DSL on this object
  - assumeThatIterable
```
default <T> AssertThatIterable<T> assumeThatIterable(Iterable<T> obj)
```
    Assume on an iterable object. This is used to skipped the test if the assumption fail.
    For instance
```
 assumeThatIterable(myIterable).hasSize(0);
 
```
    This will check that myIterable has a size of 0.
    Type Parameters:
    
    T - the element type.
    
    Parameters:
    
    obj - the object (Iterable)
    
    Returns:
    
    the assert DSL on this iterable
  - assumeThatIterable
```
default <T> AssertThatIterable<T> assumeThatIterable(String msg,
                                                     Iterable<T> obj)
```
    Assume on an iterable object. This is used to skipped the test if the assumption fail.
    For instance
```
 assumeThatIterable("msg", myIterable).hasSize(0);
 
```
    This will check that myIterable has a size of 0.
    Type Parameters:
    
    T - the element type.
    
    Parameters:
    
    msg - a message
    
    obj - the object (Iterable)
    
    Returns:
    
    the assert DSL on this iterable
  - assumeThatFunction
```
default <T,R> AssertThatObject<R> assumeThatFunction(java.util.function.Function<T,R> function,
                                                     T input)
```
    Assume on a function. This is used to skipped the test if the assumption fail.
    The purpose of this variant of assumeThat provides a way to apply a function on some input and to check the result.
    For instance
```
 assumeThatFunction((a) -> a + "x", "b").is("bx")
 
```
    This will pass the b string to the passed function (which add a x add the end of the string and then it will check that this string is bx (which is the case).
    Type Parameters:
    
    T - the object type of the input of the function
    
    R - the object type of the result
    
    Parameters:
    
    function - the function
    
    input - the input to the function
    
    Returns:
    
    then assert DSL on the result of the function
  - assumeThatFunction
```
default <T,R> AssertThatObject<R> assumeThatFunction(String msg,
                                                     java.util.function.Function<T,R> function,
                                                     T input)
```
    Assume on a function. This is used to skipped the test if the assumption fail.
    The purpose of this variant of assertThat provides a way to apply a function on some input and to check the result.
    For instance
```
 assumeThatFunction("msg", (a) -> a + "x", "b").is("bx")
 
```
    This will pass the b string to the passed function (which add a x add the end of the string and then it will check that this string is bx (which is the case).
    Type Parameters:
    
    T - the object type of the input of the function
    
    R - the object type of the result
    
    Parameters:
    
    msg - a message
    
    function - the function
    
    input - the input to the function
    
    Returns:
    
    then assert DSL on the result of the function
  - assumeThatBiFunction
```
default <T,U,R> AssertThatObject<R> assumeThatBiFunction(java.util.function.BiFunction<T,U,R> function,
                                                         T input1,
                                                         U input2)
```
    Assume on a bifunction.
    The purpose of this variant of assumeThat provides a way to apply a bifunction on some input and to check the result.
    For instance
```
 assumeThatBiFunction((a, b) -> a + b, "a", "b").is("ab")
 
```
    This will pass the b string to the passed function (which add a x add the end of the string and then it will check that this string is bx (which is the case).
    Type Parameters:
    
    T - the object type of the first input of the function
    
    U - the object type fo the second input of the function
    
    R - the object type of the result
    
    Parameters:
    
    function - the function
    
    input1 - the first input to the function
    
    input2 - the second input to the function
    
    Returns:
    
    then assert DSL on the result of the bifunction
  - assumeThatBiFunction
```
default <T,U,R> AssertThatObject<R> assumeThatBiFunction(String msg,
                                                         java.util.function.BiFunction<T,U,R> function,
                                                         T input1,
                                                         U input2)
```
    Assume on a bifunction.
    The purpose of this variant of assumeThat provides a way to apply a bifunction on some input and to check the result.
    For instance
```
 assumeThatBiFunction((a, b) -> a + b, "a", "b").is("ab")
 
```
    This will pass the b string to the passed function (which add a x add the end of the string and then it will check that this string is bx (which is the case).
    Type Parameters:
    
    T - the object type of the first input of the function
    
    U - the object type fo the second input of the function
    
    R - the object type of the result
    
    Parameters:
    
    msg - a message
    
    function - the function
    
    input1 - the first input to the function
    
    input2 - the second input to the function
    
    Returns:
    
    then assert DSL on the result of the bifunction
  - assumeWhen
```
default <T extends Throwable> AssertThatException<T> assumeWhen(Statement<?,T> underTest)
```
    Assume that a statement (a piece of code) throw an exception. This is used to skipped the test if the assumption fail.
    The goal of assumeWhen is to provide a way to validate that an exception is thrown.
    For instance
```
 assumeWhen((p) -> {
     throw new Throwable("test");
 }).throwException(exceptionMessage("test"));
 
```
    Will run a piece of code that always thrown an exception and then validate that the message of the exception is test.
    Type Parameters:
    
    T - the exception type
    
    Parameters:
    
    underTest - the Statement (p)->{}
    
    Returns:
    
    the assert DSL on the exception
  - assumeWhen
```
default <P,T extends Throwable> AssertThatException<T> assumeWhen(Statement<P,T> underTest,
                                                                  P param)
```
    Assume that a statement (a piece of code) throw an exception. This is used to skipped the test if the assumption fail.
    The goal of assumeWhen is to provide a way to validate that an exception is thrown.
    For instance
```
 assumeWhen((p) -> {
     throw new Throwable("test");
 }, null).throwException(exceptionMessage("test"));
 
```
    Will run a piece of code, passing null as parameter, that always thrown an exception and then validate that the message of the exception is test.
    Type Parameters:
    
    P - the type of the parameter
    
    T - the exception type
    
    Parameters:
    
    underTest - the Statement (p)->{}
    
    param - the parameter for the statement underTest
    
    Returns:
    
    the assert DSL on the exception
  - assumeWhen
```
default <T extends Throwable> AssertThatException<T> assumeWhen(String msg,
                                                                Statement<?,T> underTest)
```
    Assume that a statement (a piece of code) throw an exception. This is used to skipped the test if the assumption fail.
    The goal of assumeWhen is to provide a way to validate that an exception is thrown.
    For instance
```
 assumeWhen("msg", (p) -> {
     throw new Throwable("test");
 }).throwException(exceptionMessage("test"));
 
```
    Will run a piece of code that always thrown an exception and then validate that the message of the exception is test.
    Type Parameters:
    
    T - the exception type
    
    Parameters:
    
    msg - a message
    
    underTest - the statement (p)->{}
    
    Returns:
    
    the assert DSL on the exception
  - assumeWhen
```
default <P,T extends Throwable> AssertThatException<T> assumeWhen(String msg,
                                                                  Statement<P,T> underTest,
                                                                  P param)
```
    Assume that a statement (a piece of code) throw an exception. This is used to skipped the test if the assumption fail.
    The goal of assumeWhen is to provide a way to validate that an exception is thrown.
    For instance
```
 assumeWhen("msg", (p) -> {
     throw new Throwable("test");
 }, null).throwException(exceptionMessage("test"));
 
```
    Will run a piece of code, passing null as parameter, that always thrown an exception and then validate that the message of the exception is test.
    Type Parameters:
    
    P - the type of the parameter
    
    T - the exception type
    
    Parameters:
    
    msg - a message
    
    underTest - the statement (p)->{}
    
    param - the parameter for the statement underTest
    
    Returns:
    
    the assert DSL on the exception
  - skip
```
default void skip()
```
    Always produce a skip.
    For instance :
```
 skip();
 
```
    will immediately skip the current test.
  - skip
```
default void skip(String msg)
```
    Always produce a skip.
    For instance :
```
 skip("my message");
 
```
    will immediately skip the current test.
    Parameters:
    
    msg - a message
  - exceptionMessage
```
default org.hamcrest.Matcher<Throwable> exceptionMessage(org.hamcrest.Matcher<? super String> matching)
```
    Validate the message of an exception
    
    Parameters:
    
    matching - the matcher on the message
    
    Returns:
    
    the matcher on the exception
  - exceptionMessage
```
default org.hamcrest.Matcher<Throwable> exceptionMessage(String message)
```
    Validate the message of an exception
    
    Parameters:
    
    message - the expected Message
    
    Returns:
    
    the matcher on the exception
  - optionalIsPresent
```
default <T> org.hamcrest.Matcher<Optional<T>> optionalIsPresent()
```
    Check that the passed optional is present.
    
    Type Parameters:
    
    T - the type for what is inside the optional
    
    Returns:
    
    the matcher on the optional
  - optionalIsNotPresent
```
default <T> org.hamcrest.Matcher<Optional<T>> optionalIsNotPresent()
```
    Check that the passed optional is not present.
    
    Type Parameters:
    
    T - the type for what is inside the optional
    
    Returns:
    
    the matcher on the optional
  - optionalIs
```
default <T> org.hamcrest.Matcher<Optional<? super T>> optionalIs(org.hamcrest.Matcher<? super T> subMatcher)
```
    Check that the passed optional is accepted by some matcher.
    
    Type Parameters:
    
    T - the type for what is inside the optional
    
    Parameters:
    
    subMatcher - the matcher on the data
    
    Returns:
    
    the matcher on the optional
  - optionalIs
```
default <T> org.hamcrest.Matcher<Optional<? super T>> optionalIs(T target)
```
    Check that the passed optional is some target value.
    
    Type Parameters:
    
    T - the type for what is inside the optional
    
    Parameters:
    
    target - the target value
    
    Returns:
    
    the matcher on the optional
  - optionalDoubleIsPresent
```
default org.hamcrest.Matcher<OptionalDouble> optionalDoubleIsPresent()
```
    Check that the passed optional is present.
    
    Returns:
    
    the matcher on the optional
  - optionalDoubleIsNotPresent
```
default org.hamcrest.Matcher<OptionalDouble> optionalDoubleIsNotPresent()
```
    Check that the passed optional is not present.
    
    Returns:
    
    the matcher on the optional
  - optionalDoubleIs
```
default org.hamcrest.Matcher<OptionalDouble> optionalDoubleIs(org.hamcrest.Matcher<? super Double> subMatcher)
```
    Check that the passed optional is accepted by some matcher.
    
    Parameters:
    
    subMatcher - the matcher on the data
    
    Returns:
    
    the matcher on the optional
  - optionalIntIsPresent
```
default org.hamcrest.Matcher<OptionalInt> optionalIntIsPresent()
```
    Check that the passed optional is present.
    
    Returns:
    
    the matcher on the optional
  - optionalIntIsNotPresent
```
default org.hamcrest.Matcher<OptionalInt> optionalIntIsNotPresent()
```
    Check that the passed optional is not present.
    
    Returns:
    
    the matcher on the optional
  - optionalIntIs
```
default org.hamcrest.Matcher<OptionalInt> optionalIntIs(org.hamcrest.Matcher<? super Integer> subMatcher)
```
    Check that the passed optional is accepted by some matcher.
    
    Parameters:
    
    subMatcher - the matcher on the data
    
    Returns:
    
    the matcher on the optional
  - optionalIntIs
```
default org.hamcrest.Matcher<OptionalInt> optionalIntIs(Integer target)
```
    Check that the passed optional is some target value.
    
    Parameters:
    
    target - the target value
    
    Returns:
    
    the matcher on the optional
  - optionalLongIsPresent
```
default org.hamcrest.Matcher<OptionalLong> optionalLongIsPresent()
```
    Check that the passed optional is present.
    
    Returns:
    
    the matcher on the optional
  - optionalLongIsNotPresent
```
default org.hamcrest.Matcher<OptionalLong> optionalLongIsNotPresent()
```
    Check that the passed optional is not present.
    
    Returns:
    
    the matcher on the optional
  - optionalLongIs
```
default org.hamcrest.Matcher<OptionalLong> optionalLongIs(org.hamcrest.Matcher<? super Long> subMatcher)
```
    Check that the passed optional is accepted by some matcher.
    
    Parameters:
    
    subMatcher - the matcher on the data
    
    Returns:
    
    the matcher on the optional
  - optionalLongIs
```
default org.hamcrest.Matcher<OptionalLong> optionalLongIs(Long target)
```
    Check that the passed optional is some target value.
    
    Parameters:
    
    target - the target value
    
    Returns:
    
    the matcher on the optional
  - matchesRegex
```
default org.hamcrest.Matcher<String> matchesRegex(Pattern pattern)
```
    Validate a string with a Pattern.
```
 assertThat("abc").is(matchesRegex(Pattern.compile("ˆ[a-z]$"));
 
```
    Parameters:
    
    pattern - the pattern to be used.
    
    Returns:
    
    The matcher.
  - matchesRegex
```
default org.hamcrest.Matcher<String> matchesRegex(String regex)
```
    Validate a string with a regex.
```
 assertThat("abc").is matchesRegex("ˆ[a-z]+$"));
 
```
    Parameters:
    
    regex - The regex to be used for the validation.
    
    Returns:
    
    The matcher.
  - allOf
```
default <T> org.hamcrest.Matcher<T> allOf(Iterable<org.hamcrest.Matcher<? super T>> matchers)
```
    Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    For example:
```
 assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
 
```
    Type Parameters:
    
    T - The type of the object
    
    Parameters:
    
    matchers - the list of matcher to be applied
    
    Returns:
    
    the allOf Matcher
  - allOf
```
default <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T>... matchers)
```
    Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    For example:
```
 assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
 
```
    Type Parameters:
    
    T - The type of the object
    
    Parameters:
    
    matchers - the list of matcher to be applied
    
    Returns:
    
    the allOf Matcher
  - allOf
```
default <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first,
                                          org.hamcrest.Matcher<? super T> second)
```
    Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    For example:
```
 assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
 
```
    Type Parameters:
    
    T - The type of the object
    
    Parameters:
    
    first - the first Matcher
    
    second - the second Matcher
    
    Returns:
    
    the allOf Matcher
  - allOf
```
default <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first,
                                          org.hamcrest.Matcher<? super T> second,
                                          org.hamcrest.Matcher<? super T> third)
```
    Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    For example:
```
 assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
 
```
    Type Parameters:
    
    T - The type of the object
    
    Parameters:
    
    first - the first Matcher
    
    second - the second Matcher
    
    third - the third Matcher
    
    Returns:
    
    the allOf Matcher
  - allOf
```
default <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first,
                                          org.hamcrest.Matcher<? super T> second,
                                          org.hamcrest.Matcher<? super T> third,
                                          org.hamcrest.Matcher<? super T> fourth)
```
    Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    For example:
```
 assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
 
```
    Type Parameters:
    
    T - The type of the object
    
    Parameters:
    
    first - the first Matcher
    
    second - the second Matcher
    
    third - the third Matcher
    
    fourth - the fourth Matcher
    
    Returns:
    
    the allOf Matcher
  - allOf
```
default <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first,
                                          org.hamcrest.Matcher<? super T> second,
                                          org.hamcrest.Matcher<? super T> third,
                                          org.hamcrest.Matcher<? super T> fourth,
                                          org.hamcrest.Matcher<? super T> fifth)
```
    Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    For example:
```
 assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
 
```
    Type Parameters:
    
    T - The type of the object
    
    Parameters:
    
    first - the first Matcher
    
    second - the second Matcher
    
    third - the third Matcher
    
    fourth - the fourth Matcher
    
    fifth - the fifth Matcher
    
    Returns:
    
    the allOf Matcher
  - allOf
```
default <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first,
                                          org.hamcrest.Matcher<? super T> second,
                                          org.hamcrest.Matcher<? super T> third,
                                          org.hamcrest.Matcher<? super T> fourth,
                                          org.hamcrest.Matcher<? super T> fifth,
                                          org.hamcrest.Matcher<? super T> sixth)
```
    Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    For example:
```
 assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
 
```
    Type Parameters:
    
    T - The type of the object
    
    Parameters:
    
    first - the first Matcher
    
    second - the second Matcher
    
    third - the third Matcher
    
    fourth - the fourth Matcher
    
    fifth - the fifth Matcher
    
    sixth - the sixth Matcher
    
    Returns:
    
    the allOf Matcher
  - anyOf
```
default <T> org.hamcrest.core.AnyOf<T> anyOf(Iterable<org.hamcrest.Matcher<? super T>> matchers)
```
    Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    For example:
```
 assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
 
```
    Type Parameters:
    
    T - The type of the object
    
    Parameters:
    
    matchers - the list of matcher to be applied
    
    Returns:
    
    the anyOf Matcher
  - anyOf
```
default <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<T> first,
                                             org.hamcrest.Matcher<? super T> second,
                                             org.hamcrest.Matcher<? super T> third)
```
    Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    For example:
```
 assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
 
```
    Type Parameters:
    
    T - The type of the object
    
    Parameters:
    
    first - the first Matcher
    
    second - the second Matcher
    
    third - the third Matcher
    
    Returns:
    
    the anyOf Matcher
  - anyOf
```
default <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<T> first,
                                             org.hamcrest.Matcher<? super T> second,
                                             org.hamcrest.Matcher<? super T> third,
                                             org.hamcrest.Matcher<? super T> fourth)
```
    Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    For example:
```
 assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
 
```
    Type Parameters:
    
    T - The type of the object
    
    Parameters:
    
    first - the first Matcher
    
    second - the second Matcher
    
    third - the third Matcher
    
    fourth - the fourth Matcher
    
    Returns:
    
    the anyOf Matcher
  - anyOf
```
default <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<T> first,
                                             org.hamcrest.Matcher<? super T> second,
                                             org.hamcrest.Matcher<? super T> third,
                                             org.hamcrest.Matcher<? super T> fourth,
                                             org.hamcrest.Matcher<? super T> fifth)
```
    Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    For example:
```
 assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
 
```
    Type Parameters:
    
    T - The type of the object
    
    Parameters:
    
    first - the first Matcher
    
    second - the second Matcher
    
    third - the third Matcher
    
    fourth - the fourth Matcher
    
    fifth - the fifth Matcher
    
    Returns:
    
    the anyOf Matcher
  - anyOf
```
default <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<T> first,
                                             org.hamcrest.Matcher<? super T> second,
                                             org.hamcrest.Matcher<? super T> third,
                                             org.hamcrest.Matcher<? super T> fourth,
                                             org.hamcrest.Matcher<? super T> fifth,
                                             org.hamcrest.Matcher<? super T> sixth)
```
    Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    For example:
```
 assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
 
```
    Type Parameters:
    
    T - The type of the object
    
    Parameters:
    
    first - the first Matcher
    
    second - the second Matcher
    
    third - the third Matcher
    
    fourth - the fourth Matcher
    
    fifth - the fifth Matcher
    
    sixth - the sixth Matcher
    
    Returns:
    
    the anyOf Matcher
  - anyOf
```
default <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<T> first,
                                             org.hamcrest.Matcher<? super T> second)
```
    Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    For example:
```
 assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
 
```
    Type Parameters:
    
    T - The type of the object
    
    Parameters:
    
    first - the first Matcher
    
    second - the second Matcher
    
    Returns:
    
    the anyof matcher
  - anyOf
```
default <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<? super T>... matchers)
```
    Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    For example:
```
 assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
 
```
    Type Parameters:
    
    T - The type of the object
    
    Parameters:
    
    matchers - the matchers
    
    Returns:
    
    the anyOf Matcher
  - both
```
default <LHS> org.hamcrest.core.CombinableMatcher.CombinableBothMatcher<LHS> both(org.hamcrest.Matcher<? super LHS> matcher)
```
    Creates a matcher that matches when both of the specified matchers match the examined object.
    For example:
```
 assertThat("fab", both(containsString("a")).and(containsString("b")))
 
```
    Type Parameters:
    
    LHS - Left Hand Side
    
    Parameters:
    
    matcher - the second matcher
    
    Returns:
    
    the combined matcher
  - either
```
default <LHS> org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher<LHS> either(org.hamcrest.Matcher<? super LHS> matcher)
```
    Creates a matcher that matches when either of the specified matchers match the examined object.
    For example:
```
 assertThat("fan", either(containsString("a")).and(containsString("b")))
 
```
    Type Parameters:
    
    LHS - Left Hand Side
    
    Parameters:
    
    matcher - the second matcher
    
    Returns:
    
    the combined matcher
  - describedAs
```
default <T> org.hamcrest.Matcher<T> describedAs(String description,
                                                org.hamcrest.Matcher<T> matcher,
                                                Object... values)
```
    Wraps an existing matcher, overriding its description with that specified. All other functions are delegated to the decorated matcher, including its mismatch description.
    For example:
```
 describedAs("a big decimal equal to %0", equalTo(myBigDecimal),
         myBigDecimal.toPlainString())
 
```
    Type Parameters:
    
    T - the type of the object
    
    Parameters:
    
    description - the new description for the wrapped matcher
    
    matcher - the matcher to wrap
    
    values - optional values to insert into the tokenised description
    
    Returns:
    
    the matcher with description
  - everyItem
```
default <U> org.hamcrest.Matcher<Iterable<U>> everyItem(org.hamcrest.Matcher<U> itemMatcher)
```
    Creates a matcher for Iterables that only matches when a single pass over the examined Iterable yields items that are all matched by the specified itemMatcher.
    For example:
```
 assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
 
```
    Type Parameters:
    
    U - The item type
    
    Parameters:
    
    itemMatcher - the matcher to apply to every item provided by the examined Iterable
    
    Returns:
    
    the matcher on iterable
  - is
```
default <T> org.hamcrest.Matcher<T> is(T value)
```
    A shortcut to the frequently used is(equalTo(x)).
    For example:
```
 assertThat(cheese, is(smelly))
 
```
    instead of:
```
 assertThat(cheese, is(equalTo(smelly)))
 
```
    Type Parameters:
    
    T - The type of data.
    
    Parameters:
    
    value - the data
    
    Returns:
    
    the matcher on data
  - is
```
default <T> org.hamcrest.Matcher<T> is(org.hamcrest.Matcher<T> matcher)
```
    Decorates another Matcher, retaining its behaviour, but allowing tests to be slightly more expressive.
    For example:
```
 assertThat(cheese, is(equalTo(smelly)))
 
```
    instead of:
```
 assertThat(cheese, equalTo(smelly))
 
```
    Type Parameters:
    
    T - The type of data.
    
    Parameters:
    
    matcher - the matcher on data
    
    Returns:
    
    the matcher on data
  - isA
```
default <T> org.hamcrest.Matcher<T> isA(Class<T> type)
```
    A shortcut to the frequently used is(instanceOf(SomeClass.class)).
    For example:
```
 assertThat(cheese, isA(Cheddar.class))
 
```
    instead of:
```
 assertThat(cheese, is(instanceOf(Cheddar.class)))
 
```
    Type Parameters:
    
    T - The type of data.
    
    Parameters:
    
    type - the expected data type
    
    Returns:
    
    the matcher on data
  - anything
```
default org.hamcrest.Matcher<Object> anything()
```
    Creates a matcher that always matches, regardless of the examined object.
    
    Returns:
    
    the matcher
  - anything
```
default org.hamcrest.Matcher<Object> anything(String description)
```
    Creates a matcher that always matches, regardless of the examined object, but describes itself with the specified String.
    
    Parameters:
    
    description - a meaningful String used when describing itself
    
    Returns:
    
    the matcher
  - hasItem
```
default <T> org.hamcrest.Matcher<Iterable<? super T>> hasItem(T item)
```
    Creates a matcher for Iterables that only matches when a single pass over the examined Iterable yields at least one item that is equal to the specified item. Whilst matching, the traversal of the examined Iterable will stop as soon as a matching item is found.
    For example:
```
 assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
 
```
    Type Parameters:
    
    T - element Type
    
    Parameters:
    
    item - the item to compare against the items provided by the examined Iterable
    
    Returns:
    
    the matcher
  - hasItem
```
default <T> org.hamcrest.Matcher<Iterable<? super T>> hasItem(org.hamcrest.Matcher<? super T> itemMatcher)
```
    Creates a matcher for Iterables that only matches when a single pass over the examined Iterable yields at least one item that is matched by the specified itemMatcher. Whilst matching, the traversal of the examined Iterable will stop as soon as a matching item is found.
    For example:
```
 assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
 
```
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    itemMatcher - the matcher to apply to items provided by the examined Iterable
    
    Returns:
    
    the matcher
  - hasItems
```
default <T> org.hamcrest.Matcher<Iterable<T>> hasItems(T... items)
```
    Creates a matcher for Iterables that matches when consecutive passes over the examined Iterable yield at least one item that is equal to the corresponding item from the specified items. Whilst matching, each traversal of the examined Iterable will stop as soon as a matching item is found.
    For example:
```
 assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
 
```
    Type Parameters:
    
    T - the element type.
    
    Parameters:
    
    items - the items to compare against the items provided by the examined Iterable
    
    Returns:
    
    the matcher
  - hasItems
```
default <T> org.hamcrest.Matcher<Iterable<T>> hasItems(org.hamcrest.Matcher<? super T>... itemMatchers)
```
    Creates a matcher for Iterables that matches when consecutive passes over the examined Iterable yield at least one item that is matched by the corresponding matcher from the specified itemMatchers. Whilst matching, each traversal of the examined Iterable will stop as soon as a matching item is found.
    For example:
```
 assertThat(Arrays.asList("foo", "bar", "baz"),
         hasItems(endsWith("z"), endsWith("o")))
 
```
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    itemMatchers - the matchers to apply to items provided by the examined Iterable
    
    Returns:
    
    the matcher
  - equalTo
```
default <T> org.hamcrest.Matcher<T> equalTo(T operand)
```
    Creates a matcher that matches when the examined object is logically equal to the specified operand, as determined by calling the Object.equals(java.lang.Object) method on the examined object.
    If the specified operand is null then the created matcher will only match if the examined object's equals method returns true when passed a null (which would be a violation of the equals contract), unless the examined object itself is null, in which case the matcher will return a positive match.
    The created matcher provides a special behaviour when examining Arrays, whereby it will match if both the operand and the examined object are arrays of the same length and contain items that are equal to each other (according to the above rules) in the same indexes.
    For example:
```
 assertThat("foo", equalTo("foo"));
 assertThat(new String[] { "foo", "bar" },
         equalTo(new String[] { "foo", "bar" }));
 
```
    Type Parameters:
    
    T - The type
    
    Parameters:
    
    operand - the target value.
    
    Returns:
    
    the matcher
  - any
```
default <T> org.hamcrest.Matcher<T> any(Class<T> type)
```
    Creates a matcher that matches when the examined object is an instance of the specified type, as determined by calling the Class.isInstance(Object) method on that type, passing the the examined object.
    The created matcher forces a relationship between specified type and the examined object, and should be used when it is necessary to make generics conform, for example in the JMock clause with(any(Thing.class))
    For example:
```
 assertThat(new Canoe(), instanceOf(Canoe.class));
 
```
    Type Parameters:
    
    T - The type
    
    Parameters:
    
    type - the type for the instanceOf
    
    Returns:
    
    the matcher
  - instanceOf
```
default <T> org.hamcrest.Matcher<T> instanceOf(Class<?> type)
```
    Creates a matcher that matches when the examined object is an instance of the specified type, as determined by calling the Class.isInstance(Object) method on that type, passing the the examined object.
    The created matcher assumes no relationship between specified type and the examined object.
    For example:
```
 assertThat(new Canoe(), instanceOf(Paddlable.class));
 
```
    Type Parameters:
    
    T - The type
    
    Parameters:
    
    type - the type for the instanceof
    
    Returns:
    
    the matcher
  - not
```
default <T> org.hamcrest.Matcher<T> not(org.hamcrest.Matcher<T> matcher)
```
    Creates a matcher that wraps an existing matcher, but inverts the logic by which it will match.
    For example:
```
 assertThat(cheese, is(not(equalTo(smelly))))
 
```
    Type Parameters:
    
    T - The type
    
    Parameters:
    
    matcher - the matcher whose sense should be inverted
    
    Returns:
    
    the matcher
  - not
```
default <T> org.hamcrest.Matcher<T> not(T value)
```
    A shortcut to the frequently used not(equalTo(x)).
    For example:
```
 assertThat(cheese, is(not(smelly)))
 
```
    instead of:
```
 assertThat(cheese, is(not(equalTo(smelly))))
 
```
    Type Parameters:
    
    T - The type
    
    Parameters:
    
    value - the value that any examined object should not equal
    
    Returns:
    
    the matcher
  - nullValue
```
default org.hamcrest.Matcher<Object> nullValue()
```
    Creates a matcher that matches if examined object is null.
    For example:
```
 assertThat(cheese, is(nullValue())
 
```
    Returns:
    
    the matcher
  - nullValue
```
default <T> org.hamcrest.Matcher<T> nullValue(Class<T> type)
```
    Creates a matcher that matches if examined object is null. Accepts a single dummy argument to facilitate type inference.
    For example:
```
 assertThat(cheese, is(nullValue(Cheese.class))
 
```
    Type Parameters:
    
    T - The type
    
    Parameters:
    
    type - dummy parameter used to infer the generic type of the returned matcher
    
    Returns:
    
    the matcher
  - notNullValue
```
default org.hamcrest.Matcher<Object> notNullValue()
```
    A shortcut to the frequently used not(nullValue()).
    For example:
```
 assertThat(cheese, is(notNullValue()))
 
```
    instead of:
```
 assertThat(cheese, is(not(nullValue())))
 
```
    Returns:
    
    the matcher
  - notNullValue
```
default <T> org.hamcrest.Matcher<T> notNullValue(Class<T> type)
```
    A shortcut to the frequently used not(nullValue(X.class)). Accepts a single dummy argument to facilitate type inference..
    For example:
```
 assertThat(cheese, is(notNullValue(X.class)))
 
```
    instead of:
```
 assertThat(cheese, is(not(nullValue(X.class))))
 
```
    Type Parameters:
    
    T - The type
    
    Parameters:
    
    type - dummy parameter used to infer the generic type of the returned matcher
    
    Returns:
    
    the matcher
  - sameInstance
```
default <T> org.hamcrest.Matcher<T> sameInstance(T target)
```
    Creates a matcher that matches only when the examined object is the same instance as the specified target object.
    
    Type Parameters:
    
    T - The type
    
    Parameters:
    
    target - the target instance against which others should be assessed
    
    Returns:
    
    the matcher
  - theInstance
```
default <T> org.hamcrest.Matcher<T> theInstance(T target)
```
    Creates a matcher that matches only when the examined object is the same instance as the specified target object.
    
    Type Parameters:
    
    T - The type
    
    Parameters:
    
    target - the target instance against which others should be assessed
    
    Returns:
    
    the matcher
  - containsString
```
default org.hamcrest.Matcher<String> containsString(String substring)
```
    Creates a matcher that matches if the examined String contains the specified String anywhere.
    For example:
```
 assertThat("myStringOfNote", containsString("ring"))
 
```
    Parameters:
    
    substring - the substring that the returned matcher will expect to find within any examined string
    
    Returns:
    
    the matcher
  - startsWith
```
default org.hamcrest.Matcher<String> startsWith(String prefix)
```
    Creates a matcher that matches if the examined String starts with the specified String.
    For example:
```
 assertThat("myStringOfNote", startsWith("my"))
 
```
    Parameters:
    
    prefix - the substring that the returned matcher will expect at the start of any examined string
    
    Returns:
    
    the matcher
  - endsWith
```
default org.hamcrest.Matcher<String> endsWith(String suffix)
```
    Creates a matcher that matches if the examined String ends with the specified String.
    For example:
```
 assertThat("myStringOfNote", endsWith("Note"))
 
```
    Parameters:
    
    suffix - the substring that the returned matcher will expect at the end of any examined string
    
    Returns:
    
    the matcher
  - array
```
default <T> org.hamcrest.collection.IsArray<T> array(org.hamcrest.Matcher<? super T>... elementMatchers)
```
    Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. Matches positively only if the number of matchers specified is equal to the length of the examined array and each matcher[i] is satisfied by array[i].
    For example:
```
 assertThat(new Integer[] { 1, 2, 3 },
         is(array(equalTo(1), equalTo(2), equalTo(3))))
 
```
    Type Parameters:
    
    T - The element type
    
    Parameters:
    
    elementMatchers - the matchers that the elements of examined arrays should satisfy
    
    Returns:
    
    the matcher
  - hasItemInArray
```
default <T> org.hamcrest.Matcher<T[]> hasItemInArray(T element)
```
    A shortcut to the frequently used hasItemInArray(equalTo(x)) .
    For example:
```
 assertThat(hasItemInArray(x))
 
```
    instead of:
```
 assertThat(hasItemInArray(equalTo(x)))
 
```
    Type Parameters:
    
    T - The element type
    
    Parameters:
    
    element - the element that should be present in examined arrays
    
    Returns:
    
    the matcher
  - hasItemInArray
```
default <T> org.hamcrest.Matcher<T[]> hasItemInArray(org.hamcrest.Matcher<? super T> elementMatcher)
```
    Creates a matcher for arrays that matches when the examined array contains at least one item that is matched by the specified elementMatcher. Whilst matching, the traversal of the examined array will stop as soon as a matching element is found.
    For example:
```
 assertThat(new String[] { "foo", "bar" }, hasItemInArray(startsWith("ba")))
 
```
    Type Parameters:
    
    T - The element type
    
    Parameters:
    
    elementMatcher - the matcher to apply to elements in examined arrays
    
    Returns:
    
    the matcher
  - arrayContaining
```
default <E> org.hamcrest.Matcher<E[]> arrayContaining(List<org.hamcrest.Matcher<? super E>> itemMatchers)
```
    Creates a matcher for arrays that matches when each item in the examined array satisfies the corresponding matcher in the specified list of matchers. For a positive match, the examined array must be of the same length as the specified list of matchers.
    For example:
```
 assertThat(new String[] { "foo", "bar" },
         contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
 
```
    Type Parameters:
    
    E - The element type
    
    Parameters:
    
    itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item in an examined array
    
    Returns:
    
    the matcher
  - arrayContaining
```
default <E> org.hamcrest.Matcher<E[]> arrayContaining(E... items)
```
    Creates a matcher for arrays that matcheswhen each item in the examined array is logically equal to the corresponding item in the specified items. For a positive match, the examined array must be of the same length as the number of specified items.
    For example:
```
 assertThat(new String[] { "foo", "bar" }, contains("foo", "bar"))
 
```
    Type Parameters:
    
    E - The element type
    
    Parameters:
    
    items - the items that must equal the items within an examined array
    
    Returns:
    
    the matcher
  - arrayContaining
```
default <E> org.hamcrest.Matcher<E[]> arrayContaining(org.hamcrest.Matcher<? super E>... itemMatchers)
```
    Creates a matcher for arrays that matches when each item in the examined array satisfies the corresponding matcher in the specified matchers. For a positive match, the examined array must be of the same length as the number of specified matchers.
    For example:
```
 assertThat(new String[] { "foo", "bar" },
         contains(equalTo("foo"), equalTo("bar")))
 
```
    Type Parameters:
    
    E - The element type
    
    Parameters:
    
    itemMatchers - the matchers that must be satisfied by the items in the examined array
    
    Returns:
    
    the matcher
  - arrayContainingInAnyOrder
```
default <E> org.hamcrest.Matcher<E[]> arrayContainingInAnyOrder(E... items)
```
    Creates an order agnostic matcher for arrays that matches when each item in the examined array is logically equal to one item anywhere in the specified items. For a positive match, the examined array must be of the same length as the number of specified items.
    N.B. each of the specified items will only be used once during a given examination, so be careful when specifying items that may be equal to more than one entry in an examined array.
    For example:
```
 assertThat(new String[] { "foo", "bar" }, containsInAnyOrder("bar", "foo"))
 
```
    Type Parameters:
    
    E - The element type
    
    Parameters:
    
    items - the items that must equal the entries of an examined array, in any order
    
    Returns:
    
    the matcher
  - arrayContainingInAnyOrder
```
default <E> org.hamcrest.Matcher<E[]> arrayContainingInAnyOrder(org.hamcrest.Matcher<? super E>... itemMatchers)
```
    Creates an order agnostic matcher for arrays that matches when each item in the examined array satisfies one matcher anywhere in the specified matchers. For a positive match, the examined array must be of the same length as the number of specified matchers.
    N.B. each of the specified matchers will only be used once during a given examination, so be careful when specifying matchers that may be satisfied by more than one entry in an examined array.
    For example:
```
 assertThat(new String[] { "foo", "bar" },
         arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))
 
```
    Type Parameters:
    
    E - The element type
    
    Parameters:
    
    itemMatchers - a list of matchers, each of which must be satisfied by an entry in an examined array
    
    Returns:
    
    the matcher
  - arrayContainingInAnyOrder
```
default <E> org.hamcrest.Matcher<E[]> arrayContainingInAnyOrder(Collection<org.hamcrest.Matcher<? super E>> itemMatchers)
```
    Creates an order agnostic matcher for arrays that matches when each item in the examined array satisfies one matcher anywhere in the specified collection of matchers. For a positive match, the examined array must be of the same length as the specified collection of matchers.
    N.B. each matcher in the specified collection will only be used once during a given examination, so be careful when specifying matchers that may be satisfied by more than one entry in an examined array.
    For example:
```
 assertThat(
         new String[] { "foo", "bar" },
         arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
 
```
    Type Parameters:
    
    E - The element type
    
    Parameters:
    
    itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined array
    
    Returns:
    
    the matcher
  - arrayWithSize
```
default <E> org.hamcrest.Matcher<E[]> arrayWithSize(org.hamcrest.Matcher<? super Integer> sizeMatcher)
```
    Creates a matcher for arrays that matches when the length of the array satisfies the specified matcher.
    For example:
```
 assertThat(new String[] { "foo", "bar" }, arrayWithSize(equalTo(2)))
 
```
    Type Parameters:
    
    E - The element type
    
    Parameters:
    
    sizeMatcher - a matcher for the length of an examined array
    
    Returns:
    
    the matcher
  - arrayWithSize
```
default <E> org.hamcrest.Matcher<E[]> arrayWithSize(int size)
```
    Creates a matcher for arrays that matches when the length of the array equals the specified size.
    For example:
```
 assertThat(new String[] { "foo", "bar" }, arrayWithSize(2))
 
```
    Type Parameters:
    
    E - The element type
    
    Parameters:
    
    size - the length that an examined array must have for a positive match
    
    Returns:
    
    the matcher
  - emptyArray
```
default <E> org.hamcrest.Matcher<E[]> emptyArray()
```
    Creates a matcher for arrays that matches when the length of the array is zero.
    For example:
```
 assertThat(new String[0], emptyArray())
 
```
    Type Parameters:
    
    E - The element type
    
    Returns:
    
    the matcher
  - hasSize
```
default <E> org.hamcrest.Matcher<Collection<? extends E>> hasSize(org.hamcrest.Matcher<? super Integer> sizeMatcher)
```
    Creates a matcher for Collections that matches when the size() method returns a value that satisfies the specified matcher.
    For example:
```
 assertThat(Arrays.asList("foo", "bar"), hasSize(equalTo(2)))
 
```
    Type Parameters:
    
    E - The element type
    
    Parameters:
    
    sizeMatcher - a matcher for the size of an examined Collection
    
    Returns:
    
    the matcher
  - hasSize
```
default <E> org.hamcrest.Matcher<Collection<? extends E>> hasSize(int size)
```
    Creates a matcher for Collections that matches when the size() method returns a value equal to the specified size.
    For example:
```
 assertThat(Arrays.asList("foo", "bar"), hasSize(2))
 
```
    Type Parameters:
    
    E - The element type
    
    Parameters:
    
    size - the expected size of an examined Collection
    
    Returns:
    
    the matcher
  - empty
```
default <E> org.hamcrest.Matcher<Collection<? extends E>> empty()
```
    Creates a matcher for Collections matching examined collections whose isEmpty method returns true.
    For example:
```
 assertThat(new ArrayList<String>(), is(empty()))
 
```
    Type Parameters:
    
    E - The element type
    
    Returns:
    
    the matcher
  - emptyCollectionOf
```
default <E> org.hamcrest.Matcher<Collection<E>> emptyCollectionOf(Class<E> type)
```
    Creates a matcher for Collections matching examined collections whose isEmpty method returns true.
    For example:
```
 assertThat(new ArrayList<String>(), is(emptyCollectionOf(String.class)))
 
```
    Type Parameters:
    
    E - The element Type
    
    Parameters:
    
    type - the type of the collection's content
    
    Returns:
    
    the matcher
  - emptyIterable
```
default <E> org.hamcrest.Matcher<Iterable<? extends E>> emptyIterable()
```
    Creates a matcher for Iterables matching examined iterables that yield no items.
    For example:
```
 assertThat(new ArrayList<String>(), is(emptyIterable()))
 
```
    Type Parameters:
    
    E - The element type
    
    Returns:
    
    the matcher
  - emptyIterableOf
```
default <E> org.hamcrest.Matcher<Iterable<E>> emptyIterableOf(Class<E> type)
```
    Creates a matcher for Iterables matching examined iterables that yield no items.
    For example:
```
 assertThat(new ArrayList<String>(), is(emptyIterableOf(String.class)))
 
```
    Type Parameters:
    
    E - The element type
    
    Parameters:
    
    type - the type of the iterable's content
    
    Returns:
    
    the matcher
  - contains
```
default <E> org.hamcrest.Matcher<Iterable<? extends E>> contains(org.hamcrest.Matcher<? super E>... itemMatchers)
```
    Creates a matcher for Iterables that matches when a single pass over the examined Iterable yields a series of items, each satisfying the corresponding matcher in the specified matchers. For a positive match, the examined iterable must be of the same length as the number of specified matchers.
    For example:
```
 assertThat(Arrays.asList("foo", "bar"),
         contains(equalTo("foo"), equalTo("bar")))
 
```
    Type Parameters:
    
    E - The element type
    
    Parameters:
    
    itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable
    
    Returns:
    
    the matcher
  - contains
```
default <E> org.hamcrest.Matcher<Iterable<? extends E>> contains(E... items)
```
    Creates a matcher for Iterables that matches when a single pass over the examined Iterable yields a series of items, each logically equal to the corresponding item in the specified items. For a positive match, the examined iterable must be of the same length as the number of specified items.
    For example:
```
 assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))
 
```
    Type Parameters:
    
    E - the element type
    
    Parameters:
    
    items - the items that must equal the items provided by an examined Iterable
    
    Returns:
    
    the matcher
  - contains
```
default <E> org.hamcrest.Matcher<Iterable<? extends E>> contains(org.hamcrest.Matcher<? super E> itemMatcher)
```
    Creates a matcher for Iterables that matches when a single pass over the examined Iterable yields a single item that satisfies the specified matcher. For a positive match, the examined iterable must only yield one item.
    For example:
```
 assertThat(Arrays.asList("foo"), contains(equalTo("foo")))
 
```
    Type Parameters:
    
    E - the element type
    
    Parameters:
    
    itemMatcher - the matcher that must be satisfied by the single item provided by an examined Iterable
    
    Returns:
    
    the matcher
  - contains
```
default <E> org.hamcrest.Matcher<Iterable<? extends E>> contains(List<org.hamcrest.Matcher<? super E>> itemMatchers)
```
    Creates a matcher for Iterables that matches when a single pass over the examined Iterable yields a series of items, each satisfying the corresponding matcher in the specified list of matchers. For a positive match, the examined iterable must be of the same length as the specified list of matchers.
    For example:
```
 assertThat(Arrays.asList("foo", "bar"),
         contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))
 
```
    Type Parameters:
    
    E - the element type
    
    Parameters:
    
    itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item provided by an examined Iterable
    
    Returns:
    
    the matcher
  - containsInAnyOrder
```
default <T> org.hamcrest.Matcher<Iterable<? extends T>> containsInAnyOrder(T... items)
```
    Creates an order agnostic matcher for Iterables that matches when a single pass over the examined Iterable yields a series of items, each logically equal to one item anywhere in the specified items. For a positive match, the examined iterable must be of the same length as the number of specified items.
    N.B. each of the specified items will only be used once during a given examination, so be careful when specifying items that may be equal to more than one entry in an examined iterable.
    For example:
```
 assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder("bar", "foo"))
 
```
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    items - the items that must equal the items provided by an examined Iterable in any order
    
    Returns:
    
    the matcher
  - containsInAnyOrder
```
default <T> org.hamcrest.Matcher<Iterable<? extends T>> containsInAnyOrder(Collection<org.hamcrest.Matcher<? super T>> itemMatchers)
```
    Creates an order agnostic matcher for Iterables that matches when a single pass over the examined Iterable yields a series of items, each satisfying one matcher anywhere in the specified collection of matchers. For a positive match, the examined iterable must be of the same length as the specified collection of matchers.
    N.B. each matcher in the specified collection will only be used once during a given examination, so be careful when specifying matchers that may be satisfied by more than one entry in an examined iterable.
    For example:
```
 assertThat(Arrays.asList("foo", "bar"),
         containsInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))
 
```
    Type Parameters:
    
    T - the type element
    
    Parameters:
    
    itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
    
    Returns:
    
    the matcher
  - containsInAnyOrder
```
default <T> org.hamcrest.Matcher<Iterable<? extends T>> containsInAnyOrder(org.hamcrest.Matcher<? super T>... itemMatchers)
```
    Creates an order agnostic matcher for Iterables that matches when a single pass over the examined Iterable yields a series of items, each satisfying one matcher anywhere in the specified matchers. For a positive match, the examined iterable must be of the same length as the number of specified matchers.
    N.B. each of the specified matchers will only be used once during a given examination, so be careful when specifying matchers that may be satisfied by more than one entry in an examined iterable.
    For example:
```
 assertThat(Arrays.asList("foo", "bar"),
         containsInAnyOrder(equalTo("bar"), equalTo("foo")))
 
```
    Type Parameters:
    
    T - the type element
    
    Parameters:
    
    itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
    
    Returns:
    
    the matcher
  - iterableWithSize
```
default <E> org.hamcrest.Matcher<Iterable<E>> iterableWithSize(org.hamcrest.Matcher<? super Integer> sizeMatcher)
```
    Creates a matcher for Iterables that matches when a single pass over the examined Iterable yields an item count that satisfies the specified matcher.
    For example:
```
 assertThat(Arrays.asList("foo", "bar"), iterableWithSize(equalTo(2)))
 
```
    Type Parameters:
    
    E - the element type
    
    Parameters:
    
    sizeMatcher - a matcher for the number of items that should be yielded by an examined Iterable
    
    Returns:
    
    the matcher
  - iterableWithSize
```
default <E> org.hamcrest.Matcher<Iterable<E>> iterableWithSize(int size)
```
    Creates a matcher for Iterables that matches when a single pass over the examined Iterable yields an item count that is equal to the specified size argument.
    For example:
```
 assertThat(Arrays.asList("foo", "bar"), iterableWithSize(2))
 
```
    Type Parameters:
    
    E - the element type
    
    Parameters:
    
    size - the number of items that should be yielded by an examined Iterable
    
    Returns:
    
    the matcher
  - hasEntry
```
default <K,V> org.hamcrest.Matcher<Map<? extends K,? extends V>> hasEntry(K key,
                                                                          V value)
```
    Creates a matcher for Maps matching when the examined Map contains at least one entry whose key equals the specified key and whose value equals the specified value.
    For example:
```
 assertThat(myMap, hasEntry("bar", "foo"))
 
```
    Type Parameters:
    
    K - The key type
    
    V - The value type
    
    Parameters:
    
    key - the key that, in combination with the value, must be describe at least one entry
    
    value - the value that, in combination with the key, must be describe at least one entry
    
    Returns:
    
    the matcher
  - hasEntry
```
default <K,V> org.hamcrest.Matcher<Map<? extends K,? extends V>> hasEntry(org.hamcrest.Matcher<? super K> keyMatcher,
                                                                          org.hamcrest.Matcher<? super V> valueMatcher)
```
    Creates a matcher for Maps matching when the examined Map contains at least one entry whose key satisfies the specified keyMatcher and whose value satisfies the specified valueMatcher.
    For example:
```
 assertThat(myMap, hasEntry(equalTo("bar"), equalTo("foo")))
 
```
    Type Parameters:
    
    K - the key type
    
    V - the value type
    
    Parameters:
    
    keyMatcher - the key matcher that, in combination with the valueMatcher, must be satisfied by at least one entry
    
    valueMatcher - the value matcher that, in combination with the keyMatcher, must be satisfied by at least one entry
    
    Returns:
    
    the matcher
  - hasKey
```
default <K> org.hamcrest.Matcher<Map<? extends K,?>> hasKey(org.hamcrest.Matcher<? super K> keyMatcher)
```
    Creates a matcher for Maps matching when the examined Map contains at least one key that satisfies the specified matcher.
    For example:
```
 assertThat(myMap, hasKey(equalTo("bar")))
 
```
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    keyMatcher - the matcher that must be satisfied by at least one key
    
    Returns:
    
    the matcher
  - hasKey
```
default <K> org.hamcrest.Matcher<Map<? extends K,?>> hasKey(K key)
```
    Creates a matcher for Maps matching when the examined Map contains at least one key that is equal to the specified key.
    For example:
```
 assertThat(myMap, hasKey("bar"))
 
```
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    key - the key that satisfying maps must contain
    
    Returns:
    
    the matcher
  - hasValue
```
default <V> org.hamcrest.Matcher<Map<?,? extends V>> hasValue(V value)
```
    Creates a matcher for Maps matching when the examined Map contains at least one value that is equal to the specified value.
    For example:
```
 assertThat(myMap, hasValue("foo"))
 
```
    Type Parameters:
    
    V - the value type
    
    Parameters:
    
    value - the value that satisfying maps must contain
    
    Returns:
    
    the matcher
  - hasValue
```
default <V> org.hamcrest.Matcher<Map<?,? extends V>> hasValue(org.hamcrest.Matcher<? super V> valueMatcher)
```
    Creates a matcher for Maps matching when the examined Map contains at least one value that satisfies the specified valueMatcher.
    For example:
```
 assertThat(myMap, hasValue(equalTo("foo")))
 
```
    Type Parameters:
    
    V - the value type
    
    Parameters:
    
    valueMatcher - the matcher that must be satisfied by at least one value
    
    Returns:
    
    the matcher
  - isIn
```
default <T> org.hamcrest.Matcher<T> isIn(Collection<T> collection)
```
    Creates a matcher that matches when the examined object is found within the specified collection.
    For example:
```
 assertThat("foo", isIn(Arrays.asList("bar", "foo")))
 
```
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    collection - the collection in which matching items must be found
    
    Returns:
    
    the matcher
  - isIn
```
default <T> org.hamcrest.Matcher<T> isIn(T[] param1)
```
  - isOneOf
```
default <T> org.hamcrest.Matcher<T> isOneOf(T... elements)
```
    Creates a matcher that matches when the examined object is equal to one of the specified elements.
    For example:
```
 assertThat("foo", isIn("bar", "foo"))
 
```
    Type Parameters:
    
    T - the type
    
    Parameters:
    
    elements - the elements amongst which matching items will be found
    
    Returns:
    
    the matcher
  - closeTo
```
default org.hamcrest.Matcher<Double> closeTo(double operand,
                                             double error)
```
    Creates a matcher of Doubles that matches when an examined double is equal to the specified operand, within a range of +/- error.
    For example:
```
 assertThat(1.03, is(closeTo(1.0, 0.03)))
 
```
    Parameters:
    
    operand - the expected value of matching doubles
    
    error - the delta (+/-) within which matches will be allowed
    
    Returns:
    
    the matcher
  - closeTo
```
default org.hamcrest.Matcher<BigDecimal> closeTo(BigDecimal operand,
                                                 BigDecimal error)
```
    Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal to the specified operand, within a range of +/- error. The comparison for equality is done by BigDecimals BigDecimal.compareTo(java.math.BigDecimal) method.
    For example:
```
 assertThat(new BigDecimal("1.03"),
         is(closeTo(new BigDecimal("1.0"), new BigDecimal("0.03"))))
 
```
    Parameters:
    
    operand - the expected value of matching BigDecimals
    
    error - the delta (+/-) within which matches will be allowed
    
    Returns:
    
    the matcher
  - comparesEqualTo
```
default <T extends Comparable<T>> org.hamcrest.Matcher<T> comparesEqualTo(T value)
```
    Creates a matcher of Comparable object that matches when the examined object is equal to the specified value, as reported by the compareTo method of the examined object.
    For example:
```
 assertThat(1, comparesEqualTo(1))
 
```
    Type Parameters:
    
    T - the type
    
    Parameters:
    
    value - the value which, when passed to the compareTo method of the examined object, should return zero
    
    Returns:
    
    the matcher
  - greaterThan
```
default <T extends Comparable<T>> org.hamcrest.Matcher<T> greaterThan(T value)
```
    Creates a matcher of Comparable object that matches when the examined object is greater than the specified value, as reported by the compareTo method of the examined object.
    For example:
```
 assertThat(2, greaterThan(1))
 
```
    Type Parameters:
    
    T - the type
    
    Parameters:
    
    value - the value which, when passed to the compareTo method of the examined object, should return greater than zero
    
    Returns:
    
    the matcher
  - greaterThanOrEqualTo
```
default <T extends Comparable<T>> org.hamcrest.Matcher<T> greaterThanOrEqualTo(T value)
```
    Creates a matcher of Comparable object that matches when the examined object is greater than or equal to the specified value, as reported by the compareTo method of the examined object.
    For example:
```
 assertThat(1, greaterThanOrEqualTo(1))
 
```
    Type Parameters:
    
    T - The Type
    
    Parameters:
    
    value - the value which, when passed to the compareTo method of the examined object, should return greater than or equal to zero
    
    Returns:
    
    the matcher
  - lessThan
```
default <T extends Comparable<T>> org.hamcrest.Matcher<T> lessThan(T value)
```
    Creates a matcher of Comparable object that matches when the examined object is less than the specified value, as reported by the compareTo method of the examined object.
    For example:
```
 assertThat(1, lessThan(2))
 
```
    Type Parameters:
    
    T - The Type
    
    Parameters:
    
    value - the value which, when passed to the compareTo method of the examined object, should return less than zero
    
    Returns:
    
    the matcher
  - lessThanOrEqualTo
```
default <T extends Comparable<T>> org.hamcrest.Matcher<T> lessThanOrEqualTo(T value)
```
    Creates a matcher of Comparable object that matches when the examined object is less than or equal to the specified value, as reported by the compareTo method of the examined object.
    For example:
```
 assertThat(1, lessThanOrEqualTo(1))
 
```
    Type Parameters:
    
    T - The Type
    
    Parameters:
    
    value - the value which, when passed to the compareTo method of the examined object, should return less than or equal to zero
    
    Returns:
    
    the matcher
  - equalToIgnoringCase
```
default org.hamcrest.Matcher<String> equalToIgnoringCase(String expectedString)
```
    Creates a matcher of String that matches when the examined string is equal to the specified expectedString, ignoring case.
    For example:
```
 assertThat("Foo", equalToIgnoringCase("FOO"))
 
```
    Parameters:
    
    expectedString - the expected value of matched strings
    
    Returns:
    
    the matcher
  - equalToIgnoringWhiteSpace
```
default org.hamcrest.Matcher<String> equalToIgnoringWhiteSpace(String expectedString)
```
    Creates a matcher of String that matches when the examined string is equal to the specified expectedString, when whitespace differences are (mostly) ignored. To be exact, the following whitespace rules are applied:
    - all leading and trailing whitespace of both the expectedString and the examined string are ignored
    - any remaining whitespace, appearing within either string, is collapsed to a single space before comparison
    For example:
```
 assertThat("   my\tfoo  bar ", equalToIgnoringWhiteSpace(" my  foo bar"))
 
```
    Parameters:
    
    expectedString - the expected value of matched strings
    
    Returns:
    
    the matcher
  - isEmptyString
```
default org.hamcrest.Matcher<String> isEmptyString()
```
    Creates a matcher of String that matches when the examined string has zero length.
    For example:
```
 assertThat("", isEmptyString())
 
```
    Returns:
    
    the matcher
  - isEmptyOrNullString
```
default org.hamcrest.Matcher<String> isEmptyOrNullString()
```
    Creates a matcher of String that matches when the examined string is null, or has zero length.
    For example:
```
 assertThat(((String) null), isEmptyString())
 
```
    Returns:
    
    the matcher
  - stringContainsInOrder
```
default org.hamcrest.Matcher<String> stringContainsInOrder(Iterable<String> substrings)
```
    Creates a matcher of String that matches when the examined string contains all of the specified substrings, regardless of the order of their appearance.
    For example:
```
 assertThat("myfoobarbaz", stringContainsInOrder(Arrays.asList("bar", "foo")))
 
```
    Parameters:
    
    substrings - the substrings that must be contained within matching strings
    
    Returns:
    
    the matcher
  - hasToString
```
default <T> org.hamcrest.Matcher<T> hasToString(org.hamcrest.Matcher<? super String> toStringMatcher)
```
    Creates a matcher that matches any examined object whose toString method returns a value that satisfies the specified matcher.
    For example:
```
 assertThat(true, hasToString(equalTo("TRUE")))
 
```
    Type Parameters:
    
    T - The Type
    
    Parameters:
    
    toStringMatcher - the matcher used to verify the toString result
    
    Returns:
    
    the matcher
  - hasToString
```
default <T> org.hamcrest.Matcher<T> hasToString(String expectedToString)
```
    Creates a matcher that matches any examined object whose toString method returns a value equalTo the specified string.
    For example:
```
 assertThat(true, hasToString("TRUE"))
 
```
    Type Parameters:
    
    T - The Type
    
    Parameters:
    
    expectedToString - the expected toString result
    
    Returns:
    
    the matcher
  - typeCompatibleWith
```
default <T> org.hamcrest.Matcher<Class<?>> typeCompatibleWith(Class<T> baseType)
```
    Creates a matcher of Class that matches when the specified baseType is assignable from the examined class.
    For example:
```
 assertThat(Integer.class, typeCompatibleWith(Number.class))
 
```
    Type Parameters:
    
    T - The Type
    
    Parameters:
    
    baseType - the base class to examine classes against
    
    Returns:
    
    the matcher
  - eventFrom
```
default org.hamcrest.Matcher<EventObject> eventFrom(Class<? extends EventObject> eventClass,
                                                    Object source)
```
    Creates a matcher of EventObject that matches any object derived from eventClass announced by source.
    For example:
```
 assertThat(myEvent, is(eventFrom(PropertyChangeEvent.class, myBean)))
 
```
    Parameters:
    
    eventClass - the class of the event to match on
    
    source - the source of the event
    
    Returns:
    
    the matcher
  - eventFrom
```
default org.hamcrest.Matcher<EventObject> eventFrom(Object source)
```
    Creates a matcher of EventObject that matches any EventObject announced by source.
    For example:
```
 assertThat(myEvent, is(eventFrom(myBean)))
 
```
    Parameters:
    
    source - the source of the event
    
    Returns:
    
    the matcher
  - hasProperty
```
default <T> org.hamcrest.Matcher<T> hasProperty(String propertyName)
```
    Creates a matcher that matches when the examined object has a JavaBean property with the specified name.
    For example:
```
 assertThat(myBean, hasProperty("foo"))
 
```
    Type Parameters:
    
    T - The Type
    
    Parameters:
    
    propertyName - the name of the JavaBean property that examined beans should possess
    
    Returns:
    
    the matcher
  - hasProperty
```
default <T> org.hamcrest.Matcher<T> hasProperty(String propertyName,
                                                org.hamcrest.Matcher<?> valueMatcher)
```
    Creates a matcher that matches when the examined object has a JavaBean property with the specified name whose value satisfies the specified matcher.
    For example:
```
 assertThat(myBean, hasProperty("foo", equalTo("bar"))
 
```
    Type Parameters:
    
    T - The Type
    
    Parameters:
    
    propertyName - the name of the JavaBean property that examined beans should possess
    
    valueMatcher - a matcher for the value of the specified property of the examined bean
    
    Returns:
    
    the matcher
  - samePropertyValuesAs
```
default <T> org.hamcrest.Matcher<T> samePropertyValuesAs(T expectedBean)
```
    Creates a matcher that matches when the examined object has values for all of its JavaBean properties that are equal to the corresponding values of the specified bean.
    For example:
```
 assertThat(myBean, samePropertyValuesAs(myExpectedBean))
 
```
    Type Parameters:
    
    T - The Type
    
    Parameters:
    
    expectedBean - the bean against which examined beans are compared
    
    Returns:
    
    the matcher
  - hasXPath
```
default org.hamcrest.Matcher<Node> hasXPath(String xPath,
                                            NamespaceContext namespaceContext)
```
    Creates a matcher of Nodes that matches when the examined node contains a node at the specified xPath within the specified namespace context, with any content.
    For example:
```
 assertThat(xml, hasXPath("/root/something[2]/cheese", myNs))
 
```
    Parameters:
    
    xPath - the target xpath
    
    namespaceContext - the namespace for matching nodes
    
    Returns:
    
    the matcher
  - hasXPath
```
default org.hamcrest.Matcher<Node> hasXPath(String xPath)
```
    Creates a matcher of Nodes that matches when the examined node contains a node at the specified xPath, with any content.
    For example:
```
 assertThat(xml, hasXPath("/root/something[2]/cheese"))
 
```
    Parameters:
    
    xPath - the target xpath
    
    Returns:
    
    the matcher
  - hasXPath
```
default org.hamcrest.Matcher<Node> hasXPath(String xPath,
                                            NamespaceContext namespaceContext,
                                            org.hamcrest.Matcher<String> valueMatcher)
```
    Creates a matcher of Nodes that matches when the examined node has a value at the specified xPath, within the specified namespaceContext, that satisfies the specified valueMatcher.
    For example:
```
 assertThat(xml, hasXPath("/root/something[2]/cheese", myNs, equalTo("Cheddar")))
 
```
    Parameters:
    
    xPath - the target xpath
    
    namespaceContext - the namespace for matching nodes
    
    valueMatcher - matcher for the value at the specified xpath
    
    Returns:
    
    the matcher
  - hasXPath
```
default org.hamcrest.Matcher<Node> hasXPath(String xPath,
                                            org.hamcrest.Matcher<String> valueMatcher)
```
    Creates a matcher of Nodes that matches when the examined node has a value at the specified xPath that satisfies the specified valueMatcher.
    For example:
```
 assertThat(xml, hasXPath("/root/something[2]/cheese", equalTo("Cheddar")))
 
```
    Parameters:
    
    xPath - the target xpath
    
    valueMatcher - matcher for the value at the specified xpath
    
    Returns:
    
    the matcher
  - fileCanExecute
```
default org.hamcrest.Matcher<File> fileCanExecute(org.hamcrest.Matcher<? super Boolean> matcher)
```
    Validate that a file can execute.
    For example :
```
 assertThat(myFile).is(fileCanExecute(is(true)));
 
```
    Parameters:
    
    matcher - the matcher on the can execute flag.
    
    Returns:
    
    the matcher on the file.
  - fileCanExecute
```
default org.hamcrest.Matcher<File> fileCanExecute(boolean canExecute)
```
    Validate that a file can execute.
    For example :
```
 assertThat(myFile).is(fileCanExecute(true);
 
```
    Parameters:
    
    canExecute - the expected value for the can execute flag.
    
    Returns:
    
    the matcher on the file.
  - fileCanRead
```
default org.hamcrest.Matcher<File> fileCanRead(org.hamcrest.Matcher<? super Boolean> matcher)
```
    Validate that a file can read.
    For example :
```
 assertThat(myFile).is(fileCanRead(is(true)));
 
```
    Parameters:
    
    matcher - the matcher on the can read flag.
    
    Returns:
    
    the matcher on the file.
  - fileCanRead
```
default org.hamcrest.Matcher<File> fileCanRead(boolean canRead)
```
    Validate that a file can read.
    For example :
```
 assertThat(myFile).is(fileCanRead(true);
 
```
    Parameters:
    
    canRead - the expected value for the can read flag.
    
    Returns:
    
    the matcher on the file.
  - fileCanWrite
```
default org.hamcrest.Matcher<File> fileCanWrite(org.hamcrest.Matcher<? super Boolean> matcher)
```
    Validate that a file can write.
    For example :
```
 assertThat(myFile).is(fileCanWrite(is(true)));
 
```
    Parameters:
    
    matcher - the matcher on the can write flag.
    
    Returns:
    
    the matcher on the file.
  - fileCanWrite
```
default org.hamcrest.Matcher<File> fileCanWrite(boolean canWrite)
```
    Validate that a file can write.
    For example :
```
 assertThat(myFile).is(fileCanWrite(true);
 
```
    Parameters:
    
    canWrite - the expected value for the can write flag.
    
    Returns:
    
    the matcher on the file.
  - fileIsDirectory
```
default org.hamcrest.Matcher<File> fileIsDirectory(org.hamcrest.Matcher<? super Boolean> matcher)
```
    Validate that a file is a directory.
    For example :
```
 assertThat(myFile).is(fileIsDirectory(is(true)));
 
```
    Parameters:
    
    matcher - the matcher on the is directory flag.
    
    Returns:
    
    the matcher on the file.
  - fileIsDirectory
```
default org.hamcrest.Matcher<File> fileIsDirectory(boolean isDirectory)
```
    Validate that a file is a directory.
    For example :
```
 assertThat(myFile).is(fileIsDirectory(true);
 
```
    Parameters:
    
    isDirectory - the expected value for the is directory flag.
    
    Returns:
    
    the matcher on the file.
  - fileExists
```
default org.hamcrest.Matcher<File> fileExists(org.hamcrest.Matcher<? super Boolean> matcher)
```
    Validate that a file exists.
    For example :
```
 assertThat(myFile).is(fileExists(is(true)));
 
```
    Parameters:
    
    matcher - the matcher on the exists flag.
    
    Returns:
    
    the matcher on the file.
  - fileExists
```
default org.hamcrest.Matcher<File> fileExists(boolean exists)
```
    Validate that a file exists.
    For example :
```
 assertThat(myFile).is(fileExists(true);
 
```
    Parameters:
    
    exists - the expected value for the exists flag.
    
    Returns:
    
    the matcher on the file.
  - fileIsAbsolute
```
default org.hamcrest.Matcher<File> fileIsAbsolute(org.hamcrest.Matcher<? super Boolean> matcher)
```
    Validate that a file is absolute.
    For example :
```
 assertThat(myFile).is(fileIsAbsolute(is(true)));
 
```
    Parameters:
    
    matcher - the matcher on the absolute flag.
    
    Returns:
    
    the matcher on the file.
  - fileIsAbsolute
```
default org.hamcrest.Matcher<File> fileIsAbsolute(boolean absolute)
```
    Validate that a file is absolute.
    For example :
```
 assertThat(myFile).is(fileIsAbsolute(true);
 
```
    Parameters:
    
    absolute - the expected value for the absolute flag.
    
    Returns:
    
    the matcher on the file.
  - fileContains
```
default org.hamcrest.Matcher<File> fileContains(org.hamcrest.Matcher<String[]> matcher)
```
    Validate that a file contains something.
    The returned String[] is the one produced by list().
    
    Parameters:
    
    matcher - the matcher on the list() result.
    
    Returns:
    
    the matcher on the file.
  - fileContains
```
default org.hamcrest.Matcher<File> fileContains(String atLeastThisName)
```
    Validate that a file contains some other file name.
    
    Parameters:
    
    atLeastThisName - the file name.
    
    Returns:
    
    the matcher on the file.
  - fileNamed
```
default org.hamcrest.Matcher<File> fileNamed(org.hamcrest.Matcher<? super String> matcher)
```
    Validate that a file has some name.
    For example :
```
 assertThat(myFile).is(fileNamed(is("x")));
 
```
    Parameters:
    
    matcher - the matcher on the name.
    
    Returns:
    
    the matcher on the file.
  - fileNamed
```
default org.hamcrest.Matcher<File> fileNamed(String name)
```
    Validate that a file has some name.
    For example :
```
 assertThat(myFile).is(fileNamed("x"));
 
```
    Parameters:
    
    name - the expected value for the name.
    
    Returns:
    
    the matcher on the file.
  - pathMatchedAsFile
```
default org.hamcrest.Matcher<Path> pathMatchedAsFile(org.hamcrest.Matcher<? super File> matcher)
```
    This is a special matcher that apply the toFile() method to the in matching path, and then apply the specified matcher.
    
    Parameters:
    
    matcher - the matcher on File.
    
    Returns:
    
    the matcher on Path.

Interface TestSuite

Field Summary

Method Summary

Field Detail

DSL

Method Detail

before

after

mockitoRule

temporaryFolder

temporaryFolderBuilder

systemPropertiesRule

systemProperty

systemProperty

parametersMap

stringToParameterMap

addFieldToEachEntry

parametersFilterUsingMatcher

matcherPredicate

assertThat

assertThat

assertThat

assertThat

assertThatIterable

assertThatIterable

assertThatFunction

assertThatFunction

assertThatBiFunction

assertThatBiFunction

assertWhen

assertWhen

assertWhen

assertWhen

fail

fail

fail

assumeThat

assumeThat

assumeThat

assumeThat

assumeThatIterable

assumeThatIterable

assumeThatFunction

assumeThatFunction

assumeThatBiFunction

assumeThatBiFunction

assumeWhen

assumeWhen

assumeWhen

assumeWhen

skip

skip

exceptionMessage

exceptionMessage

optionalIsPresent

optionalIsNotPresent

optionalIs

optionalIs

optionalDoubleIsPresent

optionalDoubleIsNotPresent

optionalDoubleIs

optionalIntIsPresent

optionalIntIsNotPresent

optionalIntIs

optionalIntIs

optionalLongIsPresent

optionalLongIsNotPresent

optionalLongIs

optionalLongIs

matchesRegex

matchesRegex

allOf

allOf

allOf

allOf

allOf

allOf

allOf

anyOf

anyOf