Checking exception type hierarchy in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

JUnit Exception Hierarchy: Which exception is caught?

Consider the following JUnit test method. Which exception type will be caught and asserted in this test?

JUnit

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

class ExceptionTest {
    @Test
    void testExceptionHierarchy() {
        Exception thrown = assertThrows(Exception.class, () -> {
            throw new IllegalArgumentException("Invalid argument");
        });
        assertEquals(IllegalArgumentException.class, thrown.getClass());
    }
}

A The test will pass because IllegalArgumentException is a subclass of Exception and is caught.

B The test will fail because Exception.class does not catch IllegalArgumentException.

C The test will fail because assertThrows only catches RuntimeException and its subclasses.

D The test will pass but the caught exception type will be Exception, not IllegalArgumentException.

💡 Hint

Remember that IllegalArgumentException extends RuntimeException, which extends Exception.

In JUnit, assertThrows catches exceptions of the specified class or any subclass. Since IllegalArgumentException extends Exception, it is caught and the test passes. The actual exception type is IllegalArgumentException, so the assertion on getClass() succeeds.

❓ assertion

intermediate

Correct Assertion for Exception Subclass in JUnit

You want to assert that a method throws a NullPointerException using JUnit 5. Which assertion correctly verifies the exception type?

A assertThrows(RuntimeException.class, () -> method());

B assertThrows(Throwable.class, () -> method());

C assertThrows(NullPointerException.class, () -> method());

D assertThrows(Exception.class, () -> method());

💡 Hint

Use the most specific exception type to verify the exact exception thrown.

assertThrows expects the exact exception class or subclass you want to verify. Using NullPointerException.class ensures the test only passes if that specific exception is thrown.

🔧 Debug

advanced

Why does this JUnit test fail to catch the exception?

Examine the following JUnit test. Why does it fail even though the method throws an IOException?

JUnit

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

class FileTest {
    @Test
    void testIOException() {
        assertThrows(FileNotFoundException.class, () -> {
            throw new IOException("File error");
        });
    }
}

A The test fails because FileNotFoundException is a subclass of IOException, so it should catch IOException.

B The test fails because assertThrows cannot catch checked exceptions.

C The test passes because IOException is a checked exception.

D The test fails because IOException is not a subclass of FileNotFoundException.

💡 Hint

Check the inheritance relationship between IOException and FileNotFoundException.

FileNotFoundException extends IOException, so it is a subclass. But IOException is a superclass and not caught when expecting FileNotFoundException specifically. The thrown exception must be the same or subclass of the asserted exception.

🧠 Conceptual

advanced

Understanding Exception Type Matching in JUnit assertThrows

In JUnit 5, when using assertThrows(ExpectedException.class, executable), which of the following statements is true about the exception matching?

A assertThrows matches exceptions of ExpectedException or any subclass of it.

B assertThrows matches any exception that implements the Throwable interface.

C assertThrows only matches exceptions of the exact class ExpectedException, not subclasses.

D assertThrows matches exceptions only if they are checked exceptions.

💡 Hint

Think about inheritance and polymorphism in Java exceptions.

assertThrows matches exceptions that are instances of the specified class or any subclass. This allows catching more specific exceptions when expecting a general exception type.

❓ framework

expert

JUnit 5 Exception Assertion with Multiple Exception Types

You want to write a JUnit 5 test that passes if either IllegalArgumentException or NullPointerException is thrown by a method. Which approach correctly achieves this?

A Use assertThrowsAnyOf(IllegalArgumentException.class, NullPointerException.class, () -> method()) from JUnit 5.9+.

B Use assertThrows(Throwable.class, () -> method()) and then assert the exception is either IllegalArgumentException or NullPointerException.

C Use assertThrows(IllegalArgumentException.class, () -> method()) and catch NullPointerException separately.

D Use assertThrows(Exception.class, () -> method()) and check the exception type inside the test.

💡 Hint

Check if JUnit 5 has a built-in method to assert multiple exception types.

JUnit 5 does not have assertThrowsAnyOf, but using assertThrows(Throwable.class, ...) to capture the exception and then asserting it is an instance of either expected type (e.g., via instanceof checks or getClass()) is the standard and correct approach.