Class Matchers
- java.lang.Object
-
- org.hamcrest.Matchers
-
public class Matchers extends java.lang.Object
-
-
Constructor Summary
Constructors Constructor Description Matchers()
-
Method Summary
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 forMap
s that matches when thesize()
method returns a value equal to the specifiedsize
.static <K,V>
Matcher<java.util.Map<? extends K,? extends V>>aMapWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
Creates a matcher forMap
s that matches when thesize()
method returns a value that satisfies the specified matcher.static <K,V>
Matcher<java.util.Map<? extends K,? extends V>>anEmptyMap()
Creates a matcher forMap
s that matches when thesize()
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 specifiedtype
, as determined by calling theClass.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 specifiedString
.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 thelength
of the array equals the specifiedsize
.static <E> Matcher<E[]>
arrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
Creates a matcher for arrays that matches when thelength
of the array satisfies the specified matcher.static Matcher<java.lang.String>
blankOrNullString()
Creates a matcher ofString
that matches when the examined string isnull
, or contains zero or more whitespace characters and nothing else.static Matcher<java.lang.String>
blankString()
Creates a matcher ofString
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 ofDouble
s that matches when an examined double is equal to the specifiedoperand
, within a range of +/-error
.static Matcher<java.math.BigDecimal>
closeTo(java.math.BigDecimal operand, java.math.BigDecimal error)
Creates a matcher ofBigDecimal
s that matches when an examined BigDecimal is equal to the specifiedoperand
, within a range of +/-error
.static <T extends java.lang.Comparable<T>>
Matcher<T>comparesEqualTo(T value)
Creates a matcher ofComparable
object that matches when the examined object is equal to the specified value, as reported by thecompareTo
method of the examined object.static <E> Matcher<java.lang.Iterable<? extends E>>
contains(E... items)
Creates a matcher forIterable
s that matches when a single pass over the examinedIterable
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 forIterable
s that matches when a single pass over the examinedIterable
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 forIterable
s that matches when a single pass over the examinedIterable
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 forIterable
s that matches when a single pass over the examinedIterable
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 forIterable
s that matches when a single pass over the examinedIterable
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 forIterable
s that matches when a single pass over the examinedIterable
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 forIterable
s that matches when a single pass over the examinedIterable
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 forIterable
s that matches when a single pass over the examinedIterable
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 forIterable
s that matches when a single pass over the examinedIterable
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 forIterable
s that matches when a single pass over the examinedIterable
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 examinedString
contains the specifiedString
anywhere.static Matcher<java.lang.String>
containsStringIgnoringCase(java.lang.String substring)
Creates a matcher that matches if the examinedString
contains the specifiedString
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 forCollection
s matching examined collections whoseisEmpty
method returnstrue
.static <E> Matcher<E[]>
emptyArray()
Creates a matcher for arrays that matches when thelength
of the array is zero.static <E> Matcher<java.util.Collection<E>>
emptyCollectionOf(java.lang.Class<E> unusedToForceReturnType)
Creates a matcher forCollection
s matching examined collections whoseisEmpty
method returnstrue
.static <E> Matcher<java.lang.Iterable<? extends E>>
emptyIterable()
Creates a matcher forIterable
s matching examined iterables that yield no items.static <E> Matcher<java.lang.Iterable<E>>
emptyIterableOf(java.lang.Class<E> unusedToForceReturnType)
Creates a matcher forIterable
s matching examined iterables that yield no items.static Matcher<java.lang.String>
emptyOrNullString()
Creates a matcher ofString
that matches when the examined string isnull
, or has zero length.static Matcher<java.lang.String>
emptyString()
Creates a matcher ofString
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 examinedString
ends with the specifiedString
.static Matcher<java.lang.String>
endsWithIgnoringCase(java.lang.String suffix)
Creates a matcher that matches if the examinedString
ends with the specifiedString
, ignoring case.static <T> Matcher<T>
equalTo(T operand)
Creates a matcher that matches when the examined object is logically equal to the specifiedoperand
, as determined by calling theObject.equals(java.lang.Object)
method on the examined object.static Matcher<java.lang.String>
equalToCompressingWhiteSpace(java.lang.String expectedString)
Creates a matcher ofString
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 ofString
that matches when the examined string is equal to the specified expectedString, ignoring case.static Matcher<java.lang.String>
equalToIgnoringWhiteSpace(java.lang.String expectedString)
Deprecated.static Matcher<java.lang.Object>
equalToObject(java.lang.Object operand)
Creates anIsEqual
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 ofEventObject
that matches any object derived from eventClass announced by source.static Matcher<java.util.EventObject>
eventFrom(java.lang.Object source)
Creates a matcher ofEventObject
that matches any EventObject announced by source.static <U> Matcher<java.lang.Iterable<? extends U>>
everyItem(Matcher<U> itemMatcher)
Creates a matcher forIterable
s that only matches when a single pass over the examinedIterable
yields items that are all matched by the specifieditemMatcher
.static <T extends java.lang.Comparable<T>>
Matcher<T>greaterThan(T value)
Creates a matcher ofComparable
object that matches when the examined object is greater than the specified value, as reported by thecompareTo
method of the examined object.static <T extends java.lang.Comparable<T>>
Matcher<T>greaterThanOrEqualTo(T value)
Creates a matcher ofComparable
object that matches when the examined object is greater than or equal to the specified value, as reported by thecompareTo
method of the examined object.static <K,V>
Matcher<java.util.Map<? extends K,? extends V>>hasEntry(K key, V value)
Creates a matcher forMap
s matching when the examinedMap
contains at least one entry whose key equals the specifiedkey
and whose value equals the specifiedvalue
.static <K,V>
Matcher<java.util.Map<? extends K,? extends V>>hasEntry(Matcher<? super K> keyMatcher, Matcher<? super V> valueMatcher)
Creates a matcher forMap
s matching when the examinedMap
contains at least one entry whose key satisfies the specifiedkeyMatcher
and whose value satisfies the specifiedvalueMatcher
.static <T> Matcher<java.lang.Iterable<? super T>>
hasItem(Matcher<? super T> itemMatcher)
Creates a matcher forIterable
s that only matches when a single pass over the examinedIterable
yields at least one item that is matched by the specifieditemMatcher
.static <T> Matcher<java.lang.Iterable<? super T>>
hasItem(T item)
Creates a matcher forIterable
s that only matches when a single pass over the examinedIterable
yields at least one item that is equal to the specifieditem
.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 specifiedelementMatcher
.static <T> Matcher<T[]>
hasItemInArray(T element)
A shortcut to the frequently usedhasItemInArray(equalTo(x))
.static <T> Matcher<java.lang.Iterable<T>>
hasItems(Matcher<? super T>... itemMatchers)
Creates a matcher forIterable
s that matches when consecutive passes over the examinedIterable
yield at least one item that is matched by the corresponding matcher from the specifieditemMatchers
.static <T> Matcher<java.lang.Iterable<T>>
hasItems(T... items)
Creates a matcher forIterable
s that matches when consecutive passes over the examinedIterable
yield at least one item that is equal to the corresponding item from the specifieditems
.static <K> Matcher<java.util.Map<? extends K,?>>
hasKey(K key)
Creates a matcher forMap
s matching when the examinedMap
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 forMap
s matching when the examinedMap
contains at least one key that satisfies the specified matcher.static Matcher<java.lang.CharSequence>
hasLength(int length)
Creates a matcher ofCharSequence
that matches when a char sequence has the length of the specifiedargument
.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 forCollection
s that matches when thesize()
method returns a value equal to the specifiedsize
.static <E> Matcher<java.util.Collection<? extends E>>
hasSize(Matcher<? super java.lang.Integer> sizeMatcher)
Creates a matcher forCollection
s that matches when thesize()
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 whosetoString
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 whosetoString
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 forMap
s matching when the examinedMap
contains at least one value that satisfies the specified valueMatcher.static <V> Matcher<java.util.Map<?,? extends V>>
hasValue(V value)
Creates a matcher forMap
s matching when the examinedMap
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 ofNode
s that matches when the examined node contains a node at the specifiedxPath
, with any content.static Matcher<org.w3c.dom.Node>
hasXPath(java.lang.String xPath, javax.xml.namespace.NamespaceContext namespaceContext)
Creates a matcher ofNode
s that matches when the examined node contains a node at the specifiedxPath
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 ofNode
s that matches when the examined node has a value at the specifiedxPath
, within the specifiednamespaceContext
, that satisfies the specifiedvalueMatcher
.static Matcher<org.w3c.dom.Node>
hasXPath(java.lang.String xPath, Matcher<java.lang.String> valueMatcher)
Creates a matcher ofNode
s that matches when the examined node has a value at the specifiedxPath
that satisfies the specifiedvalueMatcher
.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 specifiedtype
, as determined by calling theClass.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 usedis(equalTo(x))
.static <T> Matcher<T>
isA(java.lang.Class<?> type)
A shortcut to the frequently usedis(instanceOf(SomeClass.class))
.static Matcher<java.lang.String>
isEmptyOrNullString()
Deprecated.use is(emptyOrNullString()) insteadstatic Matcher<java.lang.String>
isEmptyString()
Deprecated.use is(emptyString()) insteadstatic <T> Matcher<T>
isIn(java.util.Collection<T> collection)
Deprecated.use is(in(...)) insteadstatic <T> Matcher<T>
isIn(T[] elements)
Deprecated.use is(in(...)) insteadstatic <T> Matcher<T>
isOneOf(T... elements)
Deprecated.use is(oneOf(...)) insteadstatic <E> Matcher<java.lang.Iterable<E>>
iterableWithSize(int size)
Creates a matcher forIterable
s that matches when a single pass over the examinedIterable
yields an item count that is equal to the specifiedsize
argument.static <E> Matcher<java.lang.Iterable<E>>
iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
Creates a matcher forIterable
s that matches when a single pass over the examinedIterable
yields an item count that satisfies the specified matcher.static <T extends java.lang.Comparable<T>>
Matcher<T>lessThan(T value)
Creates a matcher ofComparable
object that matches when the examined object is less than the specified value, as reported by thecompareTo
method of the examined object.static <T extends java.lang.Comparable<T>>
Matcher<T>lessThanOrEqualTo(T value)
Creates a matcher ofComparable
object that matches when the examined object is less than or equal to the specified value, as reported by thecompareTo
method of the examined object.static Matcher<java.lang.String>
matchesPattern(java.lang.String regex)
Creates a matcher ofString
that matches when the examined string exactly matches the given regular expression, treated as aPattern
.static Matcher<java.lang.String>
matchesPattern(java.util.regex.Pattern pattern)
Creates a matcher ofString
that matches when the examined string exactly matches the givenPattern
.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 aPattern
.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 usednot(equalTo(x))
.static Matcher<java.lang.Double>
notANumber()
Creates a matcher ofDouble
s that matches when an examined double is not a number.static Matcher<java.lang.Object>
notNullValue()
A shortcut to the frequently usednot(nullValue())
.static <T> Matcher<T>
notNullValue(java.lang.Class<T> type)
A shortcut to the frequently usednot(nullValue(X.class)).
static Matcher<java.lang.Object>
nullValue()
Creates a matcher that matches if examined object isnull
.static <T> Matcher<T>
nullValue(java.lang.Class<T> type)
Creates a matcher that matches if examined object isnull
.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 examinedString
starts with the specifiedString
.static Matcher<java.lang.String>
startsWithIgnoringCase(java.lang.String prefix)
Creates a matcher that matches if the examinedString
starts with the specifiedString
, ignoring casestatic Matcher<java.lang.String>
stringContainsInOrder(java.lang.Iterable<java.lang.String> substrings)
Creates a matcher ofString
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 ofString
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 ofClass
that matches when the specified baseType is assignable from the examined class.
-
-
-
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")))
-
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")))
-
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")))
-
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")))
-
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")))
-
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")))
-
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")))
-
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")))
-
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")))
-
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")))
-
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")))
-
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")))
-
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")))
-
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")))
-
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")))
-
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")))
-
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())
- Parameters:
description
- the new description for the wrapped matchermatcher
- the matcher to wrapvalues
- optional values to insert into the tokenized description
-
everyItem
public static <U> Matcher<java.lang.Iterable<? extends U>> everyItem(Matcher<U> itemMatcher)
Creates a matcher forIterable
s that only matches when a single pass over the examinedIterable
yields items that are all matched by the specifieditemMatcher
. For example:assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))
- Parameters:
itemMatcher
- the matcher to apply to every item provided by the examinedIterable
-
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))
-
is
public static <T> Matcher<T> is(T value)
A shortcut to the frequently usedis(equalTo(x))
. For example:assertThat(cheese, is(smelly))
instead of:assertThat(cheese, is(equalTo(smelly)))
-
isA
public static <T> Matcher<T> isA(java.lang.Class<?> type)
A shortcut to the frequently usedis(instanceOf(SomeClass.class))
. For example:assertThat(cheese, isA(Cheddar.class))
instead of:assertThat(cheese, is(instanceOf(Cheddar.class)))
-
anything
public static Matcher<java.lang.Object> anything()
Creates a matcher that always matches, regardless of the examined object.
-
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 specifiedString
.- Parameters:
description
- a meaningfulString
used when describing itself
-
hasItem
public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
Creates a matcher forIterable
s that only matches when a single pass over the examinedIterable
yields at least one item that is matched by the specifieditemMatcher
. Whilst matching, the traversal of the examinedIterable
will stop as soon as a matching item is found. For example:assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))
- Parameters:
itemMatcher
- the matcher to apply to items provided by the examinedIterable
-
hasItem
public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
Creates a matcher forIterable
s that only matches when a single pass over the examinedIterable
yields at least one item that is equal to the specifieditem
. Whilst matching, the traversal of the examinedIterable
will stop as soon as a matching item is found. For example:assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))
- Parameters:
item
- the item to compare against the items provided by the examinedIterable
-
hasItems
@SafeVarargs public static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
Creates a matcher forIterable
s that matches when consecutive passes over the examinedIterable
yield at least one item that is matched by the corresponding matcher from the specifieditemMatchers
. Whilst matching, each traversal of the examinedIterable
will stop as soon as a matching item is found. For example:assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))
- Parameters:
itemMatchers
- the matchers to apply to items provided by the examinedIterable
-
hasItems
@SafeVarargs public static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
Creates a matcher forIterable
s that matches when consecutive passes over the examinedIterable
yield at least one item that is equal to the corresponding item from the specifieditems
. Whilst matching, each traversal of the examinedIterable
will stop as soon as a matching item is found. For example:assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))
- Parameters:
items
- the items to compare against the items provided by the examinedIterable
-
equalTo
public static <T> Matcher<T> equalTo(T operand)
Creates a matcher that matches when the examined object is logically equal to the specifiedoperand
, as determined by calling theObject.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'sequals
method returnstrue
when passed anull
(which would be a violation of theequals
contract), unless the examined object itself isnull
, in which case the matcher will return a positive match.The created matcher provides a special behaviour when examining
For example:Array
s, 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.assertThat("foo", equalTo("foo")); assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
-
equalToObject
public static Matcher<java.lang.Object> equalToObject(java.lang.Object operand)
Creates anIsEqual
matcher that does not enforce the values being compared to be of the same static type.
-
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 specifiedtype
, as determined by calling theClass.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
For example:with(any(Thing.class))
assertThat(new Canoe(), instanceOf(Canoe.class));
-
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 specifiedtype
, as determined by calling theClass.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));
-
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))))
- Parameters:
matcher
- the matcher whose sense should be inverted
-
not
public static <T> Matcher<T> not(T value)
A shortcut to the frequently usednot(equalTo(x))
. For example:assertThat(cheese, is(not(smelly)))
instead of:assertThat(cheese, is(not(equalTo(smelly))))
- Parameters:
value
- the value that any examined object should not equal
-
notNullValue
public static Matcher<java.lang.Object> notNullValue()
A shortcut to the frequently usednot(nullValue())
. For example:assertThat(cheese, is(notNullValue()))
instead of:assertThat(cheese, is(not(nullValue())))
-
notNullValue
public static <T> Matcher<T> notNullValue(java.lang.Class<T> type)
A shortcut to the frequently usednot(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))))
- Parameters:
type
- dummy parameter used to infer the generic type of the returned matcher
-
nullValue
public static Matcher<java.lang.Object> nullValue()
Creates a matcher that matches if examined object isnull
. For example:assertThat(cheese, is(nullValue())
-
nullValue
public static <T> Matcher<T> nullValue(java.lang.Class<T> type)
Creates a matcher that matches if examined object isnull
. Accepts a single dummy argument to facilitate type inference. For example:assertThat(cheese, is(nullValue(Cheese.class))
- Parameters:
type
- dummy parameter used to infer the generic type of the returned 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.- Parameters:
target
- the target instance against which others should be assessed
-
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.- Parameters:
target
- the target instance against which others should be assessed
-
containsString
public static Matcher<java.lang.String> containsString(java.lang.String substring)
Creates a matcher that matches if the examinedString
contains the specifiedString
anywhere. For example:assertThat("myStringOfNote", containsString("ring"))
- Parameters:
substring
- the substring that the returned matcher will expect to find within any examined string
-
containsStringIgnoringCase
public static Matcher<java.lang.String> containsStringIgnoringCase(java.lang.String substring)
Creates a matcher that matches if the examinedString
contains the specifiedString
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
-
startsWith
public static Matcher<java.lang.String> startsWith(java.lang.String prefix)
Creates a matcher that matches if the examined
For example:String
starts with the specifiedString
.assertThat("myStringOfNote", startsWith("my"))
- Parameters:
prefix
- the substring that the returned matcher will expect at the start of any examined string
-
startsWithIgnoringCase
public static Matcher<java.lang.String> startsWithIgnoringCase(java.lang.String prefix)
Creates a matcher that matches if the examined
For example:String
starts with the specifiedString
, ignoring caseassertThat("myStringOfNote", startsWithIgnoringCase("My"))
- Parameters:
prefix
- the substring that the returned matcher will expect at the start of any examined string
-
endsWith
public static Matcher<java.lang.String> endsWith(java.lang.String suffix)
Creates a matcher that matches if the examinedString
ends with the specifiedString
. For example:assertThat("myStringOfNote", endsWith("Note"))
- Parameters:
suffix
- the substring that the returned matcher will expect at the end of any examined string
-
endsWithIgnoringCase
public static Matcher<java.lang.String> endsWithIgnoringCase(java.lang.String suffix)
Creates a matcher that matches if the examinedString
ends with the specifiedString
, 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
-
matchesRegex
public static Matcher<java.lang.String> matchesRegex(java.util.regex.Pattern pattern)
Validate a string with aPattern
.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))))
- Parameters:
elementMatchers
- the matchers that the elements of examined arrays should satisfy
-
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 specifiedelementMatcher
. 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")))
- Parameters:
elementMatcher
- the matcher to apply to elements in examined arrays
-
hasItemInArray
public static <T> Matcher<T[]> hasItemInArray(T element)
A shortcut to the frequently usedhasItemInArray(equalTo(x))
. For example:assertThat(hasItemInArray(x))
instead of:assertThat(hasItemInArray(equalTo(x)))
- Parameters:
element
- the element that should be present in examined arrays
-
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"))
- Parameters:
items
- the items that must equal the items within an examined array
-
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")))
- Parameters:
itemMatchers
- the matchers that must be satisfied by the items in the examined array
-
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"))))
- Parameters:
itemMatchers
- a list of matchers, each of which must be satisfied by the corresponding item in an examined array
-
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")))
- Parameters:
itemMatchers
- a list of matchers, each of which must be satisfied by an entry in an examined array
-
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"))))
- Parameters:
itemMatchers
- a list of matchers, each of which must be satisfied by an item provided by an examined array
-
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"))
- Parameters:
items
- the items that must equal the entries of an examined array, in any order
-
arrayWithSize
public static <E> Matcher<E[]> arrayWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
Creates a matcher for arrays that matches when thelength
of the array satisfies the specified matcher. For example:assertThat(new String[]{"foo", "bar"}, arrayWithSize(equalTo(2)))
- Parameters:
sizeMatcher
- a matcher for the length of an examined array
-
arrayWithSize
public static <E> Matcher<E[]> arrayWithSize(int size)
Creates a matcher for arrays that matches when thelength
of the array equals the specifiedsize
. For example:assertThat(new String[]{"foo", "bar"}, arrayWithSize(2))
- Parameters:
size
- the length that an examined array must have for a positive match
-
emptyArray
public static <E> Matcher<E[]> emptyArray()
Creates a matcher for arrays that matches when thelength
of the array is zero. For example:assertThat(new String[0], emptyArray())
-
aMapWithSize
public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
Creates a matcher forMap
s that matches when thesize()
method returns a value that satisfies the specified matcher. For example:assertThat(myMap, is(aMapWithSize(equalTo(2))))
- Parameters:
sizeMatcher
- a matcher for the size of an examinedMap
-
aMapWithSize
public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(int size)
Creates a matcher forMap
s that matches when thesize()
method returns a value equal to the specifiedsize
. For example:assertThat(myMap, is(aMapWithSize(2)))
- Parameters:
size
- the expected size of an examinedMap
-
anEmptyMap
public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> anEmptyMap()
Creates a matcher forMap
s that matches when thesize()
method returns zero. For example:assertThat(myMap, is(anEmptyMap()))
-
hasSize
public static <E> Matcher<java.util.Collection<? extends E>> hasSize(Matcher<? super java.lang.Integer> sizeMatcher)
Creates a matcher forCollection
s that matches when thesize()
method returns a value that satisfies the specified matcher. For example:assertThat(Arrays.asList("foo", "bar"), hasSize(equalTo(2)))
- Parameters:
sizeMatcher
- a matcher for the size of an examinedCollection
-
hasSize
public static <E> Matcher<java.util.Collection<? extends E>> hasSize(int size)
Creates a matcher forCollection
s that matches when thesize()
method returns a value equal to the specifiedsize
. For example:assertThat(Arrays.asList("foo", "bar"), hasSize(2))
- Parameters:
size
- the expected size of an examinedCollection
-
empty
public static <E> Matcher<java.util.Collection<? extends E>> empty()
Creates a matcher forCollection
s matching examined collections whoseisEmpty
method returnstrue
. For example:assertThat(new ArrayList<String>(), is(empty()))
-
emptyCollectionOf
public static <E> Matcher<java.util.Collection<E>> emptyCollectionOf(java.lang.Class<E> unusedToForceReturnType)
Creates a matcher forCollection
s matching examined collections whoseisEmpty
method returnstrue
. For example:assertThat(new ArrayList<String>(), is(emptyCollectionOf(String.class)))
- Parameters:
unusedToForceReturnType
- the type of the collection's content
-
emptyIterable
public static <E> Matcher<java.lang.Iterable<? extends E>> emptyIterable()
Creates a matcher forIterable
s matching examined iterables that yield no items. For example:assertThat(new ArrayList<String>(), is(emptyIterable()))
-
emptyIterableOf
public static <E> Matcher<java.lang.Iterable<E>> emptyIterableOf(java.lang.Class<E> unusedToForceReturnType)
Creates a matcher forIterable
s matching examined iterables that yield no items. For example:assertThat(new ArrayList<String>(), is(emptyIterableOf(String.class)))
- Parameters:
unusedToForceReturnType
- the type of the iterable's content
-
contains
@SafeVarargs public static <E> Matcher<java.lang.Iterable<? extends E>> contains(E... items)
Creates a matcher forIterable
s that matches when a single pass over the examinedIterable
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"))
- Parameters:
items
- the items that must equal the items provided by an examinedIterable
-
contains
public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E> itemMatcher)
Creates a matcher forIterable
s that matches when a single pass over the examinedIterable
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")))
- Parameters:
itemMatcher
- the matcher that must be satisfied by the single item provided by an examinedIterable
-
contains
@SafeVarargs public static <E> Matcher<java.lang.Iterable<? extends E>> contains(Matcher<? super E>... itemMatchers)
Creates a matcher forIterable
s that matches when a single pass over the examinedIterable
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")))
- Parameters:
itemMatchers
- the matchers that must be satisfied by the items provided by an examinedIterable
-
contains
public static <E> Matcher<java.lang.Iterable<? extends E>> contains(java.util.List<Matcher<? super E>> itemMatchers)
Creates a matcher forIterable
s that matches when a single pass over the examinedIterable
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"))))
- Parameters:
itemMatchers
- a list of matchers, each of which must be satisfied by the corresponding item provided by an examinedIterable
-
containsInAnyOrder
@SafeVarargs public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(Matcher<? super T>... itemMatchers)
Creates an order agnostic matcher for
Iterable
s that matches when a single pass over the examinedIterable
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")))
- Parameters:
itemMatchers
- a list of matchers, each of which must be satisfied by an item provided by an examinedIterable
-
containsInAnyOrder
@SafeVarargs public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(T... items)
Creates an order agnostic matcher for
Iterable
s that matches when a single pass over the examinedIterable
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"))
- Parameters:
items
- the items that must equal the items provided by an examinedIterable
in any order
-
containsInAnyOrder
public static <T> Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers)
Creates an order agnostic matcher for
Iterable
s that matches when a single pass over the examinedIterable
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"))))
- Parameters:
itemMatchers
- a list of matchers, each of which must be satisfied by an item provided by an examinedIterable
-
containsInRelativeOrder
@SafeVarargs public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(E... items)
Creates a matcher forIterable
s that matches when a single pass over the examinedIterable
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"))
- Parameters:
items
- the items that must be contained within items provided by an examinedIterable
in the same relative order
-
containsInRelativeOrder
@SafeVarargs public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(Matcher<? super E>... itemMatchers)
Creates a matcher forIterable
s that matches when a single pass over the examinedIterable
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")))
- Parameters:
itemMatchers
- the matchers that must be satisfied by the items provided by an examinedIterable
in the same relative order
-
containsInRelativeOrder
public static <E> Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(java.util.List<Matcher<? super E>> itemMatchers)
Creates a matcher forIterable
s that matches when a single pass over the examinedIterable
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"))))
- Parameters:
itemMatchers
- a list of matchers, each of which must be satisfied by the items provided by an examinedIterable
in the same relative order
-
iterableWithSize
public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(Matcher<? super java.lang.Integer> sizeMatcher)
Creates a matcher forIterable
s that matches when a single pass over the examinedIterable
yields an item count that satisfies the specified matcher. For example:assertThat(Arrays.asList("foo", "bar"), iterableWithSize(equalTo(2)))
- Parameters:
sizeMatcher
- a matcher for the number of items that should be yielded by an examinedIterable
-
iterableWithSize
public static <E> Matcher<java.lang.Iterable<E>> iterableWithSize(int size)
Creates a matcher forIterable
s that matches when a single pass over the examinedIterable
yields an item count that is equal to the specifiedsize
argument. For example:assertThat(Arrays.asList("foo", "bar"), iterableWithSize(2))
- Parameters:
size
- the number of items that should be yielded by an examinedIterable
-
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 forMap
s matching when the examinedMap
contains at least one entry whose key satisfies the specifiedkeyMatcher
and whose value satisfies the specifiedvalueMatcher
. For example:assertThat(myMap, hasEntry(equalTo("bar"), equalTo("foo")))
- Parameters:
keyMatcher
- the key matcher that, in combination with the valueMatcher, must be satisfied by at least one entryvalueMatcher
- the value matcher that, in combination with the keyMatcher, must be satisfied by at least one entry
-
hasEntry
public static <K,V> Matcher<java.util.Map<? extends K,? extends V>> hasEntry(K key, V value)
Creates a matcher forMap
s matching when the examinedMap
contains at least one entry whose key equals the specifiedkey
and whose value equals the specifiedvalue
. For example:assertThat(myMap, hasEntry("bar", "foo"))
- Parameters:
key
- the key that, in combination with the value, must be describe at least one entryvalue
- the value that, in combination with the key, must be describe at least one entry
-
hasKey
public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(Matcher<? super K> keyMatcher)
Creates a matcher forMap
s matching when the examinedMap
contains at least one key that satisfies the specified matcher. For example:assertThat(myMap, hasKey(equalTo("bar")))
- Parameters:
keyMatcher
- the matcher that must be satisfied by at least one key
-
hasKey
public static <K> Matcher<java.util.Map<? extends K,?>> hasKey(K key)
Creates a matcher forMap
s matching when the examinedMap
contains at least one key that is equal to the specified key. For example:assertThat(myMap, hasKey("bar"))
- Parameters:
key
- the key that satisfying maps must contain
-
hasValue
public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(Matcher<? super V> valueMatcher)
Creates a matcher forMap
s matching when the examinedMap
contains at least one value that satisfies the specified valueMatcher. For example:assertThat(myMap, hasValue(equalTo("foo")))
- Parameters:
valueMatcher
- the matcher that must be satisfied by at least one value
-
hasValue
public static <V> Matcher<java.util.Map<?,? extends V>> hasValue(V value)
Creates a matcher forMap
s matching when the examinedMap
contains at least one value that is equal to the specified value. For example:assertThat(myMap, hasValue("foo"))
- Parameters:
value
- the value that satisfying maps must contain
-
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"))))
- Parameters:
collection
- the collection in which matching items must be found
-
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"})))
- Parameters:
elements
- the array in which matching items must be found
-
isIn
public static <T> Matcher<T> isIn(java.util.Collection<T> collection)
Deprecated.use is(in(...)) insteadCreates a matcher that matches when the examined object is found within the specified collection. For example:assertThat("foo", isIn(Arrays.asList("bar", "foo")))
- Parameters:
collection
- the collection in which matching items must be found
-
isIn
public static <T> Matcher<T> isIn(T[] elements)
Deprecated.use is(in(...)) insteadCreates a matcher that matches when the examined object is found within the specified array. For example:assertThat("foo", isIn(new String[]{"bar", "foo"}))
- Parameters:
elements
- the array in which matching items must be found
-
isOneOf
@SafeVarargs public static <T> Matcher<T> isOneOf(T... elements)
Deprecated.use is(oneOf(...)) insteadCreates a matcher that matches when the examined object is equal to one of the specified elements. For example:assertThat("foo", isOneOf("bar", "foo"))
- Parameters:
elements
- the elements amongst which matching items will be found
-
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")))
- Parameters:
elements
- the elements amongst which matching items will be found
-
closeTo
public static Matcher<java.lang.Double> closeTo(double operand, double error)
Creates a matcher ofDouble
s that matches when an examined double is equal to the specifiedoperand
, within a range of +/-error
. For example:assertThat(1.03, is(closeTo(1.0, 0.03)))
- Parameters:
operand
- the expected value of matching doubleserror
- the delta (+/-) within which matches will be allowed
-
notANumber
public static Matcher<java.lang.Double> notANumber()
Creates a matcher ofDouble
s that matches when an examined double is not a number. For example:assertThat(Double.NaN, is(notANumber()))
-
closeTo
public static Matcher<java.math.BigDecimal> closeTo(java.math.BigDecimal operand, java.math.BigDecimal error)
Creates a matcher ofBigDecimal
s that matches when an examined BigDecimal is equal to the specifiedoperand
, within a range of +/-error
. The comparison for equality is done by BigDecimalsBigDecimal.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 BigDecimalserror
- the delta (+/-) within which matches will be allowed
-
comparesEqualTo
public static <T extends java.lang.Comparable<T>> Matcher<T> comparesEqualTo(T value)
Creates a matcher ofComparable
object that matches when the examined object is equal to the specified value, as reported by thecompareTo
method of the examined object. For example:assertThat(1, comparesEqualTo(1))
- Parameters:
value
- the value which, when passed to the compareTo method of the examined object, should return zero
-
greaterThan
public static <T extends java.lang.Comparable<T>> Matcher<T> greaterThan(T value)
Creates a matcher ofComparable
object that matches when the examined object is greater than the specified value, as reported by thecompareTo
method of the examined object. For example:assertThat(2, greaterThan(1))
- Parameters:
value
- the value which, when passed to the compareTo method of the examined object, should return greater than zero
-
greaterThanOrEqualTo
public static <T extends java.lang.Comparable<T>> Matcher<T> greaterThanOrEqualTo(T value)
Creates a matcher ofComparable
object that matches when the examined object is greater than or equal to the specified value, as reported by thecompareTo
method of the examined object. For example:assertThat(1, greaterThanOrEqualTo(1))
- Parameters:
value
- the value which, when passed to the compareTo method of the examined object, should return greater than or equal to zero
-
lessThan
public static <T extends java.lang.Comparable<T>> Matcher<T> lessThan(T value)
Creates a matcher ofComparable
object that matches when the examined object is less than the specified value, as reported by thecompareTo
method of the examined object. For example:assertThat(1, lessThan(2))
- Parameters:
value
- the value which, when passed to the compareTo method of the examined object, should return less than zero
-
lessThanOrEqualTo
public static <T extends java.lang.Comparable<T>> Matcher<T> lessThanOrEqualTo(T value)
Creates a matcher ofComparable
object that matches when the examined object is less than or equal to the specified value, as reported by thecompareTo
method of the examined object. For example:assertThat(1, lessThanOrEqualTo(1))
- Parameters:
value
- the value which, when passed to the compareTo method of the examined object, should return less than or equal to zero
-
equalToIgnoringCase
public static Matcher<java.lang.String> equalToIgnoringCase(java.lang.String expectedString)
Creates a matcher ofString
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
-
equalToIgnoringWhiteSpace
public static Matcher<java.lang.String> equalToIgnoringWhiteSpace(java.lang.String expectedString)
Deprecated.- Parameters:
expectedString
- the expected value of matched strings
-
equalToCompressingWhiteSpace
public static Matcher<java.lang.String> equalToCompressingWhiteSpace(java.lang.String expectedString)
Creates a matcher ofString
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
assertThat(" my\tfoo bar ", equalToIgnoringWhiteSpace(" my foo bar"))
- Parameters:
expectedString
- the expected value of matched strings
-
emptyOrNullString
public static Matcher<java.lang.String> emptyOrNullString()
Creates a matcher ofString
that matches when the examined string isnull
, or has zero length. For example:assertThat(((String)null), is(emptyOrNullString()))
-
emptyString
public static Matcher<java.lang.String> emptyString()
Creates a matcher ofString
that matches when the examined string has zero length. For example:assertThat("", is(emptyString()))
-
isEmptyOrNullString
public static Matcher<java.lang.String> isEmptyOrNullString()
Deprecated.use is(emptyOrNullString()) insteadCreates a matcher ofString
that matches when the examined string isnull
, or has zero length. For example:assertThat(((String)null), isEmptyOrNullString())
-
isEmptyString
public static Matcher<java.lang.String> isEmptyString()
Deprecated.use is(emptyString()) insteadCreates a matcher ofString
that matches when the examined string has zero length. For example:assertThat("", isEmptyString())
-
blankOrNullString
public static Matcher<java.lang.String> blankOrNullString()
Creates a matcher ofString
that matches when the examined string isnull
, or contains zero or more whitespace characters and nothing else. For example:assertThat(((String)null), is(blankOrNullString()))
-
blankString
public static Matcher<java.lang.String> blankString()
Creates a matcher ofString
that matches when the examined string contains zero or more whitespace characters and nothing else. For example:assertThat(" ", is(blankString()))
-
matchesPattern
public static Matcher<java.lang.String> matchesPattern(java.util.regex.Pattern pattern)
Creates a matcher ofString
that matches when the examined string exactly matches the givenPattern
.
-
matchesPattern
public static Matcher<java.lang.String> matchesPattern(java.lang.String regex)
Creates a matcher ofString
that matches when the examined string exactly matches the given regular expression, treated as aPattern
.
-
stringContainsInOrder
public static Matcher<java.lang.String> stringContainsInOrder(java.lang.Iterable<java.lang.String> substrings)
Creates a matcher ofString
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
-
stringContainsInOrder
public static Matcher<java.lang.String> stringContainsInOrder(java.lang.String... substrings)
Creates a matcher ofString
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
-
hasLength
public static Matcher<java.lang.CharSequence> hasLength(int length)
Creates a matcher ofCharSequence
that matches when a char sequence has the length of the specifiedargument
. For example:assertThat("text", length(4))
- Parameters:
length
- the expected length of the string
-
hasToString
public static <T> Matcher<T> hasToString(Matcher<? super java.lang.String> toStringMatcher)
Creates a matcher that matches any examined object whosetoString
method returns a value that satisfies the specified matcher. For example:assertThat(true, hasToString(equalTo("TRUE")))
- Parameters:
toStringMatcher
- the matcher used to verify the toString result
-
hasToString
public static <T> Matcher<T> hasToString(java.lang.String expectedToString)
Creates a matcher that matches any examined object whosetoString
method returns a value equalTo the specified string. For example:assertThat(true, hasToString("TRUE"))
- Parameters:
expectedToString
- the expected toString result
-
typeCompatibleWith
public static <T> Matcher<java.lang.Class<?>> typeCompatibleWith(java.lang.Class<T> baseType)
Creates a matcher ofClass
that matches when the specified baseType is assignable from the examined class. For example:assertThat(Integer.class, typeCompatibleWith(Number.class))
- Parameters:
baseType
- the base class to examine classes against
-
eventFrom
public static Matcher<java.util.EventObject> eventFrom(java.lang.Class<? extends java.util.EventObject> eventClass, java.lang.Object source)
Creates a matcher ofEventObject
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 onsource
- the source of the event
-
eventFrom
public static Matcher<java.util.EventObject> eventFrom(java.lang.Object source)
Creates a matcher ofEventObject
that matches any EventObject announced by source. For example:assertThat(myEvent, is(eventFrom(myBean)))
- Parameters:
source
- the source of the event
-
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"))
- Parameters:
propertyName
- the name of the JavaBean property that examined beans should possess
-
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"))
- Parameters:
propertyName
- the name of the JavaBean property that examined beans should possessvalueMatcher
- a matcher for the value of the specified property of the examined bean
-
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 exampleage
rather than method names such asgetAge
. For example:assertThat(myBean, samePropertyValuesAs(myExpectedBean))
assertThat(myBean, samePropertyValuesAs(myExpectedBean), "age", "height")
- Parameters:
expectedBean
- the bean against which examined beans are comparedignoredProperties
- do not check any of these named properties.
-
hasXPath
public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath, Matcher<java.lang.String> valueMatcher)
Creates a matcher ofNode
s that matches when the examined node has a value at the specifiedxPath
that satisfies the specifiedvalueMatcher
. For example:assertThat(xml, hasXPath("/root/something[2]/cheese", equalTo("Cheddar")))
- Parameters:
xPath
- the target xpathvalueMatcher
- matcher for the value at the specified xpath
-
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 ofNode
s that matches when the examined node has a value at the specifiedxPath
, within the specifiednamespaceContext
, that satisfies the specifiedvalueMatcher
. For example:assertThat(xml, hasXPath("/root/something[2]/cheese", myNs, equalTo("Cheddar")))
- Parameters:
xPath
- the target xpathnamespaceContext
- the namespace for matching nodesvalueMatcher
- matcher for the value at the specified xpath
-
hasXPath
public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath)
Creates a matcher ofNode
s that matches when the examined node contains a node at the specifiedxPath
, with any content. For example:assertThat(xml, hasXPath("/root/something[2]/cheese"))
- Parameters:
xPath
- the target xpath
-
hasXPath
public static Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath, javax.xml.namespace.NamespaceContext namespaceContext)
Creates a matcher ofNode
s that matches when the examined node contains a node at the specifiedxPath
within the specified namespace context, with any content. For example:assertThat(xml, hasXPath("/root/something[2]/cheese", myNs))
- Parameters:
xPath
- the target xpathnamespaceContext
- the namespace for matching nodes
-
-