Checking exception type hierarchy in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to assert that the method throws an IOException.

JUnit

assertThrows([1].class, () -> methodThatThrows());

Drag options to blanks, or click blank then click option'

ARuntimeException

BError

CException

DIOException

Attempts:

3 left

💡 Hint

Common Mistakes

Using a superclass like Exception instead of the specific IOException.

Using an unrelated exception type like RuntimeException.

The method is expected to throw an IOException, so we assertThrows with IOException.class.

2fill in blank

medium

Complete the code to assert that the method throws a NullPointerException.

JUnit

assertThrows([1].class, () -> methodThatThrowsNull());

Drag options to blanks, or click blank then click option'

ANullPointerException

BIOException

CIllegalArgumentException

DIndexOutOfBoundsException

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing NullPointerException with IllegalArgumentException.

Using a superclass Exception instead of the specific exception.

The method throws a NullPointerException, so we assertThrows with NullPointerException.class.

3fill in blank

hard

Fix the error in the assertion to check for the correct exception type.

JUnit

assertThrows([1].class, () -> methodThatThrows());

Drag options to blanks, or click blank then click option'

AIOException

BException

CFileNotFoundException

DRuntimeException

Attempts:

3 left

💡 Hint

Common Mistakes

Using a superclass Exception which is too general.

Using a subclass FileNotFoundException which may not be thrown.

The method throws IOException, so the assertion must check for IOException.class, not a superclass or subclass.

4fill in blank

hard

Fill both blanks to assert that the method throws an IllegalArgumentException with the expected message.

JUnit

IllegalArgumentException thrown = assertThrows([1].class, () -> methodThatThrowsIllegal());
assertTrue(thrown.getMessage().[2]("Invalid argument"));

Drag options to blanks, or click blank then click option'

AIllegalArgumentException

Bcontains

CstartsWith

DendsWith

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong exception class like RuntimeException.

Using startsWith or endsWith which may fail if message format changes.

We assertThrows with IllegalArgumentException.class and check that the message contains "Invalid argument" using contains().

5fill in blank

hard

Fill all three blanks to assert that the method throws a custom exception and check its cause and message.

JUnit

CustomException ex = assertThrows([1].class, () -> methodThatThrowsCustom());
assertNotNull(ex.getCause());
assertEquals("[2]", ex.getCause().getClass().getSimpleName());
assertTrue(ex.getMessage().[3]("custom error"));

Drag options to blanks, or click blank then click option'

ACustomException

BIOException

Ccontains

DstartsWith

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong exception class in assertThrows.

Checking cause with incorrect class name.

Using startsWith instead of contains for message check.

We assertThrows with CustomException.class, check that the cause is an IOException, and verify the message contains "custom error".

Practice

1. In JUnit, when you want to check if a method throws an exception of a specific type or any of its subclasses, which assertion method should you use?

easy

A. assertThrows()

B. assertEquals()

C. assertTrue()

D. assertNull()

Solution

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

   assertThrows() is designed to check if a block of code throws an exception of a specified type or its subclass.

2. Step 2: Compare with other assertions

   assertEquals() checks equality, assertTrue() checks boolean conditions, and assertNull() checks for null values, none of which check exceptions.

3. Final Answer:

   assertThrows() -> Option A

4. Quick Check:

   Exception type check = assertThrows() [OK]

Hint: Use assertThrows() to check exceptions and their subclasses [OK]

Common Mistakes:

• Using assertEquals() to check exceptions
• Confusing assertTrue() with exception checks
• Expecting assertNull() to verify exceptions

2. Which of the following is the correct syntax to assert that a method throws a NullPointerException in JUnit 5?

easy

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

B. assertThrows(NullPointerException, method());

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

D. assertThrows(method(), NullPointerException);

Solution

1. Step 1: Recall assertThrows() method signature

   assertThrows() takes the exception class as the first argument and a lambda expression as the second.

