/** * Like {@link #getSortedDescriptorsForGlobalConfig(Predicate)} but with a constant truth predicate, to include all descriptors. */ public static Collection<Descriptor> getSortedDescriptorsForGlobalConfig() { return getSortedDescriptorsForGlobalConfig(Predicates.<GlobalConfigurationCategory>alwaysTrue()); }
public void testFilterMatchAll() { Iterator<String> unfiltered = Lists.newArrayList("foo", "bar").iterator(); Iterator<String> filtered = Iterators.filter(unfiltered, Predicates.alwaysTrue()); List<String> expected = Lists.newArrayList("foo", "bar"); List<String> actual = Lists.newArrayList(filtered); assertEquals(expected, actual); }
public void testAlwaysTrue_apply() { assertEvalsToTrue(Predicates.alwaysTrue()); }
public void testTryFind_alwaysTrue() { Iterable<String> list = Lists.newArrayList("cool", "pants"); Iterator<String> iterator = list.iterator(); assertThat(Iterators.tryFind(iterator, Predicates.alwaysTrue())).hasValue("cool"); }
public void testFind_matchAlways() { Iterable<String> list = Lists.newArrayList("cool", "pants"); Iterator<String> iterator = list.iterator(); assertEquals("cool", Iterators.find(iterator, Predicates.alwaysTrue())); }
public void testOr_listDefensivelyCopied() { List<Predicate<Object>> list = newArrayList(); Predicate<Object> predicate = Predicates.or(list); assertFalse(predicate.apply(1)); list.add(Predicates.alwaysTrue()); assertFalse(predicate.apply(1)); }
public void testFind_withDefault_matchAlways() { Iterable<String> list = Lists.newArrayList("cool", "pants"); Iterator<String> iterator = list.iterator(); assertEquals("cool", Iterators.find(iterator, Predicates.alwaysTrue(), "woot")); assertEquals("pants", iterator.next()); }
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); }
@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 testOr_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.or(iterable); assertFalse(predicate.apply(1)); list.add(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); }
@GwtIncompatible // SerializableTester public void testAlwaysTrue_serialization() { checkSerialization(Predicates.alwaysTrue()); }
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); }
@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 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"); }
@SuppressWarnings("unchecked") // varargs @GwtIncompatible // SerializbleTester public void testCascadingSerialization() throws Exception { // Eclipse says Predicate<Integer>; javac says Predicate<Object>. Predicate<? super Integer> nasty = Predicates.not( Predicates.and( Predicates.or( Predicates.equalTo((Object) 1), Predicates.equalTo(null), Predicates.alwaysFalse(), Predicates.alwaysTrue(), Predicates.isNull(), Predicates.notNull(), Predicates.in(Arrays.asList(1))))); assertEvalsToFalse(nasty); Predicate<? super Integer> stillNasty = SerializableTester.reserializeAndAssert(nasty); assertEvalsToFalse(stillNasty); }
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(); }
@Test public void testAllOutputsReferenced() { tester().assertThat(new PruneAggregationColumns()) .on(p -> buildProjectedAggregation(p, alwaysTrue())) .doesNotFire(); }
public void testAlwaysFalse_equality() throws Exception { new EqualsTester() .addEqualityGroup(FALSE, Predicates.alwaysFalse()) .addEqualityGroup(isOdd()) .addEqualityGroup(Predicates.alwaysTrue()) .testEquals(); }
public void testAlwaysTrue_equality() throws Exception { new EqualsTester() .addEqualityGroup(TRUE, Predicates.alwaysTrue()) .addEqualityGroup(isOdd()) .addEqualityGroup(Predicates.alwaysFalse()) .testEquals(); }