| 
 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectorg.hamcrest.CoreMatchers
public class CoreMatchers
| Constructor Summary | |
|---|---|
| CoreMatchers() | |
| Method Summary | ||
|---|---|---|
| static
 | allOf(java.lang.Iterable<Matcher<? super T>> matchers)Creates a matcher that matches if the examined object matches ALL of the specified matchers. | |
| static
 | allOf(Matcher<? super T>... matchers)Creates a matcher that matches if the examined object matches ALL of the specified matchers. | |
| static
 | 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
 | 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
 | 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
 | 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
 | 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
 | 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 theClass.isInstance(Object)method on that type, passing the
 the examined object. | |
| static
 | anyOf(java.lang.Iterable<Matcher<? super T>> matchers)Creates a matcher that matches if the examined object matches ANY of the specified matchers. | |
| static
 | anyOf(Matcher<? super T>... matchers)Creates a matcher that matches if the examined object matches ANY of the specified matchers. | |
| static
 | anyOf(Matcher<T> first,
      Matcher<? super T> second)Creates a matcher that matches if the examined object matches ANY of the specified matchers. | |
| static
 | anyOf(Matcher<T> first,
      Matcher<? super T> second,
      Matcher<? super T> third)Creates a matcher that matches if the examined object matches ANY of the specified matchers. | |
| static
 | anyOf(Matcher<T> first,
      Matcher<? super T> second,
      Matcher<? super T> third,
      Matcher<? super T> fourth)Creates a matcher that matches if the examined object matches ANY of the specified matchers. | |
| static
 | anyOf(Matcher<T> first,
      Matcher<? super T> second,
      Matcher<? super T> third,
      Matcher<? super T> fourth,
      Matcher<? super T> fifth)Creates a matcher that matches if the examined object matches ANY of the specified matchers. | |
| static
 | anyOf(Matcher<T> first,
      Matcher<? super T> second,
      Matcher<? super T> third,
      Matcher<? super T> fourth,
      Matcher<? super T> fifth,
      Matcher<? super T> sixth)Creates a matcher that matches if the examined object matches ANY of the specified matchers. | |
| static Matcher<java.lang.Object> | 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
 | both(Matcher<? super LHS> matcher)Creates a matcher that matches when both of the specified matchers match the examined object. | |
| static Matcher<java.lang.String> | containsString(java.lang.String substring)Creates a matcher that matches if the examined Stringcontains the specifiedStringanywhere. | |
| static
 | describedAs(java.lang.String description,
            Matcher<T> matcher,
            java.lang.Object... values)Wraps an existing matcher, overriding its description with that specified. | |
| static
 | either(Matcher<? super LHS> matcher)Creates a matcher that matches when either of the specified matchers match the examined object. | |
| static Matcher<java.lang.String> | endsWith(java.lang.String suffix)Creates a matcher that matches if the examined Stringends with the specifiedString. | |
| static
 | equalTo(T operand)Creates a matcher that matches when the examined object is logically equal to the specified operand, as determined by calling theObject.equals(java.lang.Object)method on
 the examined object. | |
| static
 | everyItem(Matcher<U> itemMatcher)Creates a matcher for Iterables that only matches when a single pass over the
 examinedIterableyields items that are all matched by the specifieditemMatcher. | |
| static
 | hasItem(Matcher<? super T> itemMatcher)Creates a matcher for Iterables that only matches when a single pass over the
 examinedIterableyields at least one item that is matched by the specifieditemMatcher. | |
| static
 | hasItem(T item)Creates a matcher for Iterables that only matches when a single pass over the
 examinedIterableyields at least one item that is equal to the specifieditem. | |
| static
 | hasItems(Matcher<? super T>... itemMatchers)Creates a matcher for Iterables that matches when consecutive passes over the
 examinedIterableyield at least one item that is matched by the corresponding
 matcher from the specifieditemMatchers. | |
| static
 | hasItems(T... items)Creates a matcher for Iterables that matches when consecutive passes over the
 examinedIterableyield at least one item that is equal to the corresponding
 item from the specifieditems. | |
| static
 | 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 theClass.isInstance(Object)method on that type, passing the
 the examined object. | |
