Why exception testing validates error handling in JUnit - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the method throws the expected exception.

JUnit

assertThrows([1].class, () -> calculator.divide(10, 0));

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

AIllegalArgumentException

BNullPointerException

CIOException

DArithmeticException

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong exception type like NullPointerException.

Not using the exception class with .class suffix.

The ArithmeticException is expected when dividing by zero.

2fill in blank

medium

Complete the code to verify the exception message contains the expected text.

JUnit

Exception exception = assertThrows(IllegalArgumentException.class, () -> parser.parse(null));
assertTrue(exception.getMessage().[1]("input cannot be null"));

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

Aequals

Bcontains

CstartsWith

DendsWith

Attempts:

3 left

💡 Hint

Common Mistakes

Using equals which requires exact match.

Using startsWith or endsWith which only check the start or end.

We use contains to check if the exception message includes the expected text.

3fill in blank

hard

Fix the error in the test code to properly catch the exception.

JUnit

try {
    service.process(null);
    fail("Expected [1] to be thrown");
} catch (NullPointerException e) {
    // test passes
}

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

ANullPointerException

BIllegalStateException

CIOException

DRuntimeException

Attempts:

3 left

💡 Hint

Common Mistakes

Mismatching exception type in fail message and catch block.

Using a generic exception type that is not thrown.

The test expects a NullPointerException when passing null to process.

4fill in blank

hard

Fill both blanks to assert that the method throws the correct exception with the expected message.

JUnit

IllegalArgumentException thrown = assertThrows([1].class, () -> validator.validate(""));
assertEquals("[2]", thrown.getMessage());

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

AIllegalArgumentException

BNullPointerException

CInput cannot be empty

DValue is null

Attempts:

3 left

💡 Hint

Common Mistakes

Using NullPointerException instead of IllegalArgumentException.

Using wrong exception message text.

The method throws IllegalArgumentException with message "Input cannot be empty" when input is empty.

5fill in blank

hard

Fill all three blanks to test that the method throws the expected exception type, and the message contains the correct text.

JUnit

Exception exception = assertThrows([1].class, () -> fileReader.readFile(null));
String expectedMessage = "[2]";
assertTrue(exception.getMessage().[3](expectedMessage));

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

AIllegalArgumentException

BFile path must not be null

Ccontains

DIOException

Attempts:

3 left

💡 Hint

Common Mistakes

Using IOException instead of IllegalArgumentException.

Checking message with equals instead of contains.

The test expects IllegalArgumentException with a message containing "File path must not be null".

Practice

1. Why is exception testing important in JUnit for validating error handling?

easy

A. It ensures the code correctly throws expected exceptions when errors occur.

B. It improves the speed of test execution by skipping error cases.

C. It automatically fixes bugs related to exceptions.

D. It prevents exceptions from being thrown during normal execution.

Solution

1. Step 1: Understand the purpose of exception testing

   Exception testing checks if the program throws the right error when something goes wrong.

2. Step 2: Connect exception testing to error handling validation

   By expecting specific exceptions, tests confirm the code handles errors as designed.

3. Final Answer:

   It ensures the code correctly throws expected exceptions when errors occur. -> Option A

4. Quick Check:

   Exception testing = Validates error handling [OK]

Hint: Exception tests confirm errors happen as expected [OK]

Common Mistakes:

• Thinking exception tests fix bugs automatically
• Believing exception tests speed up all tests
• Assuming exception tests stop exceptions from occurring

2. Which JUnit 5 syntax correctly tests that a method throws a NullPointerException?

easy

A. @Test
void test() {
assertThrows(NullPointerException, method());
}

B. @Test
void test() {
assertThrows(NullPointerException.class, () -> method());
}

C. @Test
void test() {
assertThrows(() -> method(), NullPointerException.class);
}

D. @Test
void test() {
assertThrows(method(), NullPointerException.class);
}

Solution

1. Step 1: Recall correct assertThrows syntax in JUnit 5

   The method is: assertThrows(ExceptionClass.class, Executable lambda).

2. Step 2: Match syntax to options

   @Test void test() { assertThrows(NullPointerException.class, () -> method()); } uses assertThrows with exception class first, then lambda, which is correct.

3. Final Answer:

   @Test void test() { assertThrows(NullPointerException.class, () -> method()); } -> Option B

4. Quick Check:

   assertThrows(Exception.class, () -> code) [OK]

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

Common Mistakes:

• Swapping argument order in assertThrows
• Passing method call instead of lambda
• Omitting .class for exception type

3. Given this JUnit 5 test code:

@Test
void testDivide() {
  assertThrows(ArithmeticException.class, () -> divide(10, 0));
}

int divide(int a, int b) {
  return a / b;
}

What will be the test result?

medium

A. Test fails due to syntax error in assertThrows usage.

B. Test fails because divide method returns 0 instead of throwing exception.

C. Test passes because dividing by zero throws ArithmeticException.

D. Test passes but throws NullPointerException instead.

Solution

1. Step 1: Analyze divide method behavior

   Dividing by zero in Java throws ArithmeticException automatically.

2. Step 2: Check assertThrows expectation

   The test expects ArithmeticException when dividing 10 by 0, matching actual behavior.

3. Final Answer:

   Test passes because dividing by zero throws ArithmeticException. -> Option C

4. Quick Check:

   Divide by zero throws ArithmeticException [OK]

Hint: Divide by zero throws ArithmeticException [OK]

Common Mistakes:

• Assuming divide returns 0 on zero divisor
• Confusing exception types
• Thinking assertThrows syntax is wrong here

4. Identify the error in this JUnit 5 test that tries to check for IllegalArgumentException:

@Test
void test() {
  assertThrows(IllegalArgumentException.class, method());
}

void method() {
  throw new IllegalArgumentException();
}

medium

A. assertThrows requires a string message as the first argument.

B. IllegalArgumentException is not a checked exception, so assertThrows is invalid.

C. The test method must declare throws IllegalArgumentException.

D. The method call should be inside a lambda, not called directly.

Solution

1. Step 1: Understand assertThrows parameter requirements

   assertThrows expects a lambda or Executable, not a direct method call.

2. Step 2: Identify the mistake in test code

   Calling method() directly runs it immediately, causing exception before assertThrows can catch it.

3. Final Answer:

   The method call should be inside a lambda, not called directly. -> Option D

4. Quick Check:

   Use lambda () -> method() in assertThrows [OK]

Hint: Wrap method call in lambda for assertThrows [OK]

Common Mistakes:

• Calling method directly inside assertThrows
• Thinking checked exceptions are required
• Adding unnecessary message argument

5. You want to test a method that throws IOException only when a file is missing. Which approach best validates this error handling using JUnit 5 exception testing?

hard

A. Use assertThrows(IOException.class, () -> method("missing.txt")) and verify exception message contains "not found".

B. Use assertThrows(Exception.class, () -> method("missing.txt")) without checking message.

C. Call method("missing.txt") directly and catch IOException in test method.

D. Use try-catch inside method to suppress IOException and assert no exception thrown.

Solution

1. Step 1: Choose specific exception type for assertThrows

   Testing for IOException ensures only that error triggers the test.

2. Step 2: Verify exception message for correctness

   Checking the message confirms the exception is due to missing file, not other IO errors.

3. Final Answer:

   Use assertThrows(IOException.class, () -> method("missing.txt")) and verify exception message contains "not found". -> Option A

4. Quick Check:

   Specific exception + message check = best validation [OK]

Hint: Test specific exception and check message for accuracy [OK]

Common Mistakes:

• Using generic Exception instead of IOException
• Not verifying exception message
• Suppressing exceptions inside method