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.

Practice

1.

Which JUnit method is best to test that a specific exception is thrown by a method?

easy

A. assertThrows()

B. assertEquals()

C. assertTrue()

D. assertNull()

Solution

1. Step 1: Understand the purpose of assertThrows()

   This method checks if a specific exception is thrown when running a code block.

2. Step 2: Compare with other assertion methods

   assertEquals() checks values, assertTrue() checks boolean conditions, and assertNull() checks for null values, none test exceptions.

3. Final Answer:

   assertThrows() -> Option A

4. Quick Check:

   Test exceptions with assertThrows() [OK]

Hint: Use assertThrows() to check exceptions directly [OK]

Common Mistakes:

• Using assertEquals() to test exceptions
• Trying to catch exceptions manually in tests
• Confusing assertTrue() with exception testing

2.

Which of the following is the correct syntax to test that IllegalArgumentException is thrown by myMethod() in JUnit 5?

?

easy

A. assertThrows(myMethod(), IllegalArgumentException.class);

B. assertThrows(() -> myMethod(), IllegalArgumentException.class);

C. assertThrows(IllegalArgumentException.class, () -> myMethod());

D. assertThrows(IllegalArgumentException, myMethod());

Solution

1. Step 1: Recall assertThrows() method signature

   The correct order is the exception class first, then a lambda with the code to test.

2. Step 2: Check each option's syntax

   assertThrows(IllegalArgumentException.class, () -> myMethod()); matches the correct syntax: assertThrows(Exception.class, () -> method());. Others have wrong order or missing lambda.

3. Final Answer:

   assertThrows(IllegalArgumentException.class, () -> myMethod()); -> Option C

4. Quick Check:

   Exception class first, then lambda [OK]

Hint: Exception class first, then lambda expression [OK]

Common Mistakes:

• Swapping parameters order in assertThrows
• Not using a lambda expression
• Passing method call instead of lambda

3.

Given the following JUnit 5 test code, what will be the test result?

void testMultipleExceptions() {
  assertThrows(NullPointerException.class, () -> { throw new NullPointerException(); });
  assertThrows(IllegalStateException.class, () -> { throw new IllegalArgumentException(); });
}

medium

A. Test fails because second assertThrows expects IllegalStateException but gets IllegalArgumentException

B. Test passes because both exceptions are thrown

C. Test fails because NullPointerException is not thrown

D. Test passes because assertThrows ignores exception type

Solution

1. Step 1: Analyze first assertThrows

   It expects NullPointerException and throws NullPointerException, so it passes.

2. Step 2: Analyze second assertThrows

   It expects IllegalStateException but throws IllegalArgumentException, so it fails.

3. Final Answer:

   Test fails because second assertThrows expects IllegalStateException but gets IllegalArgumentException -> Option A

4. Quick Check:

   Expected exception must match thrown exception [OK]

Hint: Exception types must match exactly in assertThrows [OK]

Common Mistakes:

• Assuming any exception passes assertThrows
• Ignoring mismatch in exception types
• Thinking assertThrows catches all exceptions

4.

Identify the error in the following JUnit 5 test code that tries to test two exceptions:

@Test
void testExceptions() {
  assertThrows(NullPointerException.class, () -> method1());
  assertThrows(IllegalArgumentException.class, () -> method2());
  assertThrows(IllegalStateException.class, () -> method3());
}

Assuming method2() throws IllegalStateException instead of IllegalArgumentException.

medium

A. The test will pass because all exceptions are thrown

B. The second assertThrows will fail because expected and actual exceptions differ

C. The test will fail because assertThrows cannot be called multiple times

D. The test will fail because method3() is not called

Solution

1. Step 1: Check expected vs actual exceptions for method2()

   Expected is IllegalArgumentException but actual thrown is IllegalStateException, so assertThrows fails.

2. Step 2: Confirm other assertThrows calls

   Calls for method1() and method3() are correct or irrelevant to this error.

3. Final Answer:

   The second assertThrows will fail because expected and actual exceptions differ -> Option B

4. Quick Check:

   Expected exception must match thrown exception [OK]

Hint: Check expected vs actual exception types carefully [OK]

Common Mistakes:

• Assuming multiple assertThrows calls cause failure
• Ignoring mismatch in exception types
• Thinking assertThrows tests method calls, not exceptions

5.

You want to test that a method process() throws either IOException or TimeoutException depending on conditions. Which is the best way to write JUnit 5 tests for both exceptions?

hard

A. Use one assertThrows with both exceptions listed together

B. Use assertThrows only for the first exception and ignore the second

C. Catch exceptions manually inside one test and assert their types

D. Write two separate tests each using assertThrows for one exception

Solution

1. Step 1: Understand assertThrows usage

   assertThrows tests one exception type per call; it cannot test multiple exceptions at once.

2. Step 2: Best practice for multiple exceptions

   Write separate tests for each expected exception to keep tests clear and focused.

3. Final Answer:

   Write two separate tests each using assertThrows for one exception -> Option D

4. Quick Check:

   One assertThrows per exception per test [OK]

Hint: Test each exception in its own assertThrows call [OK]

Common Mistakes:

• Trying to test multiple exceptions in one assertThrows
• Catching exceptions manually instead of using assertThrows
• Ignoring one exception in tests