public HasItemInArray(Matcher<? super T> elementMatcher) { this.elementMatcher = elementMatcher; this.collectionMatcher = new IsIterableContaining<>(elementMatcher); }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields at least one item that is equal to the specified * <code>item</code>. Whilst matching, the traversal of the examined {@link Iterable} * will stop as soon as a matching item is found. * For example: * <pre>assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))</pre> * * @param item * the item to compare against the items provided by the examined {@link Iterable} */ public static <T> org.hamcrest.Matcher<java.lang.Iterable<? super T>> hasItem(T item) { return IsIterableContaining.hasItem(item); }
/** * Creates a matcher for {@link Iterable}s that matches when consecutive passes over the * examined {@link Iterable} yield at least one item that is equal to the corresponding * item from the specified <code>items</code>. Whilst matching, each traversal of the * examined {@link Iterable} will stop as soon as a matching item is found. * For example: * <pre>assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))</pre> * * @param items * the items to compare against the items provided by the examined {@link Iterable} */ @SafeVarargs public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItems(T... items) { return IsIterableContaining.hasItems(items); }
@Test public void canMatchItemWhenCollectionHoldsSuperclass() { // Issue 24 final Set<Number> s = new HashSet<>(); s.add(2); assertMatches(new IsIterableContaining<>(new IsEqual<Number>(2)), s); assertMatches(IsIterableContaining.hasItem(2), s); }
@Override protected boolean matchesSafely(Iterable<? super T> collection, Description mismatchDescription) { return delegate.matchesSafely(collection, mismatchDescription); }
@Override public void describeTo(Description description) { delegate.describeTo(description); }
@Override protected boolean matchesSafely(Iterable<? super T> collection, Description mismatchDescription) { if (isEmpty(collection)) { mismatchDescription.appendText("was empty"); return false; } for (Object item : collection) { if (elementMatcher.matches(item)) { return true; } } mismatchDescription.appendText("mismatches were: ["); boolean isPastFirst = false; for (Object item : collection) { if (isPastFirst) { mismatchDescription.appendText(", "); } elementMatcher.describeMismatch(item, mismatchDescription); isPastFirst = true; } mismatchDescription.appendText("]"); return false; }
@Override protected boolean matchesSafely(Iterable<? super T> collection, Description mismatchDescription) { return delegate.matchesSafely(collection, mismatchDescription); }
@Override public void describeTo(Description description) { delegate.describeTo(description); }
@Override protected boolean matchesSafely(Iterable<? super T> collection, Description mismatchDescription) { if (isEmpty(collection)) { mismatchDescription.appendText("was empty"); return false; } for (Object item : collection) { if (elementMatcher.matches(item)) { return true; } } mismatchDescription.appendText("mismatches were: ["); boolean isPastFirst = false; for (Object item : collection) { if (isPastFirst) { mismatchDescription.appendText(", "); } elementMatcher.describeMismatch(item, mismatchDescription); isPastFirst = true; } mismatchDescription.appendText("]"); return false; }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields at least one item that is matched by the specified * <code>itemMatcher</code>. Whilst matching, the traversal of the examined {@link Iterable} * will stop as soon as a matching item is found. * For example: * <pre>assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to items provided by the examined {@link Iterable} */ public static <T> org.hamcrest.Matcher<java.lang.Iterable<? super T>> hasItem(org.hamcrest.Matcher<? super T> itemMatcher) { return IsIterableContaining.hasItem(itemMatcher); }
/** * Creates a matcher for {@link Iterable}s that matches when consecutive passes over the * examined {@link Iterable} yield at least one item that is matched by the corresponding * matcher from the specified <code>itemMatchers</code>. Whilst matching, each traversal of * the examined {@link Iterable} will stop as soon as a matching item is found. * For example: * <pre>assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))</pre> * * @param itemMatchers * the matchers to apply to items provided by the examined {@link Iterable} */ @SafeVarargs public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItems(org.hamcrest.Matcher<? super T>... itemMatchers) { return IsIterableContaining.hasItems(itemMatchers); }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields at least one item that is matched by the specified * <code>itemMatcher</code>. Whilst matching, the traversal of the examined {@link Iterable} * will stop as soon as a matching item is found. * For example: * <pre>assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to items provided by the examined {@link Iterable} */ public static <T> Matcher<Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher) { return new IsIterableContaining<>(itemMatcher); }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields at least one item that is equal to the specified * <code>item</code>. Whilst matching, the traversal of the examined {@link Iterable} * will stop as soon as a matching item is found. * For example: * <pre>assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))</pre> * * @param item * the item to compare against the items provided by the examined {@link Iterable} */ public static <T> org.hamcrest.Matcher<java.lang.Iterable<? super T>> hasItem(T item) { return IsIterableContaining.hasItem(item); }
/** * Creates a matcher for {@link Iterable}s that matches when consecutive passes over the * examined {@link Iterable} yield at least one item that is matched by the corresponding * matcher from the specified <code>itemMatchers</code>. Whilst matching, each traversal of * the examined {@link Iterable} will stop as soon as a matching item is found. * For example: * <pre>assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))</pre> * * @param itemMatchers * the matchers to apply to items provided by the examined {@link Iterable} */ @SafeVarargs public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItems(org.hamcrest.Matcher<? super T>... itemMatchers) { return IsIterableContaining.hasItems(itemMatchers); }
public IsCollectionContaining(Matcher<? super T> elementMatcher) { this.delegate = new IsIterableContaining<>(elementMatcher); }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields at least one item that is matched by the specified * <code>itemMatcher</code>. Whilst matching, the traversal of the examined {@link Iterable} * will stop as soon as a matching item is found. * For example: * <pre>assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to items provided by the examined {@link Iterable} */ public static <T> org.hamcrest.Matcher<java.lang.Iterable<? super T>> hasItem(org.hamcrest.Matcher<? super T> itemMatcher) { return IsIterableContaining.hasItem(itemMatcher); }
/** * Creates a matcher for {@link Iterable}s that matches when consecutive passes over the * examined {@link Iterable} yield at least one item that is equal to the corresponding * item from the specified <code>items</code>. Whilst matching, each traversal of the * examined {@link Iterable} will stop as soon as a matching item is found. * For example: * <pre>assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))</pre> * * @param items * the items to compare against the items provided by the examined {@link Iterable} */ @SafeVarargs public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItems(T... items) { return IsIterableContaining.hasItems(items); }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields at least one item that is equal to the specified * <code>item</code>. Whilst matching, the traversal of the examined {@link Iterable} * will stop as soon as a matching item is found. * For example: * <pre>assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))</pre> * * @param item * the item to compare against the items provided by the examined {@link Iterable} */ public static <T> Matcher<Iterable<? super T>> hasItem(T item) { // Doesn't forward to hasItem() method so compiler can sort out generics. return new IsIterableContaining<>(equalTo(item)); }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields at least one item that is matched by the specified * <code>itemMatcher</code>. Whilst matching, the traversal of the examined {@link Iterable} * will stop as soon as a matching item is found. * For example: * <pre>assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))</pre> * * @deprecated As of version 2.1, use {@link IsIterableContaining#hasItem(Matcher)}. * * @param itemMatcher * the matcher to apply to items provided by the examined {@link Iterable} */ public static <T> Matcher<Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher) { return IsIterableContaining.hasItem(itemMatcher); }