Package org.hamcrest

Class Matchers


  • public class Matchers
    extends java.lang.Object
    • Constructor Summary

      Constructors 
      Constructor Description
      Matchers()  
    • Method Summary

      All Methods Static Methods Concrete Methods Deprecated Methods 
      Modifier and Type Method Description
      static <T> Matcher<T> 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​(Matcher<? super T>... matchers)
      Creates a matcher that matches if the examined object matches ALL of the specified matchers.
      static <T> Matcher<T> 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​(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​(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​(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​(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 <K,​V>
      Matcher<java.util.Map<? extends K,​? extends V>>
      aMapWithSize​(int size)
      Creates a matcher for Maps that matches when the size() method returns a value equal to the specified size.
      static <K,​V>
      Matcher<java.util.Map<? extends K,​? extends V>>
      aMapWithSize​(Matcher<? super java.lang.Integer> sizeMatcher)
      Creates a matcher for Maps that matches when the size() method returns a value that satisfies the specified matcher.
      static <K,​V>
      Matcher<java.util.Map<? extends K,​? extends V>>
      anEmptyMap()
      Creates a matcher for Maps that matches when the size() method returns zero.
      static <T> Matcher<T> 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​(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​(Matcher<? super T>... matchers)
      Creates a matcher that matches if the examined object matches ANY of the specified matchers.
      static <T> AnyOf<T> anyOf​(Matcher<? super 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​(Matcher<? super 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​(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 ANY of the specified matchers.
      static <T> AnyOf<T> anyOf​(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 ANY of the specified matchers.
      static <T> AnyOf<T> anyOf​(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 ANY of the specified matchers.
      static Matcher<java.lang.Object> anything()
      Creates a matcher that always matches, regardless of the examined object.
      static Matcher<java.lang.Object> anything​(java.lang.String description)
      Creates a matcher that always matches, regardless of the examined object, but describes itself with the specified String.
      static <T> IsArray<T> array​(Matcher<? super T>... elementMatchers)
      Creates a matcher that matches arrays whose elements are satisfied by the specified matchers.
      static <E> Matcher<E[]> arrayContaining​(E... items)
      Creates a matcher for arrays that matches when each item in the examined array is logically equal to the corresponding item in the specified items.
      static <E> Matcher<E[]> 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[]> 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[]> 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[]> 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[]> 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[]> arrayWithSize​(int size)
      Creates a matcher for arrays that matches when the length of the array equals the specified size.
      static <E> Matcher<E[]> 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 Matcher<java.lang.String> blankOrNullString()
      Creates a matcher of String that matches when the examined string is null, or contains zero or more whitespace characters and nothing else.
      static Matcher<java.lang.String> blankString()
      Creates a matcher of String that matches when the examined string contains zero or more whitespace characters and nothing else.
      static <LHS> CombinableMatcher.CombinableBothMatcher<LHS> both​(Matcher<? super LHS> matcher)
      Creates a matcher that matches when both of the specified matchers match the examined object.
      static Matcher<java.lang.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.
      static Matcher<java.math.BigDecimal> closeTo​(java.math.BigDecimal operand, java.math.BigDecimal error)
      Creates a matcher of BigDecimals that matches when an examined BigDecimal is equal to the specified operand, within a range of +/- error.
      static <T extends java.lang.Comparable<T>>
      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.
      static <E> Matcher<java.lang.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.
      static <E> Matcher<java.lang.Iterable<? extends E>> contains​(java.util.List<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.
      static <E> Matcher<java.lang.Iterable<? extends E>> contains​(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.
      static <E> Matcher<java.lang.Iterable<? extends E>> contains​(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.
      static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder​(java.util.Collection<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.
      static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder​(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.
      static <T> Matcher<java.lang.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.
      static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder​(E... items)
      Creates a matcher for Iterables that matches when a single pass over the examined Iterable yields a series of items, that contains items logically equal to the corresponding item in the specified items, in the same relative order For example:
      static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder​(java.util.List<Matcher<? super E>> itemMatchers)
      Creates a matcher for Iterables that matches when a single pass over the examined Iterable yields a series of items, that contains items satisfying the corresponding matcher in the specified list of matchers, in the same relative order.
      static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder​(Matcher<? super E>... itemMatchers)
      Creates a matcher for Iterables that matches when a single pass over the examined Iterable yields a series of items, that each satisfying the corresponding matcher in the specified matchers, in the same relative order.
      static Matcher<java.lang.String> containsString​(java.lang.String substring)
      Creates a matcher that matches if the examined String contains the specified String anywhere.
      static Matcher<java.lang.String> containsStringIgnoringCase​(java.lang.String substring)
      Creates a matcher that matches if the examined String contains the specified String anywhere, ignoring case.
      static <T> Matcher<T> 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> either​(Matcher<? super LHS> matcher)
      Creates a matcher that matches when either of the specified matchers match the examined object.
      static <E> Matcher<java.util.Collection<? extends E>> empty()
      Creates a matcher for Collections matching examined collections whose isEmpty method returns true.
      static <E> Matcher<E[]> emptyArray()
      Creates a matcher for arrays that matches when the length of the array is zero.
      static <E> Matcher<java.util.Collection<E>> emptyCollectionOf​(java.lang.Class<E> unusedToForceReturnType)
      Creates a matcher for Collections matching examined collections whose isEmpty method returns true.
      static <E> Matcher<java.lang.Iterable<? extends E>> emptyIterable()
      Creates a matcher for Iterables matching examined iterables that yield no items.
      static <E> Matcher<java.lang.Iterable<E>> emptyIterableOf​(java.lang.Class<E> unusedToForceReturnType)
      Creates a matcher for Iterables matching examined iterables that yield no items.
      static Matcher<java.lang.String> emptyOrNullString()
      Creates a matcher of String that matches when the examined string is null, or has zero length.
      static Matcher<java.lang.String> emptyString()
      Creates a matcher of String that matches when the examined string has zero length.
      static Matcher<java.lang.String> endsWith​(java.lang.String suffix)
      Creates a matcher that matches if the examined String ends with the specified String.
      static Matcher<java.lang.String> endsWithIgnoringCase​(java.lang.String suffix)
      Creates a matcher that matches if the examined String ends with the specified String, ignoring case.
      static <T> 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.
      static Matcher<java.lang.String> equalToCompressingWhiteSpace​(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> 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> equalToIgnoringWhiteSpace​(java.lang.String expectedString)
      static Matcher<java.lang.Object> equalToObject​(java.lang.Object operand)
      Creates an IsEqual matcher that does not enforce the values being compared to be of the same static type.
      static Matcher<java.util.EventObject> 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> eventFrom​(java.lang.Object source)
      Creates a matcher of EventObject that matches any EventObject announced by source.
      static <U> Matcher<java.lang.Iterable<? extends U>> everyItem​(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.
      static <T extends java.lang.Comparable<T>>
      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.
      static <T extends java.lang.Comparable<T>>
      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.
      static <K,​V>
      Matcher<java.util.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.
      static <K,​V>
      Matcher<java.util.Map<? extends K,​? extends V>>
      hasEntry​(Matcher<? super K> keyMatcher, 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.
      static <T> Matcher<java.lang.Iterable<? super T>> hasItem​(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.
      static <T> Matcher<java.lang.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.
      static <T> Matcher<T[]> 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[]> hasItemInArray​(T element)
      A shortcut to the frequently used hasItemInArray(equalTo(x)).
      static <T> Matcher<java.lang.Iterable<T>> hasItems​(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.
      static <T> Matcher<java.lang.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.
      static <K> Matcher<java.util.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.
      static <K> Matcher<java.util.Map<? extends K,​?>> hasKey​(Matcher<? super K> keyMatcher)
      Creates a matcher for Maps matching when the examined Map contains at least one key that satisfies the specified matcher.
      static Matcher<java.lang.CharSequence> hasLength​(int length)
      Creates a matcher of CharSequence that matches when a char sequence has the length of the specified argument.
      static Matcher<java.lang.CharSequence> hasLength​(Matcher<? super java.lang.Integer> lengthMatcher)
      Creates a matcher of CharSequence that matches when a char sequence has the length that satisfies the specified matcher.
      static <T> Matcher<T> 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> 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 <E> Matcher<java.util.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.
      static <E> Matcher<java.util.Collection<? extends E>> hasSize​(Matcher<? super java.lang.Integer> sizeMatcher)
      Creates a matcher for Collections that matches when the size() method returns a value that satisfies the specified matcher.
      static <T> Matcher<T> 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<T> 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 <V> Matcher<java.util.Map<?,​? extends V>> hasValue​(Matcher<? super V> valueMatcher)
      Creates a matcher for Maps matching when the examined Map contains at least one value that satisfies the specified valueMatcher.
      static <V> Matcher<java.util.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.
      static Matcher<org.w3c.dom.Node> hasXPath​(java.lang.String xPath)
      Creates a matcher of Nodes that matches when the examined node contains a node at the specified xPath, with any content.
      static Matcher<org.w3c.dom.Node> hasXPath​(java.lang.String xPath, javax.xml.namespace.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.
      static Matcher<org.w3c.dom.Node> hasXPath​(java.lang.String xPath, javax.xml.namespace.NamespaceContext namespaceContext, Matcher<java.lang.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.
      static Matcher<org.w3c.dom.Node> hasXPath​(java.lang.String xPath, Matcher<java.lang.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.
      static <T> Matcher<T> in​(java.util.Collection<T> collection)
      Creates a matcher that matches when the examined object is found within the specified collection.
      static <T> Matcher<T> in​(T[] elements)
      Creates a matcher that matches when the examined object is found within the specified array.
      static <T> Matcher<T> 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​(Matcher<T> matcher)
      Decorates another Matcher, retaining its behaviour, but allowing tests to be slightly more expressive.
      static <T> Matcher<T> is​(T value)
      A shortcut to the frequently used is(equalTo(x)).
      static <T> Matcher<T> isA​(java.lang.Class<?> type)
      A shortcut to the frequently used is(instanceOf(SomeClass.class)).
      static Matcher<java.lang.String> isEmptyOrNullString()
      Deprecated.
      use is(emptyOrNullString()) instead
      static Matcher<java.lang.String> isEmptyString()
      Deprecated.
      use is(emptyString()) instead
      static <T> Matcher<T> isIn​(java.util.Collection<T> collection)
      Deprecated.
      use is(in(...)) instead
      static <T> Matcher<T> isIn​(T[] elements)
      Deprecated.
      use is(in(...)) instead
      static <T> Matcher<T> isOneOf​(T... elements)
      Deprecated.
      use is(oneOf(...)) instead
      static <E> Matcher<java.lang.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.
      static <E> Matcher<java.lang.Iterable<E>> iterableWithSize​(Matcher<? super java.lang.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.
      static <T extends java.lang.Comparable<T>>
      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.
      static <T extends java.lang.Comparable<T>>
      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.
      static Matcher<java.lang.String> matchesPattern​(java.lang.String regex)
      Creates a matcher of String that matches when the examined string exactly matches the given regular expression, treated as a Pattern.
      static Matcher<java.lang.String> matchesPattern​(java.util.regex.Pattern pattern)
      Creates a matcher of String that matches when the examined string exactly matches the given Pattern.
      static Matcher<java.lang.String> matchesRegex​(java.lang.String regex)
      Validate a string with a regex.
      static Matcher<java.lang.String> matchesRegex​(java.util.regex.Pattern pattern)
      Validate a string with a Pattern.
      static <T> Matcher<T> 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> not​(T value)
      A shortcut to the frequently used not(equalTo(x)).
      static Matcher<java.lang.Double> notANumber()
      Creates a matcher of Doubles that matches when an examined double is not a number.
      static Matcher<java.lang.Object> notNullValue()
      A shortcut to the frequently used not(nullValue()).
      static <T> Matcher<T> notNullValue​(java.lang.Class<T> type)
      A shortcut to the frequently used not(nullValue(X.class)).
      static Matcher<java.lang.Object> nullValue()
      Creates a matcher that matches if examined object is null.
      static <T> Matcher<T> nullValue​(java.lang.Class<T> type)
      Creates a matcher that matches if examined object is null.
      static <T> Matcher<T> oneOf​(T... elements)
      Creates a matcher that matches when the examined object is equal to one of the specified elements.
      static <T> Matcher<T> sameInstance​(T target)
      Creates a matcher that matches only when the examined object is the same instance as the specified target object.
      static <B> Matcher<B> samePropertyValuesAs​(B expectedBean, java.lang.String... ignoredProperties)
      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.
      static Matcher<java.lang.String> startsWith​(java.lang.String prefix)
      Creates a matcher that matches if the examined String starts with the specified String.
      static Matcher<java.lang.String> startsWithIgnoringCase​(java.lang.String prefix)
      Creates a matcher that matches if the examined String starts with the specified String, ignoring case
      static Matcher<java.lang.String> 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, considering the order of their appearance.
      static Matcher<java.lang.String> stringContainsInOrder​(java.lang.String... substrings)
      Creates a matcher of String that matches when the examined string contains all of the specified substrings, considering the order of their appearance.
      static <T> Matcher<T> theInstance​(T target)
      Creates a matcher that matches only when the examined object is the same instance as the specified target object.
      static <T> Matcher<java.lang.Class<?>> typeCompatibleWith​(java.lang.Class<T> baseType)
      Creates a matcher of Class that matches when the specified baseType is assignable from the examined class.
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Constructor Detail

      • Matchers

        public Matchers()
    • Method Detail

      • allOf

        public static <T> Matcher<T> allOf​(java.lang.Iterable<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 matcher type.
        Parameters:
        matchers - all the matchers must pass.
        Returns:
        The matcher.
      • allOf

        @SafeVarargs
        public static <T> Matcher<T> allOf​(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 matcher type.
        Parameters:
        matchers - all the matchers must pass.
        Returns:
        The matcher.
      • allOf

        public static <T> Matcher<T> allOf​(Matcher<? super T> first,
                                           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 matcher type.
        Parameters:
        first - first matcher that must pass.
        second - second matcher that must pass.
        Returns:
        The matcher.
      • allOf

        public static <T> Matcher<T> 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. For example:
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        Type Parameters:
        T - the matcher type.
        Parameters:
        first - first matcher that must pass.
        second - second matcher that must pass.
        third - third matcher that must pass.
        Returns:
        The matcher.
      • allOf

        public static <T> Matcher<T> 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. For example:
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        Type Parameters:
        T - the matcher type.
        Parameters:
        first - first matcher that must pass.
        second - second matcher that must pass.
        third - third matcher that must pass.
        fourth - fourth matcher that must pass.
        Returns:
        The matcher.
      • allOf

        public static <T> Matcher<T> 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. For example:
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        Type Parameters:
        T - the matcher type.
        Parameters:
        first - first matcher that must pass.
        second - second matcher that must pass.
        third - third matcher that must pass.
        fourth - fourth matcher that must pass.
        fifth - fifth matcher that must pass.
        Returns:
        The matcher.
      • allOf

        public static <T> Matcher<T> 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. For example:
        assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
        Type Parameters:
        T - the matcher type.
        Parameters:
        first - first matcher that must pass.
        second - second matcher that must pass.
        third - third matcher that must pass.
        fourth - fourth matcher that must pass.
        fifth - fifth matcher that must pass.
        sixth - sixth matcher that must pass.
        Returns:
        The matcher.
      • anyOf

        public static <T> AnyOf<T> anyOf​(java.lang.Iterable<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 matcher type.
        Parameters:
        matchers - any the matchers must pass.
        Returns:
        The matcher.
      • anyOf

        @SafeVarargs
        public static <T> AnyOf<T> anyOf​(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 matcher type.
        Parameters:
        matchers - any the matchers must pass.
        Returns:
        The matcher.
      • anyOf

        public static <T> AnyOf<T> anyOf​(Matcher<? super T> first,
                                         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 matcher type.
        Parameters:
        first - first matcher to check.
        second - second matcher to check.
        Returns:
        The matcher.
      • anyOf

        public static <T> AnyOf<T> anyOf​(Matcher<? super 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. For example:
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        Type Parameters:
        T - the matcher type.
        Parameters:
        first - first matcher to check.
        second - second matcher to check.
        third - third matcher to check.
        Returns:
        The matcher.
      • anyOf

        public static <T> AnyOf<T> anyOf​(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 ANY of the specified matchers. For example:
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        Type Parameters:
        T - the matcher type.
        Parameters:
        first - first matcher to check.
        second - second matcher to check.
        third - third matcher to check.
        fourth - fourth matcher to check.
        Returns:
        The matcher.
      • anyOf

        public static <T> AnyOf<T> anyOf​(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 ANY of the specified matchers. For example:
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        Type Parameters:
        T - the matcher type.
        Parameters:
        first - first matcher to check.
        second - second matcher to check.
        third - third matcher to check.
        fourth - fourth matcher to check.
        fifth - fifth matcher to check.
        Returns:
        The matcher.
      • anyOf

        public static <T> AnyOf<T> anyOf​(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 ANY of the specified matchers. For example:
        assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
        Type Parameters:
        T - the matcher type.
        Parameters:
        first - first matcher to check.
        second - second matcher to check.
        third - third matcher to check.
        fourth - fourth matcher to check.
        fifth - fifth matcher to check.
        sixth - sixth matcher to check.
        Returns:
        The matcher.
      • both

        public static <LHS> CombinableMatcher.CombinableBothMatcher<LHS> both​(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 - the matcher type.
        Parameters:
        matcher - the matcher to combine, and both must pass.
        Returns:
        The matcher.
      • either

        public static <LHS> CombinableMatcher.CombinableEitherMatcher<LHS> either​(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")).or(containsString("b")))
        Type Parameters:
        LHS - the matcher type.
        Parameters:
        matcher - the matcher to combine, and either must pass.
        Returns:
        The matcher.
      • describedAs

        public static <T> Matcher<T> describedAs​(java.lang.String description,
                                                 Matcher<T> matcher,
                                                 java.lang.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 matcher type.
        Parameters:
        description - the new description for the wrapped matcher
        matcher - the matcher to wrap
        values - optional values to insert into the tokenized description
        Returns:
        The matcher.
      • everyItem

        public static <U> Matcher<java.lang.Iterable<? extends U>> everyItem​(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 matcher type.
        Parameters:
        itemMatcher - the matcher to apply to every item provided by the examined Iterable
        Returns:
        The matcher.
      • is

        public static <T> Matcher<T> is​(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 matcher type.
        Parameters:
        matcher - the matcher to wrap.
        Returns:
        The matcher.
      • is

        public static <T> 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 matcher type.
        Parameters:
        value - the value to check.
        Returns:
        The matcher.
      • isA

        public static <T> Matcher<T> isA​(java.lang.Class<?> 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 matcher type.
        Parameters:
        type - the type to check.
        Returns:
        The matcher.
      • anything

        public static Matcher<java.lang.Object> anything()
        Creates a matcher that always matches, regardless of the examined object.
        Returns:
        The matcher.
      • anything

        public static Matcher<java.lang.Object> anything​(java.lang.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

        public static <T> Matcher<java.lang.Iterable<? super T>> hasItem​(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 matcher type.
        Parameters:
        itemMatcher - the matcher to apply to items provided by the examined Iterable
        Returns:
        The matcher.
      • hasItem

        public static <T> Matcher<java.lang.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 - the matcher type.
        Parameters:
        item - the item to compare against the items provided by the examined Iterable
        Returns:
        The matcher.
      • hasItems

        @SafeVarargs
        public static <T> Matcher<java.lang.Iterable<T>> hasItems​(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 matcher type.
        Parameters:
        itemMatchers - the matchers to apply to items provided by the examined Iterable
        Returns:
        The matcher.
      • hasItems

        @SafeVarargs
        public static <T> Matcher<java.lang.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 matcher type.
        Parameters:
        items - the items to compare against the items provided by the examined Iterable
        Returns:
        The matcher.
      • equalTo

        public static <T> 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 matcher type.
        Parameters:
        operand - the value to check.
        Returns:
        The matcher.
      • equalToObject

        public static Matcher<java.lang.Object> equalToObject​(java.lang.Object operand)
        Creates an IsEqual matcher that does not enforce the values being compared to be of the same static type.
        Parameters:
        operand - the value to check.
        Returns:
        The matcher.
      • any

        public static <T> Matcher<T> 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.

        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 matcher type.
        Parameters:
        type - the type to check.
        Returns:
        The matcher.
      • instanceOf

        public static <T> Matcher<T> 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.

        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 matcher type.
        Parameters:
        type - the type to check.
        Returns:
        The matcher.
      • not

        public static <T> Matcher<T> not​(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 matcher type.
        Parameters:
        matcher - the matcher whose sense should be inverted
        Returns:
        The matcher.
      • not

        public static <T> 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 matcher type.
        Parameters:
        value - the value that any examined object should not equal
        Returns:
        The matcher.
      • notNullValue

        public static Matcher<java.lang.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

        public static <T> Matcher<T> notNullValue​(java.lang.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 matcher type.
        Parameters:
        type - dummy parameter used to infer the generic type of the returned matcher
        Returns:
        The matcher.
      • nullValue

        public static Matcher<java.lang.Object> nullValue()
        Creates a matcher that matches if examined object is null. For example:
        assertThat(cheese, is(nullValue())
        Returns:
        The matcher.
      • nullValue

        public static <T> Matcher<T> nullValue​(java.lang.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 matcher type.
        Parameters:
        type - dummy parameter used to infer the generic type of the returned matcher
        Returns:
        The matcher.
      • sameInstance

        public static <T> 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 matcher type.
        Parameters:
        target - the target instance against which others should be assessed
        Returns:
        The matcher.
      • theInstance

        public static <T> 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 matcher type.
        Parameters:
        target - the target instance against which others should be assessed
        Returns:
        The matcher.
      • containsString

        public static Matcher<java.lang.String> containsString​(java.lang.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.
      • containsStringIgnoringCase

        public static Matcher<java.lang.String> containsStringIgnoringCase​(java.lang.String substring)
        Creates a matcher that matches if the examined String contains the specified String anywhere, ignoring case. For example:
        assertThat("myStringOfNote", containsStringIgnoringCase("Ring"))
        Parameters:
        substring - the substring that the returned matcher will expect to find within any examined string
        Returns:
        The matcher.
      • startsWith

        public static Matcher<java.lang.String> startsWith​(java.lang.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.
      • startsWithIgnoringCase

        public static Matcher<java.lang.String> startsWithIgnoringCase​(java.lang.String prefix)

        Creates a matcher that matches if the examined String starts with the specified String, ignoring case

        For example:
        assertThat("myStringOfNote", startsWithIgnoringCase("My"))
        Parameters:
        prefix - the substring that the returned matcher will expect at the start of any examined string
        Returns:
        The matcher.
      • endsWith

        public static Matcher<java.lang.String> endsWith​(java.lang.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.
      • endsWithIgnoringCase

        public static Matcher<java.lang.String> endsWithIgnoringCase​(java.lang.String suffix)
        Creates a matcher that matches if the examined String ends with the specified String, ignoring case. For example:
        assertThat("myStringOfNote", endsWithIgnoringCase("note"))
        Parameters:
        suffix - the substring that the returned matcher will expect at the end of any examined string
        Returns:
        The matcher.
      • matchesRegex

        public static Matcher<java.lang.String> matchesRegex​(java.util.regex.Pattern pattern)
        Validate a string with a Pattern.
         assertThat("abc", matchesRegex(Pattern.compile("ˆ[a-z]$"));
         
        Parameters:
        pattern - the pattern to be used.
        Returns:
        The matcher.
      • matchesRegex

        public static Matcher<java.lang.String> matchesRegex​(java.lang.String regex)
        Validate a string with a regex.
         assertThat("abc", matchesRegex("ˆ[a-z]+$"));
         
        Parameters:
        regex - The regex to be used for the validation.
        Returns:
        The matcher.
      • array

        @SafeVarargs
        public static <T> IsArray<T> array​(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 matcher type.
        Parameters:
        elementMatchers - the matchers that the elements of examined arrays should satisfy
        Returns:
        The matcher.
      • hasItemInArray

        public static <T> Matcher<T[]> 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. 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 matcher type.
        Parameters:
        elementMatcher - the matcher to apply to elements in examined arrays
        Returns:
        The matcher.
      • hasItemInArray

        public static <T> 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 matcher type.
        Parameters:
        element - the element that should be present in examined arrays
        Returns:
        The matcher.
      • arrayContaining

        @SafeVarargs
        public static <E> Matcher<E[]> arrayContaining​(E... items)
        Creates a matcher for arrays that matches when 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"}, arrayContaining("foo", "bar"))
        Type Parameters:
        E - the matcher type.
        Parameters:
        items - the items that must equal the items within an examined array
        Returns:
        The matcher.
      • arrayContaining

        @SafeVarargs
        public static <E> Matcher<E[]> 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. 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"}, arrayContaining(equalTo("foo"), equalTo("bar")))
        Type Parameters:
        E - the matcher type.
        Parameters:
        itemMatchers - the matchers that must be satisfied by the items in the examined array
        Returns:
        The matcher.
      • arrayContaining

        public static <E> Matcher<E[]> 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. 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"}, arrayContaining(Arrays.asList(equalTo("foo"), equalTo("bar"))))
        Type Parameters:
        E - the matcher type.
        Parameters:
        itemMatchers - a list of matchers, each of which must be satisfied by the corresponding item in an examined array
        Returns:
        The matcher.
      • arrayContainingInAnyOrder

        @SafeVarargs
        public static <E> Matcher<E[]> 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. 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 matcher type.
        Parameters:
        itemMatchers - a list of matchers, each of which must be satisfied by an entry in an examined array
        Returns:
        The matcher.
      • arrayContainingInAnyOrder

        public static <E> Matcher<E[]> 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. 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 matcher type.
        Parameters:
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined array
        Returns:
        The matcher.
      • arrayContainingInAnyOrder

        @SafeVarargs
        public static <E> 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"}, arrayContainingInAnyOrder("bar", "foo"))
        Type Parameters:
        E - the matcher type.
        Parameters:
        items - the items that must equal the entries of an examined array, in any order
        Returns:
        The matcher.
      • arrayWithSize

        public static <E> Matcher<E[]> arrayWithSize​(Matcher<? super java.lang.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 matcher type.
        Parameters:
        sizeMatcher - a matcher for the length of an examined array
        Returns:
        The matcher.
      • arrayWithSize

        public static <E> 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 matcher type.
        Parameters:
        size - the length that an examined array must have for a positive match
        Returns:
        The matcher.
      • emptyArray

        public static <E> 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 matcher type.
        Returns:
        The matcher.
      • aMapWithSize

        public static <K,​V> Matcher<java.util.Map<? extends K,​? extends V>> aMapWithSize​(Matcher<? super java.lang.Integer> sizeMatcher)
        Creates a matcher for Maps that matches when the size() method returns a value that satisfies the specified matcher. For example:
        assertThat(myMap, is(aMapWithSize(equalTo(2))))
        Type Parameters:
        K - the map key type.
        V - the map value type.
        Parameters:
        sizeMatcher - a matcher for the size of an examined Map
        Returns:
        The matcher.
      • aMapWithSize

        public static <K,​V> Matcher<java.util.Map<? extends K,​? extends V>> aMapWithSize​(int size)
        Creates a matcher for Maps that matches when the size() method returns a value equal to the specified size. For example:
        assertThat(myMap, is(aMapWithSize(2)))
        Type Parameters:
        K - the map key type.
        V - the map value type.
        Parameters:
        size - the expected size of an examined Map
        Returns:
        The matcher.
      • anEmptyMap

        public static <K,​V> Matcher<java.util.Map<? extends K,​? extends V>> anEmptyMap()
        Creates a matcher for Maps that matches when the size() method returns zero. For example:
        assertThat(myMap, is(anEmptyMap()))
        Type Parameters:
        K - the map key type.
        V - the map value type.
        Returns:
        The matcher.
      • hasSize

        public static <E> Matcher<java.util.Collection<? extends E>> hasSize​(Matcher<? super java.lang.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 matcher type.
        Parameters:
        sizeMatcher - a matcher for the size of an examined Collection
        Returns:
        The matcher.
      • hasSize

        public static <E> Matcher<java.util.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 matcher type.
        Parameters:
        size - the expected size of an examined Collection
        Returns:
        The matcher.
      • empty

        public static <E> Matcher<java.util.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 matcher type.
        Returns:
        The matcher.
      • emptyCollectionOf

        public static <E> Matcher<java.util.Collection<E>> emptyCollectionOf​(java.lang.Class<E> unusedToForceReturnType)
        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 matcher type.
        Parameters:
        unusedToForceReturnType - the type of the collection's content
        Returns:
        The matcher.
      • emptyIterable

        public static <E> Matcher<java.lang.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 matcher type.
        Returns:
        The matcher.
      • emptyIterableOf

        public static <E> Matcher<java.lang.Iterable<E>> emptyIterableOf​(java.lang.Class<E> unusedToForceReturnType)
        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 matcher type.
        Parameters:
        unusedToForceReturnType - the type of the iterable's content
        Returns:
        The matcher.
      • contains

        @SafeVarargs
        public static <E> Matcher<java.lang.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 matcher type.
        Parameters:
        items - the items that must equal the items provided by an examined Iterable
        Returns:
        The matcher.
      • contains

        public static <E> Matcher<java.lang.Iterable<? extends E>> contains​(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 matcher type.
        Parameters:
        itemMatcher - the matcher that must be satisfied by the single item provided by an examined Iterable
        Returns:
        The matcher.
      • contains

        @SafeVarargs
        public static <E> Matcher<java.lang.Iterable<? extends E>> contains​(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 matcher type.
        Parameters:
        itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable
        Returns:
        The matcher.
      • contains

        public static <E> Matcher<java.lang.Iterable<? extends E>> contains​(java.util.List<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 matcher 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

        @SafeVarargs
        public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder​(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 matcher type.
        Parameters:
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
        Returns:
        The matcher.
      • containsInAnyOrder

        @SafeVarargs
        public static <T> Matcher<java.lang.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 matcher type.
        Parameters:
        items - the items that must equal the items provided by an examined Iterable in any order
        Returns:
        The matcher.
      • containsInAnyOrder

        public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder​(java.util.Collection<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 matcher type.
        Parameters:
        itemMatchers - a list of matchers, each of which must be satisfied by an item provided by an examined Iterable
        Returns:
        The matcher.
      • containsInRelativeOrder

        @SafeVarargs
        public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder​(E... items)
        Creates a matcher for Iterables that matches when a single pass over the examined Iterable yields a series of items, that contains items logically equal to the corresponding item in the specified items, in the same relative order For example:
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder("b", "d"))
        Type Parameters:
        E - the matcher type.
        Parameters:
        items - the items that must be contained within items provided by an examined Iterable in the same relative order
        Returns:
        The matcher.
      • containsInRelativeOrder

        @SafeVarargs
        public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder​(Matcher<? super E>... itemMatchers)
        Creates a matcher for Iterables that matches when a single pass over the examined Iterable yields a series of items, that each satisfying the corresponding matcher in the specified matchers, in the same relative order. For example:
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder(equalTo("b"), equalTo("d")))
        Type Parameters:
        E - the matcher type.
        Parameters:
        itemMatchers - the matchers that must be satisfied by the items provided by an examined Iterable in the same relative order
        Returns:
        The matcher.
      • containsInRelativeOrder

        public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder​(java.util.List<Matcher<? super E>> itemMatchers)
        Creates a matcher for Iterables that matches when a single pass over the examined Iterable yields a series of items, that contains items satisfying the corresponding matcher in the specified list of matchers, in the same relative order. For example:
        assertThat(Arrays.asList("a", "b", "c", "d", "e"), contains(Arrays.asList(equalTo("b"), equalTo("d"))))
        Type Parameters:
        E - the matcher type.
        Parameters:
        itemMatchers - a list of matchers, each of which must be satisfied by the items provided by an examined Iterable in the same relative order
        Returns:
        The matcher.
      • iterableWithSize

        public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize​(Matcher<? super java.lang.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 matcher type.
        Parameters:
        sizeMatcher - a matcher for the number of items that should be yielded by an examined Iterable
        Returns:
        The matcher.
      • iterableWithSize

        public static <E> Matcher<java.lang.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 matcher type.
        Parameters:
        size - the number of items that should be yielded by an examined Iterable
        Returns:
        The matcher.
      • hasEntry

        public static <K,​V> Matcher<java.util.Map<? extends K,​? extends V>> hasEntry​(Matcher<? super K> keyMatcher,
                                                                                                 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 map key type.
        V - the map 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.
      • hasEntry

        public static <K,​V> Matcher<java.util.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 map key type.
        V - the map 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.
      • hasKey

        public static <K> Matcher<java.util.Map<? extends K,​?>> hasKey​(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 map key type.
        Parameters:
        keyMatcher - the matcher that must be satisfied by at least one key
        Returns:
        The matcher.
      • hasKey

        public static <K> Matcher<java.util.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 map key type.
        Parameters:
        key - the key that satisfying maps must contain
        Returns:
        The matcher.
      • hasValue

        public static <V> Matcher<java.util.Map<?,​? extends V>> hasValue​(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.
      • hasValue

        public static <V> Matcher<java.util.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.
      • in

        public static <T> Matcher<T> in​(java.util.Collection<T> collection)
        Creates a matcher that matches when the examined object is found within the specified collection. For example:
        assertThat("foo", is(in(Arrays.asList("bar", "foo"))))
        Type Parameters:
        T - the matcher type.
        Parameters:
        collection - the collection in which matching items must be found
        Returns:
        The matcher.
      • in

        public static <T> Matcher<T> in​(T[] elements)
        Creates a matcher that matches when the examined object is found within the specified array. For example:
        assertThat("foo", is(in(new String[]{"bar", "foo"})))
        Type Parameters:
        T - the matcher type.
        Parameters:
        elements - the array in which matching items must be found
        Returns:
        The matcher.
      • isIn

        public static <T> Matcher<T> isIn​(java.util.Collection<T> collection)
        Deprecated.
        use is(in(...)) instead
        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 matcher type.
        Parameters:
        collection - the collection in which matching items must be found
        Returns:
        The matcher.
      • isIn

        public static <T> Matcher<T> isIn​(T[] elements)
        Deprecated.
        use is(in(...)) instead
        Creates a matcher that matches when the examined object is found within the specified array. For example:
        assertThat("foo", isIn(new String[]{"bar", "foo"}))
        Type Parameters:
        T - the matcher type.
        Parameters:
        elements - the array in which matching items must be found
        Returns:
        The matcher.
      • isOneOf

        @SafeVarargs
        public static <T> Matcher<T> isOneOf​(T... elements)
        Deprecated.
        use is(oneOf(...)) instead
        Creates a matcher that matches when the examined object is equal to one of the specified elements. For example:
        assertThat("foo", isOneOf("bar", "foo"))
        Type Parameters:
        T - the matcher type.
        Parameters:
        elements - the elements amongst which matching items will be found
        Returns:
        The matcher.
      • oneOf

        @SafeVarargs
        public static <T> Matcher<T> oneOf​(T... elements)
        Creates a matcher that matches when the examined object is equal to one of the specified elements. For example:
        assertThat("foo", is(oneOf("bar", "foo")))
        Type Parameters:
        T - the matcher type.
        Parameters:
        elements - the elements amongst which matching items will be found
        Returns:
        The matcher.
      • closeTo

        public static Matcher<java.lang.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.
      • notANumber

        public static Matcher<java.lang.Double> notANumber()
        Creates a matcher of Doubles that matches when an examined double is not a number. For example:
        assertThat(Double.NaN, is(notANumber()))
        Returns:
        The matcher.
      • closeTo

        public static Matcher<java.math.BigDecimal> closeTo​(java.math.BigDecimal operand,
                                                            java.math.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

        public static <T extends java.lang.Comparable<T>> 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 matcher type.
        Parameters:
        value - the value which, when passed to the compareTo method of the examined object, should return zero
        Returns:
        The matcher.
      • greaterThan

        public static <T extends java.lang.Comparable<T>> 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 matcher 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

        public static <T extends java.lang.Comparable<T>> 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 matcher 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

        public static <T extends java.lang.Comparable<T>> 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 matcher 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

        public static <T extends java.lang.Comparable<T>> 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 matcher 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

        public static Matcher<java.lang.String> equalToIgnoringCase​(java.lang.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

        public static Matcher<java.lang.String> equalToIgnoringWhiteSpace​(java.lang.String expectedString)
        Parameters:
        expectedString - the expected value of matched strings
        Returns:
        The matcher.
      • equalToCompressingWhiteSpace

        public static Matcher<java.lang.String> equalToCompressingWhiteSpace​(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. 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.
      • emptyOrNullString

        public static Matcher<java.lang.String> emptyOrNullString()
        Creates a matcher of String that matches when the examined string is null, or has zero length. For example:
        assertThat(((String)null), is(emptyOrNullString()))
        Returns:
        The matcher.
      • emptyString

        public static Matcher<java.lang.String> emptyString()
        Creates a matcher of String that matches when the examined string has zero length. For example:
        assertThat("", is(emptyString()))
        Returns:
        The matcher.
      • isEmptyOrNullString

        public static Matcher<java.lang.String> isEmptyOrNullString()
        Deprecated.
        use is(emptyOrNullString()) instead
        Creates a matcher of String that matches when the examined string is null, or has zero length. For example:
        assertThat(((String)null), isEmptyOrNullString())
        Returns:
        The matcher.
      • isEmptyString

        public static Matcher<java.lang.String> isEmptyString()
        Deprecated.
        use is(emptyString()) instead
        Creates a matcher of String that matches when the examined string has zero length. For example:
        assertThat("", isEmptyString())
        Returns:
        The matcher.
      • blankOrNullString

        public static Matcher<java.lang.String> blankOrNullString()
        Creates a matcher of String that matches when the examined string is null, or contains zero or more whitespace characters and nothing else. For example:
        assertThat(((String)null), is(blankOrNullString()))
        Returns:
        The matcher.
      • blankString

        public static Matcher<java.lang.String> blankString()
        Creates a matcher of String that matches when the examined string contains zero or more whitespace characters and nothing else. For example:
        assertThat("  ", is(blankString()))
        Returns:
        The matcher.
      • matchesPattern

        public static Matcher<java.lang.String> matchesPattern​(java.util.regex.Pattern pattern)
        Creates a matcher of String that matches when the examined string exactly matches the given Pattern.
        Parameters:
        pattern - the text pattern to match.
        Returns:
        The matcher.
      • matchesPattern

        public static Matcher<java.lang.String> matchesPattern​(java.lang.String regex)
        Creates a matcher of String that matches when the examined string exactly matches the given regular expression, treated as a Pattern.
        Parameters:
        regex - the regex to match.
        Returns:
        The matcher.
      • stringContainsInOrder

        public static Matcher<java.lang.String> 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, considering the order of their appearance. For example:
        assertThat("myfoobarbaz", stringContainsInOrder(Arrays.asList("bar", "foo")))
        fails as "foo" occurs before "bar" in the string "myfoobarbaz"
        Parameters:
        substrings - the substrings that must be contained within matching strings
        Returns:
        The matcher.
      • stringContainsInOrder

        public static Matcher<java.lang.String> stringContainsInOrder​(java.lang.String... substrings)
        Creates a matcher of String that matches when the examined string contains all of the specified substrings, considering the order of their appearance. For example:
        assertThat("myfoobarbaz", stringContainsInOrder("bar", "foo"))
        fails as "foo" occurs before "bar" in the string "myfoobarbaz"
        Parameters:
        substrings - the substrings that must be contained within matching strings
        Returns:
        The matcher.
      • hasLength

        public static Matcher<java.lang.CharSequence> hasLength​(Matcher<? super java.lang.Integer> lengthMatcher)
        Creates a matcher of CharSequence that matches when a char sequence has the length that satisfies the specified matcher. For example:
         assertThat("text", hasLength(lessThan(4)))
         
        Parameters:
        lengthMatcher - a matcher for the expected length of the string
        Returns:
        The matcher.
      • hasLength

        public static Matcher<java.lang.CharSequence> hasLength​(int length)
        Creates a matcher of CharSequence that matches when a char sequence has the length of the specified argument. For example:
         assertThat("text", length(4))
         
        Parameters:
        length - the expected length of the string
        Returns:
        The matcher.
      • hasToString

        public static <T> Matcher<T> 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. For example:
        assertThat(true, hasToString(equalTo("TRUE")))
        Type Parameters:
        T - the matcher type.
        Parameters:
        toStringMatcher - the matcher used to verify the toString result
        Returns:
        The matcher.
      • hasToString

        public static <T> Matcher<T> hasToString​(java.lang.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 matcher type.
        Parameters:
        expectedToString - the expected toString result
        Returns:
        The matcher.
      • typeCompatibleWith

        public static <T> Matcher<java.lang.Class<?>> typeCompatibleWith​(java.lang.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 matcher type.
        Parameters:
        baseType - the base class to examine classes against
        Returns:
        The matcher.
      • eventFrom

        public static Matcher<java.util.EventObject> 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. 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

        public static Matcher<java.util.EventObject> eventFrom​(java.lang.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

        public static <T> Matcher<T> hasProperty​(java.lang.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 matcher type.
        Parameters:
        propertyName - the name of the JavaBean property that examined beans should possess
        Returns:
        The matcher.
      • hasProperty

        public static <T> Matcher<T> 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. For example:
        assertThat(myBean, hasProperty("foo", equalTo("bar"))
        Type Parameters:
        T - the matcher 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

        public static <B> Matcher<B> samePropertyValuesAs​(B expectedBean,
                                                          java.lang.String... ignoredProperties)
        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. If any properties are marked as ignored, they will be dropped from both the expected and actual bean. Note that the ignored properties use JavaBean display names, for example
        age
        rather than method names such as
        getAge
        . For example:
        assertThat(myBean, samePropertyValuesAs(myExpectedBean))
        assertThat(myBean, samePropertyValuesAs(myExpectedBean), "age", "height")
        Type Parameters:
        B - the matcher type.
        Parameters:
        expectedBean - the bean against which examined beans are compared
        ignoredProperties - do not check any of these named properties.
        Returns:
        The matcher.
      • hasXPath

        public static Matcher<org.w3c.dom.Node> hasXPath​(java.lang.String xPath,
                                                         Matcher<java.lang.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.
      • hasXPath

        public static Matcher<org.w3c.dom.Node> hasXPath​(java.lang.String xPath,
                                                         javax.xml.namespace.NamespaceContext namespaceContext,
                                                         Matcher<java.lang.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

        public static Matcher<org.w3c.dom.Node> hasXPath​(java.lang.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

        public static Matcher<org.w3c.dom.Node> hasXPath​(java.lang.String xPath,
                                                         javax.xml.namespace.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.