public void testFilterNoMatch() { Iterator<String> unfiltered = Lists.newArrayList("foo", "bar").iterator(); Iterator<String> filtered = Iterators.filter(unfiltered, Predicates.alwaysFalse()); List<String> expected = Collections.emptyList(); List<String> actual = Lists.newArrayList(filtered); assertEquals(expected, actual); }
public void testAlwaysFalse_apply() throws Exception { assertEvalsToFalse(Predicates.alwaysFalse()); }
public void testAnd_listDefensivelyCopied() { List<Predicate<Object>> list = newArrayList(); Predicate<Object> predicate = Predicates.and(list); assertTrue(predicate.apply(1)); list.add(Predicates.alwaysFalse()); assertTrue(predicate.apply(1)); }
@SuppressWarnings("unchecked") // varargs public void testAnd_arrayDefensivelyCopied() { Predicate[] array = {Predicates.alwaysFalse()}; Predicate<Object> predicate = Predicates.and(array); assertFalse(predicate.apply(1)); array[0] = Predicates.alwaysTrue(); assertFalse(predicate.apply(1)); }
public void testAnd_iterableDefensivelyCopied() { final List<Predicate<Object>> list = newArrayList(); Iterable<Predicate<Object>> iterable = new Iterable<Predicate<Object>>() { @Override public Iterator<Predicate<Object>> iterator() { return list.iterator(); } }; Predicate<Object> predicate = Predicates.and(iterable); assertTrue(predicate.apply(1)); list.add(Predicates.alwaysFalse()); assertTrue(predicate.apply(1)); }
public void testFind_withDefault() { Iterable<String> list = Lists.newArrayList("cool", "pants"); assertEquals("cool", Iterables.find(list, Predicates.equalTo("cool"), "woot")); assertEquals("pants", Iterables.find(list, Predicates.equalTo("pants"), "woot")); assertEquals("woot", Iterables.find(list, Predicates.alwaysFalse(), "woot")); assertNull(Iterables.find(list, Predicates.alwaysFalse(), null)); assertEquals("cool", Iterables.find(list, Predicates.alwaysTrue(), "woot")); assertCanIterateAgain(list); }
public void testTryFind() { Iterable<String> list = newArrayList("cool", "pants"); assertThat(Iterables.tryFind(list, Predicates.equalTo("cool"))).hasValue("cool"); assertThat(Iterables.tryFind(list, Predicates.equalTo("pants"))).hasValue("pants"); assertThat(Iterables.tryFind(list, Predicates.alwaysTrue())).hasValue("cool"); assertThat(Iterables.tryFind(list, Predicates.alwaysFalse())).isAbsent(); assertCanIterateAgain(list); }
public void testTryFind_alwaysFalse_orDefault() { Iterable<String> list = Lists.newArrayList("cool", "pants"); Iterator<String> iterator = list.iterator(); assertEquals("woot", Iterators.tryFind(iterator, Predicates.alwaysFalse()).or("woot")); assertFalse(iterator.hasNext()); }
public void testTryFind_alwaysFalse_isPresent() { Iterable<String> list = Lists.newArrayList("cool", "pants"); Iterator<String> iterator = list.iterator(); assertThat(Iterators.tryFind(iterator, Predicates.alwaysFalse())).isAbsent(); assertFalse(iterator.hasNext()); }
public void testFilteredEntriesObjectPredicate() { Map<String, Integer> unfiltered = createUnfiltered(); unfiltered.put("cat", 3); unfiltered.put("dog", 2); unfiltered.put("horse", 5); Predicate<Object> predicate = Predicates.alwaysFalse(); Map<String, Integer> filtered = Maps.filterEntries(unfiltered, predicate); assertTrue(filtered.isEmpty()); }
public void testFind_notPresent() { Iterable<String> list = Lists.newArrayList("cool", "pants"); Iterator<String> iterator = list.iterator(); try { Iterators.find(iterator, Predicates.alwaysFalse()); fail(); } catch (NoSuchElementException e) { } assertFalse(iterator.hasNext()); }
public void testFind_withDefault_notPresent() { Iterable<String> list = Lists.newArrayList("cool", "pants"); Iterator<String> iterator = list.iterator(); assertEquals("woot", Iterators.find(iterator, Predicates.alwaysFalse(), "woot")); assertFalse(iterator.hasNext()); }
@SuppressWarnings("unchecked") // varargs public void testOr_arrayDefensivelyCopied() { Predicate[] array = {Predicates.alwaysFalse()}; Predicate<Object> predicate = Predicates.or(array); assertFalse(predicate.apply(1)); array[0] = Predicates.alwaysTrue(); assertFalse(predicate.apply(1)); }
public void testFind() { Iterable<String> list = newArrayList("cool", "pants"); assertEquals("cool", Iterables.find(list, Predicates.equalTo("cool"))); assertEquals("pants", Iterables.find(list, Predicates.equalTo("pants"))); try { Iterables.find(list, Predicates.alwaysFalse()); fail(); } catch (NoSuchElementException e) { } assertEquals("cool", Iterables.find(list, Predicates.alwaysTrue())); assertCanIterateAgain(list); }
public void testFind_withDefault_notPresent_nullReturn() { Iterable<String> list = Lists.newArrayList("cool", "pants"); Iterator<String> iterator = list.iterator(); assertNull(Iterators.find(iterator, Predicates.alwaysFalse(), null)); assertFalse(iterator.hasNext()); }
@GwtIncompatible // SerializableTester public void testAlwaysFalse_serialization() { checkSerialization(Predicates.alwaysFalse()); }
public void testFirstMatch() { FluentIterable<String> iterable = FluentIterable.from(Lists.newArrayList("cool", "pants")); assertThat(iterable.firstMatch(Predicates.equalTo("cool"))).hasValue("cool"); assertThat(iterable.firstMatch(Predicates.equalTo("pants"))).hasValue("pants"); assertThat(iterable.firstMatch(Predicates.alwaysFalse())).isAbsent(); assertThat(iterable.firstMatch(Predicates.alwaysTrue())).hasValue("cool"); }
public void testForPredicate() { Function<Object, Boolean> alwaysTrue = Functions.forPredicate(Predicates.alwaysTrue()); Function<Object, Boolean> alwaysFalse = Functions.forPredicate(Predicates.alwaysFalse()); assertTrue(alwaysTrue.apply(0)); assertFalse(alwaysFalse.apply(0)); new EqualsTester() .addEqualityGroup(alwaysTrue, Functions.forPredicate(Predicates.alwaysTrue())) .addEqualityGroup(alwaysFalse) .addEqualityGroup(Functions.identity()) .testEquals(); }
public void testAlwaysTrue_equality() throws Exception { new EqualsTester() .addEqualityGroup(TRUE, Predicates.alwaysTrue()) .addEqualityGroup(isOdd()) .addEqualityGroup(Predicates.alwaysFalse()) .testEquals(); }
public void testAlwaysFalse_equality() throws Exception { new EqualsTester() .addEqualityGroup(FALSE, Predicates.alwaysFalse()) .addEqualityGroup(isOdd()) .addEqualityGroup(Predicates.alwaysTrue()) .testEquals(); }