/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ public static <U> Matcher<Iterable<? extends U>> everyItem(final Matcher<U> itemMatcher) { return new Every<>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ public static <U> Matcher<Iterable<? extends U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ public static <U> Matcher<Iterable<? extends U>> everyItem(final Matcher<U> itemMatcher) { return new Every<>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }
/** * Creates a matcher for {@link Iterable}s that only matches when a single pass over the * examined {@link Iterable} yields items that are all matched by the specified * <code>itemMatcher</code>. * <p/> * For example: * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> * * @param itemMatcher * the matcher to apply to every item provided by the examined {@link Iterable} */ @Factory public static <U> Matcher<Iterable<U>> everyItem(final Matcher<U> itemMatcher) { return new Every<U>(itemMatcher); } }