test/com/google/common/base/PredicatesTest.java

/*
 * Copyright (C) 2005 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.base;

import com.google.common.collect.ImmutableSet;
import com.google.common.testutils.EqualsTester;
import com.google.common.testutils.NullPointerTester;
import com.google.common.testutils.SerializableTester;

import junit.framework.TestCase;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

/**
 * Unit test for {@link Predicates}.
 *
 * @author Kevin Bourrillion
 */
public class PredicatesTest extends TestCase {
  private static final Predicate<Integer> TRUE = Predicates.alwaysTrue();
  private static final Predicate<Integer> FALSE = Predicates.alwaysFalse();
  private static final Predicate<Integer> NEVER_REACHED =
      new Predicate<Integer>() {
    public boolean apply(Integer i) {
      fail("This predicate should never have been evaluated");
      return false;
    }
  };

  /** Instantiable predicate with reasonable hashCode() and equals() methods. */
  static class IsOdd implements Predicate<Integer>, Serializable {
    private static final long serialVersionUID = 0x150ddL;
    public boolean apply(Integer i) {
      return (i.intValue() & 1) == 1;
    }
    @Override public int hashCode() {
      return 0x150dd;
    }
    @Override public boolean equals(Object obj) {
      return obj instanceof IsOdd;
    }
    @Override public String toString() {
      return "IsOdd";
    }
  }

  /**
   * Generates a new Predicate per call.
   *
   * <p>Creating a new Predicate each time helps catch cases where code is
   * using {@code x == y} instead of {@code x.equals(y)}.
   */
  private static IsOdd isOdd() {
    return new IsOdd();
  }

  /*
   * Tests for Predicates.alwaysTrue().
   */

  public void testAlwaysTrue_apply() {
    assertEvalsToTrue(Predicates.alwaysTrue());
  }

  public void testAlwaysTrue_equality() throws Exception {
    new EqualsTester(TRUE)
        .addEqualObject(Predicates.alwaysTrue())
        .addNotEqualObject(isOdd())
        .addNotEqualObject(Predicates.alwaysFalse())
        .testEquals();
  }

  public void testAlwaysTrue_serialization() {
    checkSerialization(Predicates.alwaysTrue());
  }

  /*
   * Tests for Predicates.alwaysFalse().
   */

  public void testAlwaysFalse_apply() throws Exception {
    assertEvalsToFalse(Predicates.alwaysFalse());
  }

  public void testAlwaysFalse_equality() throws Exception {
    new EqualsTester(FALSE)
        .addEqualObject(Predicates.alwaysFalse())
        .addNotEqualObject(isOdd())
        .addNotEqualObject(Predicates.alwaysTrue())
        .testEquals();
  }

  public void testAlwaysFalse_serialization() {
    checkSerialization(Predicates.alwaysFalse());
  }

  /*
   * Tests for Predicates.not(predicate).
   */

  public void testNot_apply() {
    assertEvalsToTrue(Predicates.not(FALSE));
    assertEvalsToFalse(Predicates.not(TRUE));
    assertEvalsLikeOdd(Predicates.not(Predicates.not(isOdd())));
  }

  public void testNot_equality() {
    new EqualsTester(Predicates.not(isOdd()))
        .addEqualObject(Predicates.not(isOdd()))
        .addNotEqualObject(Predicates.not(TRUE))
        .addNotEqualObject(isOdd())
        .testEquals();
  }