2. Step 2: Match the syntax

   assertThrows(NullPointerException.class, () -> method()); correctly uses assertThrows(NullPointerException.class, () -> method()); which matches the required syntax.

3. Final Answer:

   assertThrows(NullPointerException.class, () -> method()); -> Option A

4. Quick Check:

   Correct syntax = assertThrows(NullPointerException.class, () -> method()); [OK]

Hint: Exception class first, then lambda expression in assertThrows() [OK]

Common Mistakes:

• Passing exception instance instead of class
• Swapping argument order in assertThrows()
• Not using lambda expression for the executable

3. Consider the following JUnit 5 test code:

assertThrows(RuntimeException.class, () -> { throw new IllegalArgumentException(); });

What will be the result of this test?

medium

A. Test fails with a compilation error

B. Test fails because IllegalArgumentException is not RuntimeException

C. Test passes because IllegalArgumentException is a subclass of RuntimeException

D. Test passes but warns about unchecked exception

Solution

1. Step 1: Check exception hierarchy

   IllegalArgumentException extends RuntimeException, so it is a subclass.

2. Step 2: Understand assertThrows behavior

   assertThrows(RuntimeException.class, ...) passes if the thrown exception is RuntimeException or any subclass.

3. Final Answer:

   Test passes because IllegalArgumentException is a subclass of RuntimeException -> Option C

4. Quick Check:

   Subclass exception passes assertThrows superclass check [OK]

Hint: assertThrows accepts subclass exceptions of the specified class [OK]

Common Mistakes:

• Thinking exact exception type is required
• Confusing subclass with unrelated exceptions
• Expecting compilation error for subclass exceptions

4. Given this JUnit 5 test:

assertThrows(RuntimeException.class, () -> { throw new FileNotFoundException(); });

The test fails. What is the most likely reason?

medium

A. The lambda expression does not throw any exception

B. The test method does not declare throws IOException

C. FileNotFoundException is a checked exception and must be declared

D. FileNotFoundException is not a subclass of RuntimeException

Solution

1. Step 1: Check exception hierarchy

   FileNotFoundException extends IOException, not RuntimeException.

2. Step 2: Understand assertThrows behavior

   assertThrows(RuntimeException.class, ...) fails because the thrown exception is not RuntimeException or any subclass. Other options are incorrect: checked exceptions like FileNotFoundException do not require declaration in the test method when using Executable lambdas.

3. Final Answer:

   FileNotFoundException is not a subclass of RuntimeException -> Option D

4. Quick Check:

   Non-subclass exception causes assertThrows to fail [OK]

Hint: assertThrows requires the thrown exception to be the specified class or subclass [OK]

Common Mistakes:

• Misidentifying exception subclass relationships
• Ignoring checked exception declaration rules
• Expecting runtime exceptions to behave like checked

5. You want to write a JUnit 5 test that passes if a method throws either an IOException or any of its subclasses, but fails for other exceptions. Which of the following is the best approach?

hard

A. Use assertThrows(Exception.class, () -> method()); and check instance with instanceof IOException

B. Use assertThrows(IOException.class, () -> method());

C. Use try-catch inside test and assert exception type manually

D. Use assertThrows(Throwable.class, () -> method());

Solution

1. Step 1: Understand assertThrows behavior with superclass

   assertThrows(IOException.class, ...) passes if the thrown exception is IOException or any subclass.

2. Step 2: Evaluate other options

   Use assertThrows(Exception.class, () -> method()); and check instance with instanceof IOException requires manual checks and complicates test; Use try-catch inside test and assert exception type manually is verbose; Use assertThrows(Throwable.class, () -> method()); is too broad and accepts all throwables.

3. Final Answer:

   Use assertThrows(IOException.class, () -> method()); -> Option B

4. Quick Check:

   Superclass in assertThrows covers subclasses [OK]

Hint: Use superclass exception in assertThrows to cover subclasses [OK]

Common Mistakes:

• Using too broad exception classes
• Manually checking exception types unnecessarily
• Ignoring assertThrows built-in subclass support