@Override public boolean test(final String a, final Object b) { @SuppressWarnings("unchecked") final Iterable<String> iterable = (Iterable<String>) b; return Iterables.contains(iterable, a); } };
/** * Returns {@code true} if this fluent iterable contains any object for which {@code * equals(target)} is true. * * <p><b>{@code Stream} equivalent:</b> {@code stream.anyMatch(Predicate.isEqual(target))}. */ public final boolean contains(@Nullable Object target) { return Iterables.contains(getDelegate(), target); }
/** * Sets the available {@link MediaType}s. */ public EndpointInfoBuilder availableMimeTypes(Iterable<MediaType> availableMimeTypes) { requireNonNull(availableMimeTypes, "availableMimeTypes"); checkArgument(!Iterables.isEmpty(availableMimeTypes), "Should at least have an available media type."); if (defaultMimeType != null && !Iterables.contains(availableMimeTypes, defaultMimeType)) { this.availableMimeTypes = addDefaultMimeType(defaultMimeType, availableMimeTypes); } else { this.availableMimeTypes = ImmutableSet.copyOf(availableMimeTypes); } return this; }
public void test_contains_nonnull_set_no() { Iterable<String> set = Sets.newHashSet("a", "b"); assertFalse(Iterables.contains(set, "c")); }
public void test_contains_nonnull_set_yes() { Iterable<String> set = Sets.newHashSet("a", null, "b"); assertTrue(Iterables.contains(set, "b")); }
public void test_contains_null_set_yes() { Iterable<String> set = Sets.newHashSet("a", null, "b"); assertTrue(Iterables.contains(set, null)); }
public void test_contains_null_set_no() { Iterable<String> set = Sets.newHashSet("a", "b"); assertFalse(Iterables.contains(set, null)); }
/** * Returns {@code true} if this fluent iterable contains any object for which {@code * equals(target)} is true. * * <p><b>{@code Stream} equivalent:</b> {@code stream.anyMatch(Predicate.isEqual(target))}. */ public final boolean contains(@NullableDecl Object target) { return Iterables.contains(getDelegate(), target); }
/** * Returns {@code true} if this fluent iterable contains any object for which {@code * equals(target)} is true. * * <p><b>{@code Stream} equivalent:</b> {@code stream.anyMatch(Predicate.isEqual(target))}. */ public final boolean contains(@NullableDecl Object target) { return Iterables.contains(getDelegate(), target); }
/** Fails if the subject is equal to any element in the given iterable. */ public void isNotIn(Iterable<?> iterable) { if (Iterables.contains(iterable, actual())) { failWithActual("expected not to be any of", iterable); } }
/** Fails unless the subject is equal to any element in the given iterable. */ public void isIn(Iterable<?> iterable) { if (!Iterables.contains(iterable, actual())) { failWithActual("expected any of", iterable); } }
public void test_contains_null_iterable_no() { Iterable<String> set = iterable("a", "b"); assertFalse(Iterables.contains(set, null)); }
public void test_contains_nonnull_iterable_no() { Iterable<String> set = iterable("a", "b"); assertFalse(Iterables.contains(set, "c")); }
public void test_contains_nonnull_iterable_yes() { Iterable<String> set = iterable("a", null, "b"); assertTrue(Iterables.contains(set, "b")); }
public void test_contains_null_iterable_yes() { Iterable<String> set = iterable("a", null, "b"); assertTrue(Iterables.contains(set, null)); }
/** Checks (with a side-effect failure) that the subject does not contain the supplied item. */ public final void doesNotContain(@NullableDecl Object element) { if (Iterables.contains(actual(), element)) { failWithActual("expected not to contain", element); } }
/** @deprecated You probably meant to call {@link #containsNoneIn} instead. */ @Override @Deprecated public void isNotIn(Iterable<?> iterable) { if (Iterables.contains(iterable, actual())) { failWithActual("expected not to be any of", iterable); } List<Object> nonIterables = new ArrayList<>(); for (Object element : iterable) { if (!(element instanceof Iterable<?>)) { nonIterables.add(element); } } if (!nonIterables.isEmpty()) { failWithoutActual( simpleFact( lenientFormat( "The actual value is an Iterable, and you've written a test that compares it to " + "some objects that are not Iterables. Did you instead mean to check " + "whether its *contents* match any of the *contents* of the given values? " + "If so, call containsNoneOf(...)/containsNoneIn(...) instead. " + "Non-iterables: %s", nonIterables))); } }
@NoWarning("GC") public static void testIterablesOK(Iterable<String> i, Collection<String> c) { Iterables.contains(i, "x"); Iterables.removeAll(i, c); Iterables.retainAll(i, c); Iterables.elementsEqual(i, c); Iterables.frequency(i, "x"); } @ExpectWarning(value="GC", num=5)
@ExpectWarning(value="GC", num=5) public static void testIterables(Iterable<String> i, Collection<Integer> c) { Iterables.contains(i, 1); Iterables.removeAll(i, c); Iterables.retainAll(i, c); Iterables.elementsEqual(i, c); Iterables.frequency(i, 1); } @NoWarning("GC")
/** Checks (with a side-effect failure) that the subject contains the supplied item. */ public final void contains(@NullableDecl Object element) { if (!Iterables.contains(actual(), element)) { List<Object> elementList = newArrayList(element); if (hasMatchingToStringPair(actual(), elementList)) { failWithoutActual( fact("expected to contain", element), fact("an instance of", objectToTypeName(element)), simpleFact("but did not"), fact( "though it did contain", countDuplicatesAndAddTypeInfo( retainMatchingToString(actual(), elementList /* itemsToCheck */))), fullContents()); } else { failWithActual("expected to contain", element); } } }