Assert an Exception Is Thrown in JUnit 4 and 5

1. Introduction

In this quick tutorial, we’ll be looking at how to test if an exception is thrown and how to test if no exception is thrown using the JUnit library.

We will, of course, make sure to cover both the JUnit 4 and JUnit 5 versions.

2. JUnit 5

Let’s look at the exception-handling assertions in JUnit 5.

2.1. Assert an Exception Is Thrown

JUnit 5 Jupiter assertions API introduces the assertThrows method for asserting exceptions.

This takes the type of the expected exception and an Executable functional interface where we can pass the code under test through a lambda expression:

@Test
void whenExceptionThrown_thenAssertionSucceeds() {
    Exception exception = assertThrows(NumberFormatException.class, () -> {
        Integer.parseInt("1a");
    });

    String expectedMessage = "For input string";
    String actualMessage = exception.getMessage();

    assertTrue(actualMessage.contains(expectedMessage));
}

If the expected exception is thrown, assertThrows returns the exception, which enables us to also assert on the message.

Furthermore, it’s important to note that this assertion is satisfied when the enclosed code throws an exception of type NumberFormatException or any of its derived types.

This means that if we pass Exception as the expected exception type, any exception thrown will make the assertion succeed since Exception is the super-type for all exceptions.

If we change the test above to expect a RuntimeException, this will also pass:

@Test
void whenDerivedExceptionThrown_thenAssertionSucceeds() {
    Exception exception = assertThrows(RuntimeException.class, () -> {
        Integer.parseInt("1a");
    });

    String expectedMessage = "For input string";
    String actualMessage = exception.getMessage();

    assertTrue(actualMessage.contains(expectedMessage));
}

The assertThrows() method enables more fine-grained control for exception assertion logic because we can use it around specific parts of the code.

2.2. Assert No Exception Is Thrown

Sometimes, it’s important to ensure that a block of code or a method executes without throwing any exceptions. JUnit 5 provides an easy way to perform this check. Let’s look at an example:

@Test
void givenABlock_whenExecutes_thenEnsureNoExceptionThrown {
    assertDoesNotThrow(() -> {
        Integer.parseInt("100");
    });
}

The assertDoesNotThrow() method executes the provided block of code. If the code block doesn’t throw an exception, the test passes. If an exception is thrown, the test fails.

2.3. Assert a Specific Type of Exception Is Not Thrown

In some cases, we might need to assert that the code doesn’t cause a particular type of exception. JUnit doesn’t provide a built-in method for it. However, we can write a custom method to handle this scenario:

First, let’s create a functional interface that allows us to generically define the interface that can be used in our custom implementation:

@FunctionalInterface
public interface Executable {
    void execute() throws Exception;
}

Then, we can use this in the custom implementation to pass the desired exception class and execute the code block:

private <T extends Exception> void assertSpecificExceptionIsNotThrown(Class<T> exceptionClass, Executable executable) {
    try {
        executable.execute();
    } catch (Exception e) {
        if (exceptionClass.isInstance(e)) {
            fail(e.getClass().getSimpleName() + " was thrown");
        } else {
            // Any other exception types are ignored and test passes!
            // Logging it here for debugging purpose
            LOG.info("Caught exception: " + e.getClass().getName() + ", but ignoring since it it not an instance of " + exceptionClass.getName())
        }
    }
}

Now, we can use this method as:

@Test
void givenASpecificExceptionType_whenBlockExecutes_thenEnsureThatExceptionIsNotThrown() {
    assertSpecificExceptionIsNotThrown(IllegalArgumentException.class, () -> {
        int i = 100 / 0;
    });
}

This test fails if the code block throws an IllegalArgumentException or any of its subtypes. The test passes for any other type of exception or if no exception is generated. This is useful in scenarios where we need to ensure that a specific type of exception is never thrown.

3. JUnit 4

In this section, let’s look at the different exception-handling assertions in JUnit 4.

3.1. Assert Exception Is Thrown

When using JUnit 4, we can simply use the expected attribute of the @Test annotation to declare that we expect an exception to be thrown anywhere in the annotated test method.

As a result, when the test is run, it will fail if the specified exception isn’t thrown and will pass if it’s thrown:

@Test(expected = NullPointerException.class)
public void whenExceptionThrown_thenExpectationSatisfied() {
    String test = null;
    test.length();
}

In this example, we’ve declared that we’re expecting our test code to result in a NullPointerException.

This is enough if we’re only interested in asserting that an exception is thrown.

When we need to verify some other properties of the exception, we can use the ExpectedException rule.

Let’s see an example of verifying the message property of an exception:

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

@Test
public void whenExceptionThrown_thenRuleIsApplied() {
    exceptionRule.expect(NumberFormatException.class);
    exceptionRule.expectMessage("For input string");
    Integer.parseInt("1a");
}

In the example above, we’re first declaring the ExpectedException rule. Then in our test, we’re asserting that the code that attempts to parse an Integer value will result in a NumberFormatException with the message “For input string”.

3.2. Assert No Exception Is Thrown

Unlike JUnit 5, JUnit 4 doesn’t provide a built-in method to assert that no exceptions are generated from the code. However, we can implement this logic easily. Let’s look at the implementation:

private void assertNoExceptionIsThrown(Executable executable) {
    try {
        executable.execute();
    } catch (Exception e) {
        fail(e.getClass().getSimpleName() + " was thrown");
    }
}

We utilized the previously created Executable functional interface to pass the code block. If any exceptions are thrown, we catch them and explicitly fail the test. Now, we can use this in the test:

@Test
public void givenABlock_whenExecuted_thenEnsureThatNoExceptionAreThrown() {
    assertNoExceptionIsThrown(() -> {
        int d = 100 / 10;
    });
}

The test fails if any exception is thrown in the code block.

4. Conclusion

In this article, we covered asserting exceptions with both JUnit 4 and JUnit 5. We examined methods for asserting that an exception is thrown as well as ensuring that no exceptions are thrown. Additionally, we created a custom implementation to handle specific types of exceptions.