Testing equals and hashCode

This isn't a post about whether it is a good idea to implement equals and hashCode in all your classes, and if so how (check all fields, check some kind of identifier, check fields except the boring ones, etc).

No, I'm assuming that you have decided to implement equals and hashCode, either because you like working that way, or because you are using a package like Hibernate which encourages/requires it.

So now the question is: being good test-driven developers that we are, how do we write the tests for our equals and hashCode methods? Many of us have probably read the javadoc for Object#equals (the so-called equals contract), and started out
writing things like:

assertTrue(one.equals(two));
assertTrue(two.equals(one));
assertFalse(one.equals(null));

etc.

And that's about right. But it seems like this is a framework waiting to happen (well, framework is probably too grandiose a word for something which probably doesn't need to be more than a hundred or so lines of code and just affects tests for equals and hashCode, but hey, people have called things frameworks for less).

Are there any good ones out there in Apache commons or the other usual places? I've seen some really bad ones, but generally have just ended up writing them myself. I'm enclosing the one I'm currently using in both Mayfly and MIFOS.

The one thing it doesn't do super-well is test transitivity. You can give it a bunch of things which should all be equals to each other, and it tests that they all are, but it doesn't do any transitivity tests for not-equals. I think it is pretty clear how to fix that: instead of just passing in a bunch A of things equals to each other, pass in several bunches: A, B, and C. Each object within A should be equals to the others in A, but none of the ones in B and C. Likewise for B and C (the mathematically experienced of you will recognized these "bunches" as equivalence classes). In fact, I started to implement this today, and I got a bit hung up on whether it reads as nicely as what I have now. Somehow, passing in Object[][] { new Object[] { a1,a2}} just seemed like too many levels of [] and {} and such. I don't know if my concern is justified.

public static void assertAllEqual(Object[] objects) {
    /**
     * The point of checking each pair is to make sure that equals is
     * transitive per the contract of {@link Object#equals(java.lang.Object)}.
     */
    for (int i = 0; i < objects.length; i++) {
        Assert.assertFalse(objects[i].equals(null));
        for (int j = 0; j < objects.length; j++) {
            assertIsEqual(objects[i], objects[j]);
        }
    }
}

public static void assertIsEqual(Object one, Object two) {
    Assert.assertTrue(one.equals(two));
    Assert.assertTrue(two.equals(one));
    Assert.assertEquals(one.hashCode(), two.hashCode());
}

public static void assertIsNotEqual(Object one, Object two) {
    assertReflexiveAndNull(one);
    assertReflexiveAndNull(two);
    Assert.assertFalse(one.equals(two));
    Assert.assertFalse(two.equals(one));
}

public static void assertReflexiveAndNull(Object object) {
    Assert.assertTrue(object.equals(object));
    Assert.assertFalse(object.equals(null));
}