Testing multiple exceptions in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of JUnit test with multiple expected exceptions

Consider the following JUnit 5 test method that expects either IllegalArgumentException or NullPointerException. What will be the test result when IllegalArgumentException is thrown?

JUnit

import org.junit.jupiter.api.Test;

public class ExceptionTest {
    @Test
    void testMultipleExceptions() {
        assertThrowsAnyOf(IllegalArgumentException.class, NullPointerException.class, () -> {
            throw new IllegalArgumentException("Invalid argument");
        });
    }

    static void assertThrowsAnyOf(Class<? extends Throwable> ex1, Class<? extends Throwable> ex2, Runnable executable) {
        try {
            executable.run();
            throw new AssertionError("Expected exception was not thrown");
        } catch (Throwable t) {
            if (!ex1.isInstance(t) && !ex2.isInstance(t)) {
                throw new AssertionError("Unexpected exception type: " + t.getClass());
            }
        }
    }
}

A Test passes because IllegalArgumentException is one of the expected exceptions.

B Test fails with AssertionError because the exception message does not match.

C Test fails with AssertionError because NullPointerException was expected but IllegalArgumentException was thrown.

D Test fails with a compilation error due to incorrect assertThrowsAnyOf usage.

💡 Hint

Think about whether the thrown exception matches any of the expected exception classes.

The custom assertThrowsAnyOf method checks if the thrown exception is an instance of either expected exception class. Since IllegalArgumentException is expected, the test passes.

❓ assertion

intermediate

Correct assertion for multiple exceptions in JUnit 5

Which of the following JUnit 5 assertions correctly verifies that a method throws either IOException or FileNotFoundException?

JUnit

void methodUnderTest() throws IOException {
    // implementation
}

A assertThrows(FileNotFoundException.class, () -> methodUnderTest());

B assertThrows(IOException.class, () -> methodUnderTest());

C assertThrowsAnyOf(IOException.class, FileNotFoundException.class, () -> methodUnderTest());

D assertThrowsAllOf(IOException.class, FileNotFoundException.class, () -> methodUnderTest());

💡 Hint

Consider the exception class hierarchy; FileNotFoundException is a subclass of IOException.

assertThrows(IOException.class, ...) succeeds because FileNotFoundException is a subclass of IOException, so either will match. JUnit 5 lacks built-in assertThrowsAnyOf.

🔧 Debug

advanced

Debug failing JUnit test with multiple exceptions

This JUnit 5 test is intended to pass if either ArithmeticException or NullPointerException is thrown. However, it always fails. Identify the cause.

JUnit

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertThrowsAnyOf;

public class DebugTest {
    @Test
    void testException() {
        assertThrowsAnyOf(ArithmeticException.class, NullPointerException.class, () -> {
            int x = 1 / 0;
        });
    }
}

A The test fails because the division by zero throws an unchecked exception.

B The test fails because ArithmeticException is not caught by assertThrowsAnyOf.

C The test fails because assertThrowsAnyOf is not a valid JUnit 5 method.

D The test fails because the lambda does not throw any exception.

💡 Hint

Check if assertThrowsAnyOf is part of standard JUnit 5 API.

JUnit 5 does not have an assertThrowsAnyOf method. This causes a compilation error, so the test cannot run and always fails.

🧠 Conceptual

advanced

Best practice for testing multiple exceptions in JUnit 5

Which approach is best to test that a method throws either SQLException or TimeoutException in JUnit 5?

A Use a custom helper method that catches exceptions and verifies if the thrown exception is one of the expected types.

B Use assertThrows with SQLException.class and then assertThrows with TimeoutException.class separately in the same test.

C Use assertThrowsAnyOf method from JUnit 5 standard library.

D Use try-catch blocks inside the test method and fail the test if the exception is not one of the expected types.

💡 Hint

JUnit 5 does not provide a built-in method for multiple expected exceptions.

JUnit 5 does not have assertThrowsAnyOf. The best practice is to write a custom helper that asserts the thrown exception is one of the expected types, making the test clear and maintainable.

❓ framework

expert

JUnit 5 extension for multiple exception assertions

You want to create a reusable JUnit 5 extension that allows asserting multiple possible exceptions from a test method. Which of the following correctly describes how to implement this?

A Use a try-catch block inside each test method to manually check for multiple exceptions.

B Override the default assertThrows method in JUnit 5 to accept multiple exception classes.

C Use JUnit 4's @Test(expected=...) annotation with multiple exception classes.

D Create a custom annotation with expected exception classes and implement a TestExecutionExceptionHandler to verify thrown exceptions against them.

💡 Hint

JUnit 5 extensions can intercept test execution and handle exceptions.

JUnit 5 allows creating extensions that can intercept exceptions thrown by tests. A custom annotation combined with TestExecutionExceptionHandler can check if the thrown exception matches any expected type, enabling reusable multiple exception assertions.