/** * 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); }
public HasItemInArray(Matcher<? super T> elementMatcher) { this.elementMatcher = elementMatcher; this.collectionMatcher = new IsIterableContaining<>(elementMatcher); }
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 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 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> Matcher<Iterable<T>> hasItems(Matcher<? super T>... itemMatchers) { List<Matcher<? super Iterable<T>>> all = new ArrayList<>(itemMatchers.length); for (Matcher<? super T> elementMatcher : itemMatchers) { // Doesn't forward to hasItem() method so compiler can sort out generics. all.add(new IsIterableContaining<>(elementMatcher)); } return allOf(all); }
@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); }
public HasItemInArray(Matcher<? super T> elementMatcher) { this.elementMatcher = elementMatcher; this.collectionMatcher = new IsIterableContaining<>(elementMatcher); }
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> 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> 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 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> Matcher<Iterable<T>> hasItems(Matcher<? super T>... itemMatchers) { List<Matcher<? super Iterable<T>>> all = new ArrayList<>(itemMatchers.length); for (Matcher<? super T> elementMatcher : itemMatchers) { // Doesn't forward to hasItem() method so compiler can sort out generics. all.add(new IsIterableContaining<>(elementMatcher)); } return allOf(all); }