| static
 | is(java.lang.Class<T> type)Deprecated. use isA(Class | |
| static
 | is(Matcher<T> matcher)Decorates another Matcher, retaining its behaviour, but allowing tests to be slightly more expressive. | |
| static
 | is(T value)A shortcut to the frequently used is(equalTo(x)). | |
| static
 | isA(java.lang.Class<T> type)A shortcut to the frequently used is(instanceOf(SomeClass.class)). | |
| static
 | not(Matcher<T> matcher)Creates a matcher that wraps an existing matcher, but inverts the logic by which it will match. | |
| static
 | not(T value)A shortcut to the frequently used not(equalTo(x)). | |
| static Matcher<java.lang.Object> | notNullValue()A shortcut to the frequently used not(nullValue()). | |
| static
 | 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
 | nullValue(java.lang.Class<T> type)Creates a matcher that matches if examined object is null. | |
| static
 | sameInstance(T target)Creates a matcher that matches only when the examined object is the same instance as the specified target object. | |
| static Matcher<java.lang.String> | startsWith(java.lang.String prefix)Creates a matcher that matches if the examined Stringstarts with the specifiedString. | |
| static
 | theInstance(T target)Creates a matcher that matches only when the examined object is the same instance as the specified target object. | |
| Methods inherited from class java.lang.Object | 
|---|
| clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait | 
| Constructor Detail | 
|---|
public CoreMatchers()
| Method Detail | 
|---|
public static <T> Matcher<T> allOf(java.lang.Iterable<Matcher<? super T>> matchers)
assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
public static <T> Matcher<T> allOf(Matcher<? super T>... matchers)
assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
public static <T> Matcher<T> allOf(Matcher<? super T> first,
                                   Matcher<? super T> second)
assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
public static <T> Matcher<T> allOf(Matcher<? super T> first,
                                   Matcher<? super T> second,
                                   Matcher<? super T> third)
assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
public static <T> Matcher<T> allOf(Matcher<? super T> first,
                                   Matcher<? super T> second,
                                   Matcher<? super T> third,
                                   Matcher<? super T> fourth)
assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
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)
assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
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)
assertThat("myValue", allOf(startsWith("my"), containsString("Val")))
public static <T> AnyOf<T> anyOf(java.lang.Iterable<Matcher<? super T>> matchers)
assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
public static <T> AnyOf<T> anyOf(Matcher<T> first,
                                 Matcher<? super T> second,
                                 Matcher<? super T> third)
assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
public static <T> AnyOf<T> anyOf(Matcher<T> first,
                                 Matcher<? super T> second,
                                 Matcher<? super T> third,
                                 Matcher<? super T> fourth)
assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
public static <T> AnyOf<T> anyOf(Matcher<T> first,
                                 Matcher<? super T> second,
                                 Matcher<? super T> third,
                                 Matcher<? super T> fourth,
                                 Matcher<? super T> fifth)
assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
public static <T> AnyOf<T> anyOf(Matcher<T> first,
                                 Matcher<? super T> second,
                                 Matcher<? super T> third,
                                 Matcher<? super T> fourth,
                                 Matcher<? super T> fifth,
                                 Matcher<? super T> sixth)
assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
public static <T> AnyOf<T> anyOf(Matcher<T> first,
                                 Matcher<? super T> second)
assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
public static <T> AnyOf<T> anyOf(Matcher<? super T>... matchers)
assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))
public static <LHS> CombinableMatcher.CombinableBothMatcher<LHS> both(Matcher<? super LHS> matcher)
assertThat("fab", both(containsString("a")).and(containsString("b")))
public static <LHS> CombinableMatcher.CombinableEitherMatcher<LHS> either(Matcher<? super LHS> matcher)
assertThat("fan", either(containsString("a")).and(containsString("b")))
public static <T> Matcher<T> describedAs(java.lang.String description,
                                         Matcher<T> matcher,
                                         java.lang.Object... values)
describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())
description - the new description for the wrapped matchermatcher - the matcher to wrapvalues - optional values to insert into the tokenised descriptionpublic static <U> Matcher<java.lang.Iterable<U>> everyItem(Matcher<U> itemMatcher)
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")))
itemMatcher - the matcher to apply to every item provided by the examined Iterablepublic static <T> Matcher<T> is(T value)
is(equalTo(x)).
 
 For example:
 assertThat(cheese, is(smelly))instead of:
