assertFalse(filter1.equals(null), "Expected " + filter1 + " to not equal " + null);
        assertTrue(filter1.equals(filter1), "Expected " + filter1 + " to equal " + filter1);
        assertEquals(filter1.hashCode(), filter1.hashCode());

        assertFalse(filter1.equals(filter2), "Expected " + filter1 + " to not equal " + filter2);
        assertFalse(filter2.equals(filter1), "Expected " + filter2 + " to not equal " + filter1);

      assertTrue(item + " must not be Object#equals to null", !item.equals(null));
      assertTrue(
          item + " must not be Object#equals to an arbitrary object of another class",
          !item.equals(NotAnInstance.EQUAL_TO_NOTHING));
      assertTrue(item + " must be Object#equals to itself", item.equals(item));
      assertEquals(

        getList().equals(other));
  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)
  public void testEquals_shorterList() {
    Collection<E> fewerElements = getSampleElements(getNumElements() - 1);
    assertFalse(
        "Lists of different sizes should not be equal.",
        getList().equals(new ArrayList<E>(fewerElements)));
  }

          e,
          equalObject1
              + " [group 1, item 1] must be Object#equals to "
              + notEqualObject1
              + " [group 1, item 2]");
      return;
    }
    fail("Should get not equal to equal object error");
  }

  /**
   * Test EqualsTester with no equals or not equals objects. This checks proper handling of null,
   * incompatible class and reflexive tests
   */

    assertFalse(
        "Two Sets should not be equal if exactly one of them contains null.",
        getSet().equals(other));
  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)
  public void testEquals_smallerSet() {
    Collection<E> fewerElements = getSampleElements(getNumElements() - 1);
    assertFalse(
        "Sets of different sizes should not be equal.",
        getSet().equals(MinimalSet.from(fewerElements)));
  }

    assertFalse(
        "Two Sets should not be equal if exactly one of them contains null.",
        getSet().equals(other));
  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)
  public void testEquals_smallerSet() {
    Collection<E> fewerElements = getSampleElements(getNumElements() - 1);
    assertFalse(
        "Sets of different sizes should not be equal.",
        getSet().equals(MinimalSet.from(fewerElements)));
  }

          e,
          equalObject1
              + " [group 1, item 1] must be Object#equals to "
              + notEqualObject1
              + " [group 1, item 2]");
      return;
    }
    fail("Should get not equal to equal object error");
  }

  /**
   * Test EqualsTester with no equals or not equals objects. This checks proper handling of null,
   * incompatible class and reflexive tests
   */

    @ParametricNullness
    V rightValue();

    /**
     * Two instances are considered equal if their {@link #leftValue()} values are equal and their
     * {@link #rightValue()} values are also equal.
     */
    @Override
    boolean equals(@Nullable Object other);

    /**
     * The hash code equals the value {@code Arrays.asList(leftValue(), rightValue()).hashCode()}.
     */
    @Override

    assertTrue("An Object should be equal to itself.", collection.equals(collection));
  }

  // Comparisons to null *are* defined.
  @SuppressWarnings("UndefinedEquals")
  public void testEquals_null() {
    // noinspection ObjectEqualsNull
    assertFalse("An object should not be equal to null.", collection.equals(null));
  }

  // A collection should essentially never be equal to a non-collection.

        assertFalse(r1.hashCode() == r3.hashCode());

        assertTrue(r1.equals(r2), "Expected " + r1 + " to equal " + r2);
        assertTrue(r2.equals(r1), "Expected " + r2 + " to equal " + r1);

        assertFalse(r1.equals(r3), "Expected " + r1 + " to not equal " + r3);
        assertFalse(r3.equals(r1), "Expected " + r3 + " to not equal " + r1);
    }