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 assertEqualHashCode( Predicate<? super Integer> expected, Predicate<? super Integer> actual) { assertEquals(actual + " should hash like " + expected, expected.hashCode(), actual.hashCode()); }
private static void assertEvalsLikeOdd(Predicate<? super Integer> predicate) { assertEvalsLike(isOdd(), predicate); }
public void testAnd_applyBinary() { assertEvalsLikeOdd(Predicates.and(isOdd(), TRUE)); assertEvalsLikeOdd(Predicates.and(TRUE, isOdd())); assertEvalsToFalse(Predicates.and(FALSE, NEVER_REACHED)); }
@SuppressWarnings("unchecked") // varargs public void testAnd_applyOneArg() { assertEvalsLikeOdd(Predicates.and(isOdd())); }
public void testNot_apply() { assertEvalsToTrue(Predicates.not(FALSE)); assertEvalsToFalse(Predicates.not(TRUE)); assertEvalsLikeOdd(Predicates.not(Predicates.not(isOdd()))); }
public void testIsEqualTo_apply() { Predicate<Integer> isOne = Predicates.equalTo(1); assertTrue(isOne.apply(1)); assertFalse(isOne.apply(2)); assertFalse(isOne.apply(null)); }
@GwtIncompatible // SerializableTester @SuppressWarnings("unchecked") // varargs public void testAnd_serializationTernary() { checkSerialization(Predicates.and(TRUE, isOdd(), FALSE)); }
@SuppressWarnings("unchecked") // varargs public void testOr_applyOneArg() { assertEvalsToTrue(Predicates.or(TRUE)); assertEvalsToFalse(Predicates.or(FALSE)); }
@SuppressWarnings("unchecked") // varargs public void testOr_applyTernary() { assertEvalsLikeOdd(Predicates.or(isOdd(), FALSE, FALSE)); assertEvalsLikeOdd(Predicates.or(FALSE, isOdd(), FALSE)); assertEvalsLikeOdd(Predicates.or(FALSE, FALSE, isOdd())); assertEvalsToTrue(Predicates.or(FALSE, TRUE, NEVER_REACHED)); }
@GwtIncompatible // Predicates.subtypeOf public void testSubtypeOf_apply() { Predicate<Class<?>> isInteger = Predicates.subtypeOf(Integer.class); assertTrue(isInteger.apply(Integer.class)); assertFalse(isInteger.apply(Float.class)); try { isInteger.apply(null); fail(); } catch (NullPointerException expected) { } }
@GwtIncompatible // SerializableTester @SuppressWarnings("unchecked") // varargs public void testAnd_serializationIterable() { checkSerialization(Predicates.and(Arrays.asList(TRUE, FALSE))); }
private static void assertEvalsToFalse(Predicate<? super Integer> predicate) { assertFalse(predicate.apply(0)); assertFalse(predicate.apply(1)); assertFalse(predicate.apply(null)); }
private static <T> void assertEvalsLike( Predicate<? super T> expected, Predicate<? super T> actual, T input) { Boolean expectedResult = null; RuntimeException expectedRuntimeException = null; try { expectedResult = expected.apply(input); } catch (RuntimeException e) { expectedRuntimeException = e; } Boolean actualResult = null; RuntimeException actualRuntimeException = null; try { actualResult = actual.apply(input); } catch (RuntimeException e) { actualRuntimeException = e; } assertEquals(expectedResult, actualResult); if (expectedRuntimeException != null) { assertNotNull(actualRuntimeException); assertEquals(expectedRuntimeException.getClass(), actualRuntimeException.getClass()); } }
private static void assertEvalsToTrue(Predicate<? super Integer> predicate) { assertTrue(predicate.apply(0)); assertTrue(predicate.apply(1)); assertTrue(predicate.apply(null)); }
private static void assertEvalsLike( Predicate<? super Integer> expected, Predicate<? super Integer> actual) { assertEvalsLike(expected, actual, 0); assertEvalsLike(expected, actual, 1); assertEvalsLike(expected, actual, null); }
@SuppressWarnings("unchecked") // varargs public void testOr_applyNoArgs() { assertEvalsToFalse(Predicates.or()); }
@SuppressWarnings("unchecked") // varargs public void testAnd_applyNoArgs() { assertEvalsToTrue(Predicates.and()); }
@SuppressWarnings("unchecked") // varargs public void testAnd_applyIterable() { Collection<Predicate<Integer>> empty = Arrays.asList(); assertEvalsToTrue(Predicates.and(empty)); assertEvalsLikeOdd(Predicates.and(Arrays.asList(isOdd()))); assertEvalsLikeOdd(Predicates.and(Arrays.asList(TRUE, isOdd()))); assertEvalsToFalse(Predicates.and(Arrays.asList(FALSE, NEVER_REACHED))); }
public void testNotNull_apply() { Predicate<Integer> notNull = Predicates.notNull(); assertFalse(notNull.apply(null)); assertTrue(notNull.apply(1)); }