  public void testNot_equalityForNotOfKnownValues() {
    /* Would be nice to have .addEqualObject(Predicates.not(FALSE)). */
    new EqualsTester(TRUE)
        .addEqualObject(Predicates.alwaysTrue())
        .addNotEqualObject(FALSE)
        .addNotEqualObject(Predicates.not(TRUE))
        .testEquals();

    /* Would be nice to have .addEqualObject(Predicates.not(TRUE)). */
    new EqualsTester(FALSE)
        .addEqualObject(Predicates.alwaysFalse())
        .addNotEqualObject(TRUE)
        .addNotEqualObject(Predicates.not(FALSE))
        .testEquals();

    /* Would be nice to have .addEqualObject(Predicates.not(notNull())). */
    new EqualsTester(Predicates.isNull())
        .addEqualObject(Predicates.isNull())
        .addNotEqualObject(Predicates.notNull())
        .addNotEqualObject(Predicates.not(Predicates.isNull()))
        .testEquals();

    /* Would be nice to have .addEqualObject(Predicates.not(isNull())). */
    new EqualsTester(Predicates.notNull())
        .addEqualObject(Predicates.notNull())
        .addNotEqualObject(Predicates.isNull())
        .addNotEqualObject(Predicates.not(Predicates.notNull()))
        .testEquals();
  }

  public void testNot_serialization() {
    checkSerialization(Predicates.not(isOdd()));
  }

  /*
   * Tests for all the different flavors of Predicates.and().
   */

  @SuppressWarnings("unchecked")
  public void testAnd_applyNoArgs() {
    assertEvalsToTrue(Predicates.and());
  }

  @SuppressWarnings("unchecked")
  public void testAnd_equalityNoArgs() {
    new EqualsTester(Predicates.and())
        .addEqualObject(Predicates.and())
        .addNotEqualObject(Predicates.and(FALSE))
        .addNotEqualObject(Predicates.or())
        .testEquals();
  }

  @SuppressWarnings("unchecked")
  public void testAnd_serializationNoArgs() {
    checkSerialization(Predicates.and());
  }

  @SuppressWarnings("unchecked")
  public void testAnd_applyOneArg() {
    assertEvalsLikeOdd(Predicates.and(isOdd()));
  }

  @SuppressWarnings("unchecked")
  public void testAnd_equalityOneArg() {
    new EqualsTester(Predicates.and(NEVER_REACHED))
        .addEqualObject(Predicates.and(NEVER_REACHED))
        .addNotEqualObject(Predicates.and(NEVER_REACHED, FALSE))
        .addNotEqualObject(Predicates.and(isOdd()))
        .addNotEqualObject(Predicates.and())
        .addNotEqualObject(Predicates.or(NEVER_REACHED))
        .testEquals();
  }

  @SuppressWarnings("unchecked")
  public void testAnd_serializationOneArg() {
    checkSerialization(Predicates.and(isOdd()));
  }

  public void testAnd_applyBinary() {
    assertEvalsLikeOdd(Predicates.and(isOdd(), TRUE));
    assertEvalsLikeOdd(Predicates.and(TRUE, isOdd()));
    assertEvalsToFalse(Predicates.and(FALSE, NEVER_REACHED));
  }

  @SuppressWarnings("unchecked")
  public void testAnd_equalityBinary() {
    new EqualsTester(Predicates.and(TRUE, NEVER_REACHED))
        .addEqualObject(Predicates.and(TRUE, NEVER_REACHED))
        .addNotEqualObject(Predicates.and(NEVER_REACHED, TRUE))
        .addNotEqualObject(Predicates.and(TRUE))
        .addNotEqualObject(Predicates.or(TRUE, NEVER_REACHED))
        .testEquals();
  }

  public void testAnd_serializationBinary() {
    checkSerialization(Predicates.and(TRUE, isOdd()));
  }

  @SuppressWarnings("unchecked")
  public void testAnd_applyTernary() {
    assertEvalsLikeOdd(Predicates.and(isOdd(), TRUE, TRUE));
    assertEvalsLikeOdd(Predicates.and(TRUE, isOdd(), TRUE));
    assertEvalsLikeOdd(Predicates.and(TRUE, TRUE, isOdd()));
    assertEvalsToFalse(Predicates.and(TRUE, FALSE, NEVER_REACHED));
  }

  @SuppressWarnings("unchecked")
  public void testAnd_equalityTernary() {
    new EqualsTester(Predicates.and(TRUE, isOdd(), NEVER_REACHED))
        .addEqualObject(Predicates.and(TRUE, isOdd(), NEVER_REACHED))
        .addNotEqualObject(Predicates.and(isOdd(), NEVER_REACHED, TRUE))
        .addNotEqualObject(Predicates.and(TRUE))
        .addNotEqualObject(Predicates.or(TRUE, isOdd(), NEVER_REACHED))
        .testEquals();
  }

