/** * Returns a predicate that evaluates to {@code true} if the object being tested {@code equals()} * the given target or both are null. */ public static <T> Predicate<T> equalTo(@Nullable T target) { return (target == null) ? Predicates.<T>isNull() : new IsEqualToPredicate<T>(target); }
/** * Returns a predicate that evaluates to {@code true} if the object being tested {@code equals()} * the given target or both are null. */ public static <T> Predicate<T> equalTo(@NullableDecl T target) { return (target == null) ? Predicates.<T>isNull() : new IsEqualToPredicate<T>(target); }
/** * Returns a predicate that evaluates to {@code true} if the object being tested {@code equals()} * the given target or both are null. */ public static <T> Predicate<T> equalTo(@NullableDecl T target) { return (target == null) ? Predicates.<T>isNull() : new IsEqualToPredicate<T>(target); }
public void testIsNull_apply() { Predicate<Integer> isNull = Predicates.isNull(); assertTrue(isNull.apply(null)); assertFalse(isNull.apply(1)); }
/** * Chains a given {@link List} of {@link JobListener}s into a single {@link JobListener}. The specified {@link JobListener}s * will all be executed in parallel. * * @param jobListeners is a {@link List} of {@link JobListener}s that need to be executed * * @return a {@link CloseableJobListener}, which is similar to {@link JobListener}, except * {@link CloseableJobListener#close()} will block until all {@link JobListener}s have finished their executions. */ public static CloseableJobListener parallelJobListener(List<JobListener> jobListeners) { Iterables.removeIf(jobListeners, Predicates.isNull()); return new ParallelJobListener(jobListeners); }
@GwtIncompatible // SerializableTester public void testIsNull_serialization() { Predicate<String> pre = Predicates.isNull(); Predicate<String> post = SerializableTester.reserializeAndAssert(pre); assertEquals(pre.apply("foo"), post.apply("foo")); assertEquals(pre.apply(null), post.apply(null)); }
public void testHashCodeForBooleanOperations() { Predicate<Integer> p1 = Predicates.isNull(); Predicate<Integer> p2 = isOdd(); // Make sure that hash codes are not computed per-instance. assertEqualHashCode(Predicates.not(p1), Predicates.not(p1)); assertEqualHashCode(Predicates.and(p1, p2), Predicates.and(p1, p2)); assertEqualHashCode(Predicates.or(p1, p2), Predicates.or(p1, p2)); // While not a contractual requirement, we'd like the hash codes for ands // & ors of the same predicates to not collide. assertTrue(Predicates.and(p1, p2).hashCode() != Predicates.or(p1, p2).hashCode()); }
public void testNotNull_equality() { new EqualsTester() .addEqualityGroup(Predicates.notNull(), Predicates.notNull()) .addEqualityGroup(Predicates.isNull()) .testEquals(); }
@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 testNot_equalityForNotOfKnownValues() { new EqualsTester() .addEqualityGroup(TRUE, Predicates.alwaysTrue()) .addEqualityGroup(FALSE) .addEqualityGroup(Predicates.not(TRUE)) .testEquals(); new EqualsTester() .addEqualityGroup(FALSE, Predicates.alwaysFalse()) .addEqualityGroup(TRUE) .addEqualityGroup(Predicates.not(FALSE)) .testEquals(); new EqualsTester() .addEqualityGroup(Predicates.isNull(), Predicates.isNull()) .addEqualityGroup(Predicates.notNull()) .addEqualityGroup(Predicates.not(Predicates.isNull())) .testEquals(); new EqualsTester() .addEqualityGroup(Predicates.notNull(), Predicates.notNull()) .addEqualityGroup(Predicates.isNull()) .addEqualityGroup(Predicates.not(Predicates.notNull())) .testEquals(); }
private static String getLocation(AbstractLocator[] locators) { if (locators == null) { return ""; } final Collection<AbstractLocator> filteredLocators = Collections2.filter(Arrays.asList(locators), Predicates.not(Predicates.isNull())); if (filteredLocators.size() == 0) { return ""; } return " Defined at:" + (filteredLocators.size() > 1 ? "\n\t" : " ") + Joiner.on("\n\t").skipNulls().join(filteredLocators); }
@Override public Predicate apply(final String input) { switch (input) { case "alwaysFalse" : return Predicates.alwaysFalse(); case "alwaysTrue" : return Predicates.alwaysTrue(); case "isNull" : return Predicates.isNull(); case "notNull" : return Predicates.notNull(); default: throw new IllegalArgumentException("Cannot convert string '" + input + "' to predicate"); } } });
private void throwExceptionIfAnyCloseFails(SQLException... sqlExceptions) { if (!Iterables.all(Arrays.asList(sqlExceptions), Predicates.<Object>isNull())) { throw new RuntimeException("At least one error occured during close, see logs for more details, there may be multiple"); } }
/** * Returns a predicate that evaluates to {@code true} if the object being * tested {@code equals()} the given target or both are null. */ public static <T> Predicate<T> equalTo(@Nullable T target) { // TODO: Change signature to return Predicate<Object>. return (target == null) ? Predicates.<T>isNull() : new IsEqualToPredicate<T>(target); }
/** * Returns a predicate that evaluates to {@code true} if the object being * tested {@code equals()} the given target or both are null. */ public static <T> Predicate<T> equalTo(@Nullable T target) { return (target == null) ? Predicates.<T> isNull() : new IsEqualToPredicate<T>(target); }
/** * Returns a predicate that evaluates to {@code true} if the object being * tested {@code equals()} the given target or both are null. */ public static <T> Predicate<T> equalTo(@Nullable T target) { return (target == null) ? Predicates.<T>isNull() : new IsEqualToPredicate<T>(target); }
/** * Returns a predicate that evaluates to {@code true} if the object being * tested {@code equals()} the given target or both are null. */ public static <T> Predicate<T> equalTo(@Nullable T target) { return (target == null) ? Predicates.<T>isNull() : new IsEqualToPredicate<T>(target); }
/** * Returns a predicate that evaluates to {@code true} if the object being * tested {@code equals()} the given target or both are null. */ public static <T> Predicate<T> equalTo(@Nullable T target) { return (target == null) ? Predicates.<T>isNull() : new IsEqualToPredicate<T>(target); }
/** * Returns a predicate that evaluates to {@code true} if the object being * tested {@code equals()} the given target or both are null. */ public static <T> Predicate<T> equalTo(@Nullable T target) { return (target == null) ? Predicates.<T>isNull() : new IsEqualToPredicate<T>(target); }