Testing things that should be the same both ways

Question

For example the Equals method. a should equal b and b should equal a. Would you say it is OK to check this in one test case using two asserts like the following:

[Test]
public void Equals_TwoEqualObjects_ReturnsTrue()
{
    var a = new Something();
    var b = new Something();

    Assert.That(a.Equals(b), Is.True);
    Assert.That(b.Equals(a), Is.True);
}

Or do you think this should be done in two separate tests so that you won't have two asserts in the test?

I'm thinking having two asserts in this case may be cleaner, because I am not sure what I would call the two separate tests, and I am kind of thinking it doesn't matter which one of the asserts that break the test. But anyways, I am curious to know what others think about this since I am kind of a newbie in this area :)

Answer 1

I think it's absolutely fine to have them in one test.

The "one assert per test" idea feels more like dogma than anything useful to me. Be pragmatic with your testing.

Yes, test one piece of functionality per test - but don't restrict yourself to one assertion.

Answer 2

I would have them in two tests as if one of the links is incorrectly set up you will know exactly what one, remember a Unit test tests the smallest possible unit.

Answer 3

I'm going to say you have to have both tests in one place. It's not enough that one object equals the other and some other one object equals another. It's that the same two objects equal each other at the same time.

The intent of your test (to test that equals is commutative) is much clearer in the two assertions case.

Answer 4

It Depends.

If you're doing something complex where having this be commutative is a critical function and isnt a no-brainer, then having the tests granular enough to reflect that makes sense - it allows you to isolate problems much quicker.

In lots of cases, this will be overkill. A test has to have a point.

Saying that doesnt mean that you should shoe-horn in as many asserts as possible - that would be too far in the other direction.

Bottom line is there is not and should not be an absolute rule for this. But the general point is to keep tests

• Short
• Useful in isolating issues
• Useful in documenting behaviour

Answer 5

Both of your asserts test the same thing. That one object of a type is equal to another object of the same type. The Equals code doesn't have any way of telling which local variables it's being invoked on and which are parameters. I think it would suffice to have a single assert that says that any object of a type is equal to any other object of that type. If that is true, then commutativity holds.