  @SuppressWarnings("unchecked")
  public void testAnd_serializationTernary() {
    checkSerialization(Predicates.and(TRUE, isOdd(), FALSE));
  }

  @SuppressWarnings("unchecked")
  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)));
  }

  @SuppressWarnings("unchecked")
  public void testAnd_equalityIterable() {
    new EqualsTester(Predicates.and(Arrays.asList(TRUE, NEVER_REACHED)))
        .addEqualObject(Predicates.and(Arrays.asList(TRUE, NEVER_REACHED)))
        .addEqualObject(Predicates.and(TRUE, NEVER_REACHED))
        .addNotEqualObject(Predicates.and(FALSE, NEVER_REACHED))
        .addNotEqualObject(Predicates.or(TRUE, NEVER_REACHED))
        .testEquals();
  }

  @SuppressWarnings("unchecked")
  public void testAnd_serializationIterable() {
    checkSerialization(Predicates.and(Arrays.asList(TRUE, FALSE)));
  }

  @SuppressWarnings("unchecked")
  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));
  }

  @SuppressWarnings("unchecked")
  public void testAnd_listDefensivelyCopied() {
    List list = new ArrayList<Predicate>();
    Predicate<Object> predicate = Predicates.and(list);
    assertTrue(predicate.apply(1));
    list.add(Predicates.alwaysFalse());
    assertTrue(predicate.apply(1));
  }

  @SuppressWarnings("unchecked")
  public void testAnd_iterableDefensivelyCopied() {
    final List list = new ArrayList<Predicate>();
    Iterable iterable = new Iterable<Predicate>() {
      public Iterator<Predicate> iterator() {
        return list.iterator();
      }
    };
    Predicate<Object> predicate = Predicates.and(iterable);
    assertTrue(predicate.apply(1));
    list.add(Predicates.alwaysFalse());
    assertTrue(predicate.apply(1));
  }

  /*
   * Tests for all the different flavors of Predicates.or().
   */

  @SuppressWarnings("unchecked")
  public void testOr_applyNoArgs() {
    assertEvalsToFalse(Predicates.or());
  }

  @SuppressWarnings("unchecked")
  public void testOr_equalityNoArgs() {
    new EqualsTester(Predicates.or())
        .addEqualObject(Predicates.or())
        .addNotEqualObject(Predicates.or(TRUE))
        .addNotEqualObject(Predicates.and())
        .testEquals();
  }

  @SuppressWarnings("unchecked")
  public void testOr_serializationNoArgs() {
    checkSerialization(Predicates.or());
  }

  @SuppressWarnings("unchecked")
  public void testOr_applyOneArg() {
    assertEvalsToTrue(Predicates.or(TRUE));
    assertEvalsToFalse(Predicates.or(FALSE));
  }

  @SuppressWarnings("unchecked")
  public void testOr_equalityOneArg() {
    new EqualsTester(Predicates.or(NEVER_REACHED))
        .addEqualObject(Predicates.or(NEVER_REACHED))
        .addNotEqualObject(Predicates.or(NEVER_REACHED, TRUE))
        .addNotEqualObject(Predicates.or(TRUE))
        .addNotEqualObject(Predicates.or())
        .addNotEqualObject(Predicates.and(NEVER_REACHED))
        .testEquals();
  }

  @SuppressWarnings("unchecked")
  public void testOr_serializationOneArg() {
    checkSerialization(Predicates.or(isOdd()));
  }

  public void testOr_applyBinary() {
    Predicate<Integer> falseOrFalse = Predicates.or(FALSE, FALSE);
    Predicate<Integer> falseOrTrue = Predicates.or(FALSE, TRUE);
    Predicate<Integer> trueOrAnything = Predicates.or(TRUE, NEVER_REACHED);

    assertEvalsToFalse(falseOrFalse);
    assertEvalsToTrue(falseOrTrue);
    assertEvalsToTrue(trueOrAnything);
  }

  @SuppressWarnings("unchecked")
  public void testOr_equalityBinary() {
    new EqualsTester(Predicates.or(FALSE, NEVER_REACHED))
    .addEqualObject(Predicates.or(FALSE, NEVER_REACHED))
    .addNotEqualObject(Predicates.or(NEVER_REACHED, FALSE))
    .addNotEqualObject(Predicates.or(TRUE))
    .addNotEqualObject(Predicates.and(FALSE, NEVER_REACHED))
    .testEquals();
  }

  public void testOr_serializationBinary() {
    checkSerialization(Predicates.or(isOdd(), TRUE));
  }

  @SuppressWarnings("unchecked")
  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));
  }

  @SuppressWarnings("unchecked")
  public void testOr_equalityTernary() {
    new EqualsTester(Predicates.or(FALSE, NEVER_REACHED, TRUE))
        .addEqualObject(Predicates.or(FALSE, NEVER_REACHED, TRUE))
        .addNotEqualObject(Predicates.or(TRUE, NEVER_REACHED, FALSE))
        .addNotEqualObject(Predicates.or(TRUE))
        .addNotEqualObject(Predicates.and(FALSE, NEVER_REACHED, TRUE))
        .testEquals();
  }

  @SuppressWarnings("unchecked")
  public void testOr_serializationTernary() {
    checkSerialization(Predicates.or(FALSE, isOdd(), TRUE));
  }

  @SuppressWarnings("unchecked")
  public void testOr_applyIterable() {
    Predicate<Integer> vacuouslyFalse =
        Predicates.or(Collections.<Predicate<Integer>>emptyList());
    Predicate<Integer> troo = Predicates.or(Collections.singletonList(TRUE));
    /*
     * newLinkedList() takes varargs. TRUE and FALSE are both instances of
     * Predicate<Integer>, so the call is safe.
     */
    Predicate<Integer> trueAndFalse = Predicates.or(Arrays.asList(TRUE, FALSE));

    assertEvalsToFalse(vacuouslyFalse);
    assertEvalsToTrue(troo);
    assertEvalsToTrue(trueAndFalse);
  }

  @SuppressWarnings("unchecked")
  public void testOr_equalityIterable() {
    new EqualsTester(Predicates.or(Arrays.asList(FALSE, NEVER_REACHED)))
        .addEqualObject(Predicates.or(Arrays.asList(FALSE, NEVER_REACHED)))
        .addEqualObject(Predicates.or(FALSE, NEVER_REACHED))
        .addNotEqualObject(Predicates.or(TRUE, NEVER_REACHED))
        .addNotEqualObject(Predicates.and(FALSE, NEVER_REACHED))
        .testEquals();
  }

  @SuppressWarnings("unchecked")
  public void testOr_serializationIterable() {
    Predicate<Integer> pre = Predicates.or(Arrays.asList(TRUE, FALSE));
    Predicate<Integer> post = SerializableTester.reserializeAndAssert(pre);
    assertEquals(pre.apply(0), post.apply(0));
  }

  @SuppressWarnings("unchecked")
  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));
  }

  @SuppressWarnings("unchecked")
  public void testOr_listDefensivelyCopied() {
    List list = new ArrayList<Predicate>();
    Predicate<Object> predicate = Predicates.or(list);
    assertFalse(predicate.apply(1));
    list.add(Predicates.alwaysTrue());
    assertFalse(predicate.apply(1));
  }

  @SuppressWarnings("unchecked")
  public void testOr_iterableDefensivelyCopied() {
    final List list = new ArrayList<Predicate>();
    Iterable iterable = new Iterable<Predicate>() {
      public Iterator<Predicate> iterator() {
        return list.iterator();
      }
    };
    Predicate<Object> predicate = Predicates.or(iterable);
    assertFalse(predicate.apply(1));
    list.add(Predicates.alwaysTrue());
    assertFalse(predicate.apply(1));
  }

  /*
   * Tests for Predicates.equalTo(x).
   */

  public void testIsEqualTo_apply() {
    Predicate<Integer> isOne = Predicates.equalTo(1);

    assertTrue(isOne.apply(1));
    assertFalse(isOne.apply(2));
    assertFalse(isOne.apply(null));
  }

  public void testIsEqualTo_equality() {
    new EqualsTester(Predicates.equalTo(1))
        .addEqualObject(Predicates.equalTo(1))
        .addNotEqualObject(Predicates.equalTo(2))
        .addNotEqualObject(Predicates.equalTo(null))
        .testEquals();
  }

  public void testIsEqualTo_serialization() {
    checkSerialization(Predicates.equalTo(1));
  }

  public void testIsEqualToNull_apply() {
    Predicate<Integer> isNull = Predicates.equalTo(null);
    assertTrue(isNull.apply(null));
    assertFalse(isNull.apply(1));
  }

  public void testIsEqualToNull_equality() {
    new EqualsTester(Predicates.equalTo(null))
        .addEqualObject(Predicates.equalTo(null))
        .addNotEqualObject(Predicates.equalTo(1))
        .addNotEqualObject(Predicates.equalTo("null"))
        .testEquals();
  }

  public void testIsEqualToNull_serialization() {
    checkSerialization(Predicates.equalTo(null));
  }

  /*
   * Tests for Predicates.instanceOf(x).
   */

  public void testIsInstanceOf_apply() {
    Predicate<Object> isInteger = Predicates.instanceOf(Integer.class);

    assertTrue(isInteger.apply(1));
    assertFalse(isInteger.apply(2.0f));
    assertFalse(isInteger.apply(""));
    assertFalse(isInteger.apply(null));
  }

  public void testIsInstanceOf_subclass() {
    Predicate<Object> isNumber = Predicates.instanceOf(Number.class);

    assertTrue(isNumber.apply(1));
    assertTrue(isNumber.apply(2.0f));
    assertFalse(isNumber.apply(""));
    assertFalse(isNumber.apply(null));
  }

  public void testIsInstanceOf_interface() {
    Predicate<Object> isComparable = Predicates.instanceOf(Comparable.class);

    assertTrue(isComparable.apply(1));
    assertTrue(isComparable.apply(2.0f));
    assertTrue(isComparable.apply(""));
    assertFalse(isComparable.apply(null));
  }

  public void testIsInstanceOf_equality() {
    new EqualsTester(Predicates.instanceOf(Integer.class))
        .addEqualObject(Predicates.instanceOf(Integer.class))
        .addNotEqualObject(Predicates.instanceOf(Number.class))
        .addNotEqualObject(Predicates.instanceOf(Float.class))
        .testEquals();
  }

  public void testIsInstanceOf_serialization() {
    checkSerialization(Predicates.instanceOf(Integer.class));
  }

  /*
   * Tests for Predicates.isNull()
   */

  public void testIsNull_apply() {
    Predicate<Integer> isNull = Predicates.isNull();
    assertTrue(isNull.apply(null));
    assertFalse(isNull.apply(1));
  }

  public void testIsNull_equality() {
    new EqualsTester(Predicates.isNull())
        .addEqualObject(Predicates.isNull())
        .addNotEqualObject(Predicates.notNull())
        .testEquals();
  }

  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 testNotNull_apply() {
    Predicate<Integer> notNull = Predicates.notNull();
    assertFalse(notNull.apply(null));
    assertTrue(notNull.apply(1));
  }

  public void testNotNull_equality() {
    new EqualsTester(Predicates.notNull())
        .addEqualObject(Predicates.notNull())
        .addNotEqualObject(Predicates.isNull())
        .testEquals();
  }

  public void testNotNull_serialization() {
    checkSerialization(Predicates.notNull());
  }

  public void testIn_apply() {
    Collection<Integer> nums = Arrays.asList(1, 5);
    Predicate<Integer> isOneOrFive = Predicates.in(nums);

    assertTrue(isOneOrFive.apply(1));
    assertTrue(isOneOrFive.apply(5));
    assertFalse(isOneOrFive.apply(3));
    assertFalse(isOneOrFive.apply(null));
  }

  public void testIn_equality() {
    Collection<Integer> nums = ImmutableSet.of(1, 5);
    Collection<Integer> sameOrder = ImmutableSet.of(1, 5);
    Collection<Integer> differentOrder = ImmutableSet.of(5, 1);
    Collection<Integer> differentNums = ImmutableSet.of(1, 3, 5);

    new EqualsTester(Predicates.in(nums))
        .addEqualObject(Predicates.in(nums))
        .addEqualObject(Predicates.in(sameOrder))
        .addEqualObject(Predicates.in(differentOrder))
        .addNotEqualObject(Predicates.in(differentNums))
        .testEquals();
  }

  public void testIn_serialization() {
    checkSerialization(Predicates.in(Arrays.asList(1, 2, 3, null)));
  }

  public void testIn_handlesNullPointerException() {
    class CollectionThatThrowsNPE<T> extends ArrayList<T> {
      private static final long serialVersionUID = 1L;

      @Override public boolean contains(Object element) {
        Preconditions.checkNotNull(element);
        return super.contains(element);
      }
    }
    Collection<Integer> nums = new CollectionThatThrowsNPE<Integer>();
    Predicate<Integer> isFalse = Predicates.in(nums);
    assertFalse(isFalse.apply(null));
  }

  public void testIn_handlesClassCastException() {
    class CollectionThatThrowsCCE<T> extends ArrayList<T> {
      private static final long serialVersionUID = 1L;

      @Override public boolean contains(Object element) {
        throw new ClassCastException("");
      }
    }
    Collection<Integer> nums = new CollectionThatThrowsCCE<Integer>();
    nums.add(3);
    Predicate<Integer> isThree = Predicates.in(nums);
    assertFalse(isThree.apply(3));
  }

  /*
   * Tests that compilation will work when applying explicit types.
   */
  public void testIn_compilesWithExplicitSupertype() {
    Collection<Number> nums = ImmutableSet.of();
    Predicate<Number> p1 = Predicates.in(nums);
    Predicate<Object> p2 = Predicates.<Object>in(nums);
    // The next two lines are not expected to compile.
    // Predicate<Integer> p3 = Predicates.in(nums);
    // Predicate<Integer> p4 = Predicates.<Integer>in(nums);
  }

  public void testNullPointerExceptions() throws Exception {
    NullPointerTester tester = new NullPointerTester();
    tester.testAllPublicStaticMethods(Predicates.class);
  }

  @SuppressWarnings("unchecked") // varargs
  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);
  }

  // enum singleton pattern
  private enum TrimStringFunction implements Function<String, String> {
    INSTANCE;

    public String apply(String string) {
      return string.trim();
    }
  }

  public void testCompose() {
    Function<String, String> trim = TrimStringFunction.INSTANCE;
    Predicate<String> equalsFoo = Predicates.equalTo("Foo");
    Predicate<String> equalsBar = Predicates.equalTo("Bar");
    Predicate<String> trimEqualsFoo = Predicates.compose(equalsFoo, trim);
    Function<String, String> identity = Functions.identity();

    assertTrue(trimEqualsFoo.apply("Foo"));
    assertTrue(trimEqualsFoo.apply("   Foo   "));
    assertFalse(trimEqualsFoo.apply("Foo-b-que"));

    new EqualsTester(trimEqualsFoo)
        .addEqualObject(Predicates.compose(equalsFoo, trim))
        .addNotEqualObject(equalsFoo)
        .addNotEqualObject(trim)
        .addNotEqualObject(Predicates.compose(equalsFoo, identity))
        .addNotEqualObject(Predicates.compose(equalsBar, trim))
        .testEquals();

    SerializableTester.reserializeAndAssert(trimEqualsFoo);
  }

  public void checkConsistency(
      Predicate<? super Integer> expected, Predicate<? super Integer> actual) {
    assertEvalsLike(expected, actual);
    assertEquals(actual.toString() + " should hash like " + expected.toString(),
        expected.hashCode(), actual.hashCode());
  }

  public void testHashCodeForBooleanOperationsIsConsistentWithBooleanLogic() {
    /*
     * This isn't a "requirement" yet, as much as it's a "nice to have for
     * future design."
     *
     * Maybe it will be possible to eventually have these predicates do
     * certain simplifying logical transformations to simpler equivalent
     * forms.  If so, this checks that the hash codes have been chosen in such
     * a way that the fundamental building-block operations:
     *
     *    alwaysTrue()
     *    alwaysFalse()
     *    not(p)
     *    and(p1, p2)
     *    or(p1, p2)
     *
     * have hashCode() calculations that coincidentally cause equivalent logical
     * expressions to have equivalent hashCode() values.
     */
    Predicate<Integer> p1 = Predicates.isNull();
    Predicate<Integer> p2 = isOdd();
    Predicate<Integer> p3 = new Predicate<Integer>() {
      public boolean apply(Integer i) {
        return (Integer.bitCount(i) & 1) == 1;
      }
      @Override public String toString() {
        return "oddBitCount";
      }
    };

    checkConsistency(
        p1,
        Predicates.not(Predicates.not(p1)));

    checkConsistency(
        Predicates.and(Predicates.not(p1), Predicates.not(p2)),
        Predicates.not(Predicates.or(p1, p2)));

    checkConsistency(
        Predicates.or(Predicates.not(p1), Predicates.not(p2)),
        Predicates.not(Predicates.and(p1, p2)));

    checkConsistency(
        Predicates.and(Predicates.and(p1, p2), p3),
        Predicates.and(p1, Predicates.and(p2, p3)));

    checkConsistency(
        Predicates.or(Predicates.or(p1, p2), p3),
        Predicates.or(p1, Predicates.or(p2, p3)));

    checkConsistency(
        Predicates.or(Predicates.and(p1, p2), p3),
        Predicates.and(Predicates.or(p1, p3), Predicates.or(p2, p3)));

    checkConsistency(
        Predicates.and(Predicates.or(p1, p2), p3),
        Predicates.or(Predicates.and(p1, p3), Predicates.and(p2, p3)));

    /*
     * Now that alwaysFalse and alwaysTrue follow the enum singleton pattern,
     * the following tests can't call checkConsistency to compare the hash
     * codes.
     */

    assertEvalsLike(
        Predicates.alwaysTrue(),
        Predicates.not(Predicates.alwaysFalse()));

    assertEvalsLike(
        Predicates.alwaysFalse(),
        Predicates.not(Predicates.alwaysTrue()));

    assertEvalsLike(
        Predicates.alwaysFalse(),
        Predicates.and(p1, Predicates.not(p1)));

    assertEvalsLike(
        Predicates.alwaysTrue(),
        Predicates.or(p1, Predicates.not(p1)));
  }

  private static void assertEvalsToTrue(Predicate<? super Integer> predicate) {
    assertTrue(predicate.apply(0));
    assertTrue(predicate.apply(1));
    assertTrue(predicate.apply(null));
  }

  private static void assertEvalsToFalse(Predicate<? super Integer> predicate) {
    assertFalse(predicate.apply(0));
    assertFalse(predicate.apply(1));
    assertFalse(predicate.apply(null));
  }

  private static void assertEvalsLikeOdd(Predicate<? super Integer> predicate) {
    assertEvalsLike(isOdd(), predicate);
  }

  private static void assertEvalsLike(
      Predicate<? super Integer> expected,
      Predicate<? super Integer> actual) {
    assertEvalsLike(expected, actual, 0);
    assertEvalsLike(expected, actual, 1);
    assertEvalsLike(expected, actual, null);
  }

  private static void assertEvalsLike(
      Predicate<? super Integer> expected,
      Predicate<? super Integer> actual,
      Integer 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 checkSerialization(Predicate<? super Integer> predicate) {
    Predicate<? super Integer> reserialized =
        SerializableTester.reserializeAndAssert(predicate);
    assertEvalsLike(predicate, reserialized);
  }
}