Uses of Class org.hamcrest.Factory (Hamcrest)
Date: 2018-08-04

## Uses of Class
org.hamcrest.Factory

- Packages that use Factory
  Package | Description
  --- | ---
  org.hamcrest.beans | Matchers of Java Bean properties and their values.
  org.hamcrest.collection | Matchers of arrays and collections.
  org.hamcrest.core | Fundamental matchers of objects and values, and composite matchers.
  org.hamcrest.number | Matchers that perform numeric comparisons.
  org.hamcrest.object | Matchers that inspect objects and classes.
  org.hamcrest.text | Matchers that perform text comparisons.
  org.hamcrest.xml | Matchers of XML documents.

- - ### Uses of Factory in org.hamcrest.beans

    Methods in org.hamcrest.beans with annotations of type Factory
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Matcher<T>` | HasProperty.`hasProperty(java.lang.String propertyName)` Creates a matcher that matches when the examined object has a JavaBean property with the specified name.
    `static <T> Matcher<T>` | HasPropertyWithValue.`hasProperty(java.lang.String propertyName, 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.
    `static <T> Matcher<T>` | SamePropertyValuesAs.`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.

  - ### Uses of Factory in org.hamcrest.collection

    Methods in org.hamcrest.collection with annotations of type Factory
    Modifier and Type | Method and Description
    --- | ---
    `static <T> IsArray<T>` | IsArray.`array(Matcher<? super T>... elementMatchers)` Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
    `static <E> Matcher<E[]>` | IsArrayContainingInOrder.`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.
    `static <E> Matcher<E[]>` | IsArrayContainingInOrder.`arrayContaining(java.util.List<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.
    `static <E> Matcher<E[]>` | IsArrayContainingInOrder.`arrayContaining(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.
    `static <E> Matcher<E[]>` | IsArrayContainingInAnyOrder.`arrayContainingInAnyOrder(java.util.Collection<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.
    `static <E> Matcher<E[]>` | IsArrayContainingInAnyOrder.`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.
    `static <E> Matcher<E[]>` | IsArrayContainingInAnyOrder.`arrayContainingInAnyOrder(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.
    `static <E> Matcher<E[]>` | IsArrayWithSize.`arrayWithSize(int size)` Creates a matcher for arrays that matches when the `length` of the array equals the specified `size`.
    `static <E> Matcher<E[]>` | IsArrayWithSize.`arrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)` Creates a matcher for arrays that matches when the `length` of the array satisfies the specified matcher.
    `static <E> Matcher<java.lang.Iterable<? extends E>>` | IsIterableContainingInOrder.`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.
    `static <E> Matcher<java.lang.Iterable<? extends E>>` | IsIterableContainingInOrder.`contains(java.util.List<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.
    `static <E> Matcher<java.lang.Iterable<? extends E>>` | IsIterableContainingInOrder.`contains(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.
    `static <E> Matcher<java.lang.Iterable<? extends E>>` | IsIterableContainingInOrder.`contains(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.
    `static <T> Matcher<java.lang.Iterable<? extends T>>` | IsIterableContainingInAnyOrder.`containsInAnyOrder(java.util.Collection<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.
    `static <E> Matcher<java.lang.Iterable<? extends E>>` | IsIterableContainingInAnyOrder.`containsInAnyOrder(Matcher<? super E> itemMatcher)` Deprecated. use contains(Matcher itemMatcher) instead
    `static <T> Matcher<java.lang.Iterable<? extends T>>` | IsIterableContainingInAnyOrder.`containsInAnyOrder(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.
    `static <T> Matcher<java.lang.Iterable<? extends T>>` | IsIterableContainingInAnyOrder.`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.
    `static <E> Matcher<java.util.Collection<? extends E>>` | IsEmptyCollection.`empty()` Creates a matcher for `Collection`s matching examined collections whose `isEmpty` method returns `true`.
    `static <E> Matcher<E[]>` | IsArrayWithSize.`emptyArray()` Creates a matcher for arrays that matches when the `length` of the array is zero.
    `static <E> Matcher<java.util.Collection<E>>` | IsEmptyCollection.`emptyCollectionOf(java.lang.Class<E> type)` Creates a matcher for `Collection`s matching examined collections whose `isEmpty` method returns `true`.
    `static <E> Matcher<java.lang.Iterable<? extends E>>` | IsEmptyIterable.`emptyIterable()` Creates a matcher for `Iterable`s matching examined iterables that yield no items.
    `static <E> Matcher<java.lang.Iterable<E>>` | IsEmptyIterable.`emptyIterableOf(java.lang.Class<E> type)` Creates a matcher for `Iterable`s matching examined iterables that yield no items.
    `static <K,V> Matcher<java.util.Map<? extends K,? extends V>>` | IsMapContaining.`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`.
    `static <K,V> Matcher<java.util.Map<? extends K,? extends V>>` | IsMapContaining.`hasEntry(Matcher<? super K> keyMatcher, 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`.
    `static <T> Matcher<T[]>` | IsArrayContaining.`hasItemInArray(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`.
    `static <T> Matcher<T[]>` | IsArrayContaining.`hasItemInArray(T element)` A shortcut to the frequently used `hasItemInArray(equalTo(x))`.
    `static <K> Matcher<java.util.Map<? extends K,?>>` | IsMapContaining.`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.
    `static <K> Matcher<java.util.Map<? extends K,?>>` | IsMapContaining.`hasKey(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.
    `static <E> Matcher<java.util.Collection<? extends E>>` | IsCollectionWithSize.`hasSize(int size)` Creates a matcher for `Collection`s that matches when the `size()` method returns a value equal to the specified `size`.
    `static <E> Matcher<java.util.Collection<? extends E>>` | IsCollectionWithSize.`hasSize(Matcher<? super java.lang.Integer> sizeMatcher)` Creates a matcher for `Collection`s that matches when the `size()` method returns a value that satisfies the specified matcher.
    `static <V> Matcher<java.util.Map<?,? extends V>>` | IsMapContaining.`hasValue(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.
    `static <V> Matcher<java.util.Map<?,? extends V>>` | IsMapContaining.`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.
    `static <T> Matcher<T>` | IsIn.`isIn(java.util.Collection<T> collection)` Creates a matcher that matches when the examined object is found within the specified collection.
    `static <T> Matcher<T>` | IsIn.`isIn(T[] elements)` Creates a matcher that matches when the examined object is found within the specified array.
    `static <T> Matcher<T>` | IsIn.`isOneOf(T... elements)` Creates a matcher that matches when the examined object is equal to one of the specified elements.
    `static <E> Matcher<java.lang.Iterable<E>>` | IsIterableWithSize.`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.
    `static <E> Matcher<java.lang.Iterable<E>>` | IsIterableWithSize.`iterableWithSize(Matcher<? super java.lang.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.

  - ### Uses of Factory in org.hamcrest.core

    Methods in org.hamcrest.core with annotations of type Factory
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Matcher<T>` | AllOf.`allOf(java.lang.Iterable<Matcher<? super T>> matchers)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    `static <T> Matcher<T>` | AllOf.`allOf(Matcher<? super T>... matchers)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    `static <T> Matcher<T>` | AllOf.`allOf(Matcher<? super T> first, Matcher<? super T> second)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    `static <T> Matcher<T>` | AllOf.`allOf(Matcher<? super T> first, Matcher<? super T> second, Matcher<? super T> third)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    `static <T> Matcher<T>` | AllOf.`allOf(Matcher<? super T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    `static <T> Matcher<T>` | AllOf.`allOf(Matcher<? super T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth, Matcher<? super T> fifth)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    `static <T> Matcher<T>` | AllOf.`allOf(Matcher<? super T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth, Matcher<? super T> fifth, Matcher<? super T> sixth)` Creates a matcher that matches if the examined object matches ALL of the specified matchers.
    `static <T> Matcher<T>` | IsInstanceOf.`any(java.lang.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.
    `static <T> AnyOf<T>` | AnyOf.`anyOf(java.lang.Iterable<Matcher<? super T>> matchers)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    `static <T> AnyOf<T>` | AnyOf.`anyOf(Matcher<? super T>... matchers)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    `static <T> AnyOf<T>` | AnyOf.`anyOf(Matcher<T> first, Matcher<? super T> second)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    `static <T> AnyOf<T>` | AnyOf.`anyOf(Matcher<T> first, Matcher<? super T> second, Matcher<? super T> third)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    `static <T> AnyOf<T>` | AnyOf.`anyOf(Matcher<T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    `static <T> AnyOf<T>` | AnyOf.`anyOf(Matcher<T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth, Matcher<? super T> fifth)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    `static <T> AnyOf<T>` | AnyOf.`anyOf(Matcher<T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth, Matcher<? super T> fifth, Matcher<? super T> sixth)` Creates a matcher that matches if the examined object matches ANY of the specified matchers.
    `static Matcher<java.lang.Object>` | IsAnything.`anything()` Creates a matcher that always matches, regardless of the examined object.
    `static Matcher<java.lang.Object>` | IsAnything.`anything(java.lang.String description)` Creates a matcher that always matches, regardless of the examined object, but describes itself with the specified `String`.
    `static <LHS> CombinableMatcher.CombinableBothMatcher<LHS>` | CombinableMatcher.`both(Matcher<? super LHS> matcher)` Creates a matcher that matches when both of the specified matchers match the examined object.
    `static Matcher<java.lang.String>` | StringContains.`containsString(java.lang.String substring)` Creates a matcher that matches if the examined `String` contains the specified `String` anywhere.
    `static <T> Matcher<T>` | DescribedAs.`describedAs(java.lang.String description, Matcher<T> matcher, java.lang.Object... values)` Wraps an existing matcher, overriding its description with that specified.
    `static <LHS> CombinableMatcher.CombinableEitherMatcher<LHS>` | CombinableMatcher.`either(Matcher<? super LHS> matcher)` Creates a matcher that matches when either of the specified matchers match the examined object.
    `static Matcher<java.lang.String>` | StringEndsWith.`endsWith(java.lang.String suffix)` Creates a matcher that matches if the examined `String` ends with the specified `String`.
    `static <T> Matcher<T>` | IsEqual.`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.
    `static <U> Matcher<java.lang.Iterable<U>>` | Every.`everyItem(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`.
    `static <T> Matcher<java.lang.Iterable<? super T>>` | IsCollectionContaining.`hasItem(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`.
    `static <T> Matcher<java.lang.Iterable<? super T>>` | IsCollectionContaining.`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`.
    `static <T> Matcher<java.lang.Iterable<T>>` | IsCollectionContaining.`hasItems(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`.
    `static <T> Matcher<java.lang.Iterable<T>>` | IsCollectionContaining.`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`.
    `static <T> Matcher<T>` | IsInstanceOf.`instanceOf(java.lang.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.
    `static <T> Matcher<T>` | Is.`is(java.lang.Class<T> type)` Deprecated. use isA(Class type) instead.
    `static <T> Matcher<T>` | Is.`is(Matcher<T> matcher)` Decorates another Matcher, retaining its behaviour, but allowing tests to be slightly more expressive.
    `static <T> Matcher<T>` | Is.`is(T value)` A shortcut to the frequently used `is(equalTo(x))`.
    `static <T> Matcher<T>` | Is.`isA(java.lang.Class<T> type)` A shortcut to the frequently used `is(instanceOf(SomeClass.class))`.
    `static <T> Matcher<T>` | IsNot.`not(Matcher<T> matcher)` Creates a matcher that wraps an existing matcher, but inverts the logic by which it will match.
    `static <T> Matcher<T>` | IsNot.`not(T value)` A shortcut to the frequently used `not(equalTo(x))`.
    `static Matcher<java.lang.Object>` | IsNull.`notNullValue()` A shortcut to the frequently used `not(nullValue())`.
    `static <T> Matcher<T>` | IsNull.`notNullValue(java.lang.Class<T> type)` A shortcut to the frequently used `not(nullValue(X.class)).`
    `static Matcher<java.lang.Object>` | IsNull.`nullValue()` Creates a matcher that matches if examined object is `null`.
    `static <T> Matcher<T>` | IsNull.`nullValue(java.lang.Class<T> type)` Creates a matcher that matches if examined object is `null`.
    `static <T> Matcher<T>` | IsSame.`sameInstance(T target)` Creates a matcher that matches only when the examined object is the same instance as the specified target object.
    `static Matcher<java.lang.String>` | StringStartsWith.`startsWith(java.lang.String prefix)` Creates a matcher that matches if the examined `String` starts with the specified `String`.
    `static <T> Matcher<T>` | IsSame.`theInstance(T target)` Creates a matcher that matches only when the examined object is the same instance as the specified target object.

  - ### Uses of Factory in org.hamcrest.number

    Methods in org.hamcrest.number with annotations of type Factory
    Modifier and Type | Method and Description
    --- | ---
    `static Matcher<java.math.BigDecimal>` | BigDecimalCloseTo.`closeTo(java.math.BigDecimal operand, java.math.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`.
    `static Matcher<java.lang.Double>` | IsCloseTo.`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`.
    `static <T extends java.lang.Comparable<T>> Matcher<T>` | OrderingComparison.`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.
    `static <T extends java.lang.Comparable<T>> Matcher<T>` | OrderingComparison.`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.
    `static <T extends java.lang.Comparable<T>> Matcher<T>` | OrderingComparison.`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.
    `static <T extends java.lang.Comparable<T>> Matcher<T>` | OrderingComparison.`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.
    `static <T extends java.lang.Comparable<T>> Matcher<T>` | OrderingComparison.`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.

  - ### Uses of Factory in org.hamcrest.object

    Methods in org.hamcrest.object with annotations of type Factory
    Modifier and Type | Method and Description
    --- | ---
    `static Matcher<java.util.EventObject>` | IsEventFrom.`eventFrom(java.lang.Class<? extends java.util.EventObject> eventClass, java.lang.Object source)` Creates a matcher of `EventObject` that matches any object derived from eventClass announced by source.
    `static Matcher<java.util.EventObject>` | IsEventFrom.`eventFrom(java.lang.Object source)` Creates a matcher of `EventObject` that matches any EventObject announced by source.
    `static <T> Matcher<T>` | HasToString.`hasToString(Matcher<? super java.lang.String> toStringMatcher)` Creates a matcher that matches any examined object whose `toString` method returns a value that satisfies the specified matcher.
    `static <T> Matcher<T>` | HasToString.`hasToString(java.lang.String expectedToString)` Creates a matcher that matches any examined object whose `toString` method returns a value equalTo the specified string.
    `static <T> Matcher<java.lang.Class<?>>` | IsCompatibleType.`typeCompatibleWith(java.lang.Class<T> baseType)` Creates a matcher of `Class` that matches when the specified baseType is assignable from the examined class.

  - ### Uses of Factory in org.hamcrest.text

    Methods in org.hamcrest.text with annotations of type Factory
    Modifier and Type | Method and Description
    --- | ---
    `static Matcher<java.lang.String>` | IsEqualIgnoringCase.`equalToIgnoringCase(java.lang.String expectedString)` Creates a matcher of `String` that matches when the examined string is equal to the specified expectedString, ignoring case.
    `static Matcher<java.lang.String>` | IsEqualIgnoringWhiteSpace.`equalToIgnoringWhiteSpace(java.lang.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.
    `static Matcher<java.lang.String>` | IsEmptyString.`isEmptyOrNullString()` Creates a matcher of `String` that matches when the examined string is `null`, or has zero length.
    `static Matcher<java.lang.String>` | IsEmptyString.`isEmptyString()` Creates a matcher of `String` that matches when the examined string has zero length.
    `static Matcher<java.lang.String>` | StringContainsInOrder.`stringContainsInOrder(java.lang.Iterable<java.lang.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.

  - ### Uses of Factory in org.hamcrest.xml

    Methods in org.hamcrest.xml with annotations of type Factory
    Modifier and Type | Method and Description
    --- | ---
    `static Matcher<org.w3c.dom.Node>` | HasXPath.`hasXPath(java.lang.String xPath)` Creates a matcher of `Node`s that matches when the examined node contains a node at the specified `xPath`, with any content.
    `static Matcher<org.w3c.dom.Node>` | HasXPath.`hasXPath(java.lang.String xPath, Matcher<java.lang.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`.
    `static Matcher<org.w3c.dom.Node>` | HasXPath.`hasXPath(java.lang.String xPath, javax.xml.namespace.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.
    `static Matcher<org.w3c.dom.Node>` | HasXPath.`hasXPath(java.lang.String xPath, javax.xml.namespace.NamespaceContext namespaceContext, Matcher<java.lang.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`.