Testing multiple exceptions in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to test that the method throws NullPointerException.

JUnit

assertThrows([1].class, () -> myObject.myMethod(null));

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

ANullPointerException

BIllegalArgumentException

CIOException

DRuntimeException

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong exception class like IllegalArgumentException.

Not specifying the exception class at all.

The assertThrows method expects the exception class that should be thrown. Here, NullPointerException.class is correct to test for a null argument.

2fill in blank

medium

Complete the code to test that the method throws either IOException or SQLException.

JUnit

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

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

AException

BIOException

CSQLException

DRuntimeException

Attempts:

3 left

💡 Hint

Common Mistakes

Testing only one exception when multiple can be thrown.

Using RuntimeException which does not cover checked exceptions.

Using Exception.class covers multiple checked exceptions like IOException and SQLException in one test.

3fill in blank

hard

Fix the error in the test that expects multiple exceptions using assertThrows.

JUnit

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

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

AIOException | SQLException

BException

CSQLException

DIOException

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to use 'IOException | SQLException.class' which is invalid syntax.

Using only one exception class when multiple exceptions can be thrown.

You cannot use the '|' operator inside assertThrows. Instead, use the common superclass Exception.class to catch multiple exceptions.

4fill in blank

hard

Fill both blanks to correctly test that either IllegalArgumentException or NullPointerException is thrown.

JUnit

Throwable thrown = assertThrows([1].class, () -> myObject.myMethod([2]));

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

ARuntimeException

Bnull

C"invalid"

DException

Attempts:

3 left

💡 Hint

Common Mistakes

Using Exception.class which is too broad.

Passing a string instead of null to trigger the exception.

Both IllegalArgumentException and NullPointerException extend RuntimeException, so using RuntimeException.class works. Passing null triggers NullPointerException.

5fill in blank

hard

Fill all three blanks to test multiple exceptions and check the exception message.

JUnit

Exception exception = assertThrows([1].class, () -> myObject.myMethod([2]));
assertTrue(exception.getMessage().[3]("error"));

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

AException

Bnull

Ccontains

DstartsWith

Attempts:

3 left

💡 Hint

Common Mistakes

Using startsWith() which is more restrictive.

Passing a non-null argument that does not cause exception.

Using Exception.class covers multiple exceptions. Passing null triggers an exception. Checking if the message contains the word "error" verifies the error details.

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