如何在junit4 Java中测试多行代码是否引发异常

Question

I am writing a negative test for the method add(T elem, int index) of a class. The method is expected to throw IllegalArgumentException if index < 0 || index > size || elem == null index < 0 || index > size || elem == null index < 0 || index > size || elem == null . My test looks like this:

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

@Test(expected = IllegalArgumentException.class) 
public void addNegTest() {
    l0.add(42, 10);  // index > size 
    l0.add(42, -1);  // index < 0
    l0.add(null, 2); // elem == null
}

The test turns green, but I figured it out that it takes only 1 of these 3 lines of code to throw an exception in order for the test to turn green. So if I add 1 line to the code like this, the test still turns green.

@Test(expected = IllegalArgumentException.class) 
public void addNegTest() {
    l0.add(42, 10);  // index > size 
    l0.add(42, -1);  // index < 0
    l0.add(null, 2); // elem == null
    l0.add(42, 0);   // this is perfectly fine 
}

So how I can make sure that the test tests if every single line throws an exception and not just one?

Answer 1

The expected exception is expected in the scope of the whole test method execution whatever if some other statements don't throw it.
So you should create a test method by possible scenario.

@Test(expected = IllegalArgumentException.class) 
public void add_with_index_greater_than_size() {
    l0.add(42, 10);  // index > size 
}  

@Test(expected = IllegalArgumentException.class) 
public void add_with_index_less_than_zero() {
    l0.add(42, -1);  
}  

@Test(expected = IllegalArgumentException.class) 
public void add_with_null_arg() {
    l0.add(null, 10); 
}  

@Test
public void add() {
    l0.add(42, 10);  
    Assert.assertEquals(42, l0.get(10));
}  

While you could still use a single test method with as many try/catch statements as failing scenarios to test as shown in the SilverNak answer , I would not recommend it for readability reasons.

Note that beyond your case, specifying each distinct scenario in its own method is a good practice as it makes tests more readable and it also makes simpler/easier to correct a test that fails as its responsibility is clearer and well defined.

---

JUnit 5 improvements

Note that with the last release JUnit version, you could gather some common cases in a same method without decreasing the code readability.
You could gather the invalid cases with incorrect index passed to such as :

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
...
@Test
public void add_with_index_less_than_zero_or_greater_than_size() {
    Assertions.assertThrows(IllegalArgumentException.class, 
                             () -> l0.add(42, 10));
    Assertions.assertThrows(IllegalArgumentException.class, 
                             () -> l0.add(42, -1));
}  

But I would keep this one in a separate method :

import  org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
...
@Test
public void add_with_null_arg() {
    Assertions.assertThrows(IllegalArgumentException.class, 
                             () -> l0.add(null, 10));
}  

Answer 2

By writing four different test methods:

@Test(expected = IllegalArgumentException.class) 
public void addNegTest_indexTooLarge() {
    l0.add(42, 10);  // index > size 
}

@Test(expected = IllegalArgumentException.class) 
public void addNegTest_negativeIndex() {
    l0.add(42, -1);  // index < 0
}

@Test(expected = IllegalArgumentException.class) 
public void addNegTest_nullElement() {
    l0.add(null, 2); // elem == null
}

@Test
public void addNegTest_ok() {
    l0.add(42, 0);   // this is perfectly fine 
}

If you use a plugin such as JaCoCo , you can visually confirm that all possible paths are covered.

Answer 3

An exception will terminate the method which is currently executed, until the exception is caught. So you have two possibilities:

One method for every test

You can write one method for every scenario in which an exception should be thrown:

@Test(expected = IllegalArgumentException.class) 
public void addIndexGreaterThanSize() {
    l0.add(42, 10);  // index > size 
}

@Test(expected = IllegalArgumentException.class) 
public void addIndexNegative() {
    l0.add(42, -1);  // index < 0
}

@Test(expected = IllegalArgumentException.class) 
public void addElementNull() {
    l0.add(null, 2); // elem == null
}

Catch exceptions yourself

You could also catch all exceptions yourself and fail the test if the exception is not thrown. When you use this method, you can verify additional properties of the exception (eg the message).

@Test
public void addNegTest() {
    try {
        l0.add(42, 10);  // index > size 
        fail();
    } catch (IllegalArgumentException e) {}
    try {
        l0.add(42, -1);  // index < 0
        fail();
    } catch (IllegalArgumentException e) {}
    try {
        l0.add(null, 2); // elem == null
        fail();
    } catch (IllegalArgumentException e) {}
}

If you do want to test additional properties of the thrown exception, you can choose the second method. Otherwise, I recommend the first alternative as it is easier to understand and less code to write yourself.