Checking exception message in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ assertion

intermediate

Check exception message with JUnit 5

Which JUnit 5 assertion correctly verifies that a method throws an IllegalArgumentException with the message "Invalid input"?

JUnit

public void testInvalidInput() {
    // methodUnderTest throws IllegalArgumentException with message "Invalid input" when input is negative
}

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

B

IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> methodUnderTest(-1));
assertEquals("Invalid input", thrown.getMessage());

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

D assertThatThrownBy(() -> methodUnderTest(-1)).hasMessage("Invalid input");

💡 Hint

Use assertThrows to capture the exception, then check its message separately.

Option B correctly uses assertThrows to capture the exception object, then asserts the message with assertEquals. Option B incorrectly passes the message as a third argument to assertThrows, which is for failure message, not exception message. Option B uses AssertJ syntax, not JUnit 5 core. Option B calls getMessage() but does not assert the result, so it does not fail the test if message is wrong.

❓ Predict Output

intermediate

Output of JUnit test with exception message assertion

What is the result of running this JUnit 5 test method if methodUnderTest throws IllegalArgumentException with message "Wrong value" instead of "Invalid input"?

JUnit

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

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

void methodUnderTest(int x) {
    if (x < 0) throw new IllegalArgumentException("Wrong value");
}

A Test fails with IllegalArgumentException but no assertion error

B Test passes successfully

C Test fails with NullPointerException

D Test fails with AssertionError: expected 'Invalid input' but was 'Wrong value'

💡 Hint

Check the difference between expected and actual exception messages.

The test captures the exception correctly but asserts the wrong message. The actual message is 'Wrong value' but the test expects 'Invalid input', so assertEquals fails with an AssertionError showing the mismatch.

🔧 Debug

advanced

Identify the error in exception message assertion

What is wrong with this JUnit 5 test code that tries to check the exception message?

JUnit

assertThrows(IllegalArgumentException.class, () -> methodUnderTest(-1), msg -> assertEquals("Invalid input", msg));

A assertThrows does not accept a third argument; this causes a runtime error.

B The lambda parameter 'msg' is a String, but assertThrows expects a Consumer<Throwable>.

C The third argument is a failure message string, not a lambda; this causes a compilation error.

D The lambda should return a boolean, but assertEquals returns void, causing a type mismatch.

💡 Hint

Check the method signature of assertThrows in JUnit 5.

The third argument to assertThrows is an optional failure message string, not a lambda function. Passing a lambda causes a compilation error because no matching method signature exists.

❓ framework

advanced

Best practice for checking exception messages in JUnit 5

Which approach is considered best practice for verifying exception messages in JUnit 5 tests?

A Use assertThrows to capture the exception, then assert the message with assertEquals separately.

B Use @Test(expected=Exception.class) annotation and check message in a separate test.

C Use assertThrows with a third argument as a lambda to check the message inline.

D Use try-catch block and fail() method to check exception message manually.

💡 Hint

Consider readability and clarity of test code.

Option A is best practice because it uses assertThrows to capture the exception object clearly and then asserts the message explicitly. Option A is verbose and less clear. Option A is invalid syntax. Option A is deprecated in JUnit 5 and does not allow message checking.

🧠 Conceptual

expert

Why check exception messages in tests?

Why is it important to verify the exception message in addition to the exception type in automated tests?

A Because exception messages provide detailed context that distinguishes different error causes of the same exception type.

B Because checking messages improves test execution speed significantly.

C Because exception messages are required by the compiler to identify exceptions.

D Because exception messages are always unique and guarantee no false positives.

💡 Hint

Think about why the same exception type might be thrown for different reasons.

Exception types can be generic and used in multiple places. Checking the message ensures the test verifies the exact error scenario, avoiding false positives when the same exception type is thrown for different reasons.