assertThat(cheese, is(equalTo(smelly)))
public static <T> Matcher<T> is(Matcher<T> matcher)
assertThat(cheese, is(equalTo(smelly)))instead of:
assertThat(cheese, equalTo(smelly))
public static <T> Matcher<T> is(java.lang.Class<T> type)
is(instanceOf(SomeClass.class)).
 
 For example:
 assertThat(cheese, is(Cheddar.class))instead of:
assertThat(cheese, is(instanceOf(Cheddar.class)))
public static <T> Matcher<T> isA(java.lang.Class<T> type)
is(instanceOf(SomeClass.class)).
 
 For example:
 assertThat(cheese, isA(Cheddar.class))instead of:
assertThat(cheese, is(instanceOf(Cheddar.class)))
public static Matcher<java.lang.Object> anything()
public static Matcher<java.lang.Object> anything(java.lang.String description)
String.
description - a meaningful String used when describing itselfpublic static <T> Matcher<java.lang.Iterable<? super T>> hasItem(T item)
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"))
item - the item to compare against the items provided by the examined Iterablepublic static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher)
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")))
itemMatcher - the matcher to apply to items provided by the examined Iterablepublic static <T> Matcher<java.lang.Iterable<T>> hasItems(T... items)
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"))
items - the items to compare against the items provided by the examined Iterablepublic static <T> Matcher<java.lang.Iterable<T>> hasItems(Matcher<? super T>... itemMatchers)
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")))
itemMatchers - the matchers to apply to items provided by the examined Iterablepublic static <T> Matcher<T> equalTo(T operand)
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.
 assertThat("foo", equalTo("foo"));
 assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
 
public static <T> Matcher<T> any(java.lang.Class<T> type)
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))
assertThat(new Canoe(), instanceOf(Canoe.class));
public static <T> Matcher<T> instanceOf(java.lang.Class<?> type)
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));
public static <T> Matcher<T> not(Matcher<T> matcher)
assertThat(cheese, is(not(equalTo(smelly))))
matcher - the matcher whose sense should be invertedpublic static <T> Matcher<T> not(T value)
not(equalTo(x)).
 
 For example:
 assertThat(cheese, is(not(smelly)))instead of:
assertThat(cheese, is(not(equalTo(smelly))))
value - the value that any examined object should not equalpublic static Matcher<java.lang.Object> nullValue()
null.
 
 For example:
 assertThat(cheese, is(nullValue())
public static <T> Matcher<T> nullValue(java.lang.Class<T> type)
null. Accepts a
 single dummy argument to facilitate type inference.
 
 For example:
 assertThat(cheese, is(nullValue(Cheese.class))
type - dummy parameter used to infer the generic type of the returned matcherpublic static Matcher<java.lang.Object> notNullValue()
not(nullValue()).
 
 For example:
 assertThat(cheese, is(notNullValue()))instead of:
assertThat(cheese, is(not(nullValue())))
public static <T> Matcher<T> notNullValue(java.lang.Class<T> type)
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 - dummy parameter used to infer the generic type of the returned matcherpublic static <T> Matcher<T> sameInstance(T target)
target - the target instance against which others should be assessedpublic static <T> Matcher<T> theInstance(T target)
target - the target instance against which others should be assessedpublic static Matcher<java.lang.String> containsString(java.lang.String substring)
String contains the specified
 String anywhere.
 
 For example:
 assertThat("myStringOfNote", containsString("ring"))
substring - the substring that the returned matcher will expect to find within any examined stringpublic static Matcher<java.lang.String> startsWith(java.lang.String prefix)
String starts with the specified
 String.
 
 For example:
 assertThat("myStringOfNote", startsWith("my"))
prefix - the substring that the returned matcher will expect at the start of any examined stringpublic static Matcher<java.lang.String> endsWith(java.lang.String suffix)
String ends with the specified
 String.
 
 For example:
 assertThat("myStringOfNote", endsWith("Note"))
suffix - the substring that the returned matcher will expect at the end of any examined string| 
 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||