/** * 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: * <pre>assertThat(new String[]{"foo", "bar"}, arrayContaining(Arrays.asList(equalTo("foo"), equalTo("bar"))))</pre> * * @param itemMatchers * a list of matchers, each of which must be satisfied by the corresponding item in an examined array */ public static <E> org.hamcrest.Matcher<E[]> arrayContaining(java.util.List<org.hamcrest.Matcher<? super E>> itemMatchers) { return ArrayMatching.arrayContaining(itemMatchers); }
/** * <p> * 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. * </p> * <p> * 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. * </p> * <p> * For example: * </p> * <pre>assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))</pre> * * @param itemMatchers * a list of matchers, each of which must be satisfied by an item provided by an examined array */ public static <E> org.hamcrest.Matcher<E[]> arrayContainingInAnyOrder(java.util.Collection<org.hamcrest.Matcher<? super E>> itemMatchers) { return ArrayMatching.arrayContainingInAnyOrder(itemMatchers); }
/** * A shortcut to the frequently used <code>hasItemInArray(equalTo(x))</code>. * For example: * <pre>assertThat(hasItemInArray(x))</pre> * instead of: * <pre>assertThat(hasItemInArray(equalTo(x)))</pre> * * @param element * the element that should be present in examined arrays */ public static <T> org.hamcrest.Matcher<T[]> hasItemInArray(T element) { return ArrayMatching.hasItemInArray(element); }
/** * 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: * <pre>assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))</pre> * * @param items * the items that must equal the items within an examined array */ @SafeVarargs public static <E> Matcher<E[]> arrayContaining(E... items) { return arrayContaining(asEqualMatchers(items)); } /**
/** * <p>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. * </p> * <p>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. * </p> * <p> * For example: * </p> * <pre>assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))</pre> * * @param items * the items that must equal the entries of an examined array, in any order */ @SafeVarargs public static <E> Matcher<E[]> arrayContainingInAnyOrder(E... items) { return arrayContainingInAnyOrder(asEqualMatchers(items)); }
/** * Creates a matcher for {@link Iterable}s that matches when a single pass over the * examined {@link Iterable} yields a series of items, each logically equal to the * corresponding item in the specified items. For a positive match, the examined iterable * must be of the same length as the number of specified items. * For example: * <pre>assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))</pre> * * @param items * the items that must equal the items provided by an examined {@link Iterable} */ @SafeVarargs public static <E> Matcher<Iterable<? extends E>> contains(E... items) { return contains(asEqualMatchers(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: * <pre>assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))</pre> * * @param items * the items that must equal the items within an examined array */ @SafeVarargs public static <E> Matcher<E[]> arrayContaining(E... items) { return arrayContaining(asEqualMatchers(items)); } /**
/** * <p>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. * </p> * <p>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. * </p> * <p> * For example: * </p> * <pre>assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))</pre> * * @param items * the items that must equal the entries of an examined array, in any order */ @SafeVarargs public static <E> Matcher<E[]> arrayContainingInAnyOrder(E... items) { return arrayContainingInAnyOrder(asEqualMatchers(items)); }
/** * Creates a matcher for {@link Iterable}s that matches when a single pass over the * examined {@link Iterable} yields a series of items, each logically equal to the * corresponding item in the specified items. For a positive match, the examined iterable * must be of the same length as the number of specified items. * For example: * <pre>assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))</pre> * * @param items * the items that must equal the items provided by an examined {@link Iterable} */ @SafeVarargs public static <E> Matcher<Iterable<? extends E>> contains(E... items) { return contains(asEqualMatchers(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: * <pre>assertThat(new String[]{"foo", "bar"}, arrayContaining("foo", "bar"))</pre> * * @param items * the items that must equal the items within an examined array */ @SafeVarargs public static <E> org.hamcrest.Matcher<E[]> arrayContaining(E... items) { return ArrayMatching.arrayContaining(items); }
/** * <p>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. * </p> * <p>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. * </p> * <p> * For example: * </p> * <pre>assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder("bar", "foo"))</pre> * * @param items * the items that must equal the entries of an examined array, in any order */ @SafeVarargs public static <E> org.hamcrest.Matcher<E[]> arrayContainingInAnyOrder(E... items) { return ArrayMatching.arrayContainingInAnyOrder(items); }
/** * Creates a matcher for arrays that matches when the examined array contains at least one item * that is matched by the specified <code>elementMatcher</code>. Whilst matching, the traversal * of the examined array will stop as soon as a matching element is found. * For example: * <pre>assertThat(new String[] {"foo", "bar"}, hasItemInArray(startsWith("ba")))</pre> * * @param elementMatcher * the matcher to apply to elements in examined arrays */ public static <T> org.hamcrest.Matcher<T[]> hasItemInArray(org.hamcrest.Matcher<? super T> elementMatcher) { return ArrayMatching.hasItemInArray(elementMatcher); }
/** * 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: * <pre>assertThat(new String[]{"foo", "bar"}, arrayContaining(equalTo("foo"), equalTo("bar")))</pre> * * @param itemMatchers * the matchers that must be satisfied by the items in the examined array */ @SafeVarargs public static <E> org.hamcrest.Matcher<E[]> arrayContaining(org.hamcrest.Matcher<? super E>... itemMatchers) { return ArrayMatching.arrayContaining(itemMatchers); }
/** * <p> * 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. * </p> * <p> * 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. * </p> * <p> * For example: * </p> * <pre>assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))</pre> * * @param itemMatchers * a list of matchers, each of which must be satisfied by an entry in an examined array */ @SafeVarargs public static <E> org.hamcrest.Matcher<E[]> arrayContainingInAnyOrder(org.hamcrest.Matcher<? super E>... itemMatchers) { return ArrayMatching.arrayContainingInAnyOrder(itemMatchers); }
/** * A shortcut to the frequently used <code>hasItemInArray(equalTo(x))</code>. * For example: * <pre>assertThat(hasItemInArray(x))</pre> * instead of: * <pre>assertThat(hasItemInArray(equalTo(x)))</pre> * * @param element * the element that should be present in examined arrays */ public static <T> Matcher<T[]> hasItemInArray(T element) { return hasItemInArray(equalTo(element)); }
/** * 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: * <pre>assertThat(new String[]{"foo", "bar"}, arrayContaining(equalTo("foo"), equalTo("bar")))</pre> * * @param itemMatchers * the matchers that must be satisfied by the items in the examined array */ @SafeVarargs public static <E> Matcher<E[]> arrayContaining(Matcher<? super E>... itemMatchers) { //required for JDK 1.6 //noinspection RedundantTypeArguments final List<Matcher<? super E>> nullSafeWithExplicitTypeMatchers = NullSafety.<E>nullSafe(itemMatchers); return arrayContaining(nullSafeWithExplicitTypeMatchers); }
/** * <p> * 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. * </p> * <p> * 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. * </p> * <p> * For example: * </p> * <pre>assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))</pre> * * @param itemMatchers * a list of matchers, each of which must be satisfied by an entry in an examined array */ @SafeVarargs public static <E> Matcher<E[]> arrayContainingInAnyOrder(Matcher<? super E>... itemMatchers) { return arrayContainingInAnyOrder(asList(itemMatchers)); }
@Override protected Matcher<?> createMatcher() { return hasItemInArray("irrelevant"); }
@SuppressWarnings("unchecked") @Override protected Matcher<?> createMatcher() { return arrayContaining(equalTo(1), equalTo(2)); }
@SuppressWarnings("unchecked") @Override protected Matcher<?> createMatcher() { return ArrayMatching.arrayContainingInAnyOrder(equalTo(1), equalTo(2)); }