Checking exception message in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of checking an exception message in a test?

To verify that the code throws the correct error with the expected message, ensuring the error is meaningful and specific.

beginner

How do you check an exception message using JUnit 5's assertThrows?

Use assertThrows to catch the exception, then assert the message with getMessage(), for example:

Exception exception = assertThrows(Exception.class, () -> method());
assertEquals("Expected message", exception.getMessage());

intermediate

Why is it better to check the exception message instead of only the exception type?

Because the message gives more detail about the error cause, helping to confirm the exact failure reason, not just the error category.

beginner

What happens if the exception message does not match the expected message in a test?

The assertion fails, and the test reports a failure showing the expected and actual messages, helping to identify the mismatch.

beginner

Show a simple JUnit 5 test snippet that checks for IllegalArgumentException with message "Invalid input".

@Test
void testInvalidInput() {
  IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> {
    methodThatThrows();
  });
  assertEquals("Invalid input", ex.getMessage());
}

Which JUnit method is used to check that a specific exception is thrown?

A assertThrows

B assertEquals

C assertTrue

D assertNull

assertThrows is designed to check that a block of code throws a specific exception.

How do you access the message of an exception in JUnit tests?

A exception.toString()

B exception.message()

C exception.getMessage()

D exception.getError()

The getMessage() method returns the detail message string of the exception.

Why should you check the exception message in addition to the exception type?

A To make tests run faster

B To confirm the exact error reason

C To avoid catching exceptions

D To ignore error details

Checking the message confirms the specific cause of the error, not just its type.

What happens if the exception message does not match the expected message in a test?

A The test fails

B The test passes

C The exception is ignored

D The test is skipped

A mismatch in messages causes the assertion to fail, marking the test as failed.

Which of these is a correct way to check exception message in JUnit 5?

A assertTrue(method().throwsException());

B assertThrows(Exception.class, () -> method(), "msg");

C assertEquals("msg", method().getMessage());

D Exception e = assertThrows(Exception.class, () -> method()); assertEquals("msg", e.getMessage());

You capture the exception with assertThrows, then check its message with getMessage().

Explain how to write a JUnit test that verifies both the type and message of an exception.

Think about how to capture and check exception details step by step.

Why is checking the exception message important in software testing?

Consider what information the message provides beyond the exception type.

Practice

1. In JUnit 5, which method is used to check that a specific exception is thrown with a particular message?

easy

A. assertThrows with a lambda and then assert on the exception message

B. assertEquals with the exception class

C. assertTrue with exception message string

D. assertNull with exception object

Solution

1. Step 1: Understand how to catch exceptions in JUnit 5

   JUnit 5 uses assertThrows to check if a block of code throws an exception.

2. Step 2: Check the exception message

   After assertThrows returns the exception, you can assert its message with assertEquals or other assertions.

3. Final Answer:

   assertThrows with a lambda and then assert on the exception message -> Option A

4. Quick Check:

   assertThrows + message check = A [OK]

Hint: Use assertThrows and then check message from returned exception [OK]

Common Mistakes:

• Trying to check exception message inside assertEquals directly
• Using assertTrue with exception message string only
• Expecting assertNull to check exceptions

2. Which of the following is the correct syntax to assert that a method throws IllegalArgumentException with message "Invalid input" in JUnit 5?

easy

A. assertThrows(IllegalArgumentException.class, () -> method(), "Invalid input");

B. assertEquals("Invalid input", assertThrows(IllegalArgumentException.class, () -> method()).getMessage());

C. assertThrows(() -> method(), IllegalArgumentException.class).getMessage().equals("Invalid input");

D. assertThrows(IllegalArgumentException.class, () -> method()).getMessage() == "Invalid input";

Solution

1. Step 1: Use assertThrows with exception class and lambda

   The correct order is assertThrows(ExceptionClass.class, executable lambda).

2. Step 2: Get the exception message and compare with equals()

   Use getMessage() and equals() to compare strings, not ==.

3. Final Answer:

   assertEquals("Invalid input", assertThrows(IllegalArgumentException.class, () -> method()).getMessage()); -> Option B

4. Quick Check:

   assertThrows + getMessage + equals = B [OK]

Hint: Use assertEquals("msg", assertThrows(class, lambda).getMessage()) [OK]

Common Mistakes:

• Passing message as third argument to assertThrows
• Swapping lambda and exception class order
• Using == to compare strings instead of equals()

3. What will be the result of this JUnit 5 test code?

Exception exception = assertThrows(NullPointerException.class, () -> { throw new NullPointerException("Null value found"); });
assertEquals("Null value found", exception.getMessage());

medium

A. Test fails because exception type does not match

B. Test fails because exception message does not match

C. Test passes because exception type and message match

D. Test throws compilation error

Solution

1. Step 1: Check exception type thrown matches assertThrows

   The lambda throws NullPointerException, which matches the expected type.

2. Step 2: Check the exception message matches the assertEquals

   The message "Null value found" matches exactly, so assertion passes.

3. Final Answer:

   Test passes because exception type and message match -> Option C

4. Quick Check:

   Exception type and message match = Pass [OK]

Hint: Exception type and message must both match for assertEquals pass [OK]

Common Mistakes:

• Assuming assertThrows only checks type, not message
• Confusing assertEquals order of arguments
• Thinking test fails if exception is thrown

4. Identify the error in this JUnit 5 test code that checks exception message:

assertThrows(IllegalStateException.class, () -> { throw new IllegalStateException("Error occurred"); }, "Error occurred");

medium

A. Exception message should be checked with assertTrue, not assertThrows

B. Exception type IllegalStateException is incorrect

C. Lambda syntax is invalid

D. assertThrows does not accept a message as third argument for checking exception message

Solution

1. Step 1: Review assertThrows method signature

   assertThrows expects (Class, Executable) or (Class, Executable, String) where String is failure message, not exception message.

2. Step 2: Understand how to check exception message

   Exception message must be checked separately after assertThrows returns the exception.

3. Final Answer:

   assertThrows does not accept a message as third argument for checking exception message -> Option D

4. Quick Check:

   Third argument in assertThrows is failure message, not exception message [OK]

Hint: Third argument in assertThrows is test failure message, not exception message [OK]

Common Mistakes:

• Passing expected exception message as third argument to assertThrows
• Confusing failure message with exception message
• Not capturing exception to check message separately

5. You want to test a method that throws different exceptions with different messages based on input. Which JUnit 5 approach correctly checks both exception type and message for input "bad" that throws IllegalArgumentException with message "Bad input"?

hard

A. var ex = assertThrows(IllegalArgumentException.class, () -> method("bad")); assertEquals("Bad input", ex.getMessage());

B. assertThrows(IllegalArgumentException.class, () -> method("bad"), "Bad input");

C. assertTrue(() -> method("bad").getMessage().equals("Bad input"));

D. try { method("bad"); fail(); } catch (Exception e) { assertEquals("Bad input", e.getMessage()); }

Solution

1. Step 1: Use assertThrows to capture the exception for input "bad"

   assertThrows returns the exception object for further checks.

2. Step 2: Assert the exception message matches expected "Bad input"

   Use assertEquals on ex.getMessage() to verify the message.

3. Final Answer:

   var ex = assertThrows(IllegalArgumentException.class, () -> method("bad")); assertEquals("Bad input", ex.getMessage()); -> Option A

4. Quick Check:

   Capture exception then check message separately = D [OK]

Hint: Capture exception with assertThrows, then assert message separately [OK]

Common Mistakes:

• Passing message as third argument to assertThrows
• Using assertTrue incorrectly with lambda
• Not failing test if exception not thrown