Should method preconditions be unit tested?

Question

I use Guava's Preconditions to validate the input of my methods, e.g.:

class TestedClass {
  public double sqrt(double value) {
    Preconditions.checkArgument(value >= 0.0, "negative value: %s", value);
  }
}

I am wondering should the preconditions be unit tested? Should I have a test:

@Rule
public ExpectedException exception = ExpectedException.none();

@Test
public void shouldFailWhenValueIsNegative() {
   exception.thown(IllegalArgumentException.class);
   exception.expectMessage("negative value: -1");

   new TestedClass().sqrt(-1);
} 

Answer 1

My opinion is that yes, you should typically have tests that verify that the behavior of your method matches that specified by its contract (including preconditions). If you say your method throws a certain exception when given a negative value for a parameter, have a test that ensure's that's true.

For really common things like NullPointerException, guava-testlib has NullPointerTester, which we use for testing that NPE is thrown for parameters that aren't annotated with @Nullable.

Answer 2

To posit the opposite argument (and sit on the fence with an 'It depends'), the how the preconditions are checked is an implementation detail, the fact is that the behaviour that you want is that an exception is thrown if the preconditions are violated. Given this I think you should check these conditions in your tests as your tests should verify that the behaviour is what you expect.

Having said that I think it depends on what the preconditions are checking, and how they are applied. If you are applying annotation to the whole package so that no null values are allowed to be passed, then it doesn't make sense to me to then check that with a test for every method.

But in your example you are checking something specific in your sqrt function and the fact that you are checking with a specific piece of technology is, IMHO, irrelevant and you should test for that to validate the behaviour of the method.