assertThrows usage in JUnit - Test Execution Trace

Test Overview

This test checks that a method throws the expected exception when given invalid input. It verifies that assertThrows correctly catches the exception type.

Test Code - JUnit

JUnit

import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;

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

public class CalculatorTest {
    @Test
    void testDivideByZeroThrows() {
        Calculator calc = new Calculator();
        assertThrows(ArithmeticException.class, () -> calc.divide(10, 0));
    }
}

Execution Trace - 5 Steps

Step	Action	System State	Assertion	Result
1	Test starts	JUnit test runner initialized	—	PASS
2	CalculatorTest.testDivideByZeroThrows method invoked	Calculator instance created	—	PASS
3	assertThrows called with ArithmeticException.class and lambda dividing 10 by 0	Lambda executed, division by zero attempted	Check if ArithmeticException is thrown	PASS
4	ArithmeticException thrown by divide method	Exception caught by assertThrows	Exception type matches expected ArithmeticException	PASS
5	Test completes successfully	Test runner reports test passed	assertThrows assertion passed	PASS

Failure Scenario

Failing Condition: divide method does not throw ArithmeticException when dividing by zero

Execution Trace Quiz - 3 Questions

What does assertThrows verify in this test?

A That the divide method throws ArithmeticException when dividing by zero

B That the divide method returns zero when dividing by zero

C That no exception is thrown during division

D That the divide method throws NullPointerException

Key Result

Use assertThrows to clearly and safely verify that a specific exception is thrown by a code block, improving test clarity and correctness.

Practice

1. What is the primary purpose of assertThrows in JUnit testing?

easy

A. To check if a specific exception is thrown by a code block

B. To verify the return value of a method

C. To measure the execution time of a method

D. To assert that no exceptions are thrown

Solution

1. Step 1: Understand the role of assertThrows

   assertThrows is used to test if a particular exception occurs when running a piece of code.

2. Step 2: Compare with other assertions

   Other assertions check values or states, but assertThrows specifically checks for exceptions.

3. Final Answer:

   To check if a specific exception is thrown by a code block -> Option A

4. Quick Check:

   assertThrows = Exception check [OK]

Hint: assertThrows checks exceptions thrown by code [OK]

Common Mistakes:

• Confusing assertThrows with assertEquals
• Using assertThrows to check return values
• Expecting assertThrows to measure performance

2. Which of the following is the correct syntax to use assertThrows in JUnit 5?

easy

A. assertThrows(Exception.class, () -> methodCall());

B. assertThrows(() -> methodCall(), Exception.class);

C. assertThrows(methodCall(), Exception.class);

D. assertThrows(Exception.class, methodCall());

Solution

1. Step 1: Recall assertThrows method signature

   The correct syntax is assertThrows(Exception.class, Executable) where Executable is a lambda or method reference.

2. Step 2: Analyze options

   assertThrows(Exception.class, () -> methodCall()); matches the correct syntax: exception class first, then lambda expression.

3. Final Answer:

   assertThrows(Exception.class, () -> methodCall()); -> Option A

4. Quick Check:

   assertThrows(Exception.class, lambda) = correct syntax [OK]

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

Common Mistakes:

• Swapping parameters order
• Passing method call instead of lambda
• Omitting lambda expression

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

assertThrows(IllegalArgumentException.class, () -> {
  throw new IllegalArgumentException("Invalid argument");
});

medium

A. Test passes but ignores the exception message

B. Test fails because no exception is thrown

C. Test fails due to a syntax error

D. Test passes because the expected exception is thrown

Solution

1. Step 1: Check the exception thrown

   The lambda throws IllegalArgumentException, which matches the expected exception class.

2. Step 2: Understand assertThrows behavior

   assertThrows passes if the expected exception is thrown during execution.

3. Final Answer:

   Test passes because the expected exception is thrown -> Option D

4. Quick Check:

   Thrown exception matches expected = pass [OK]

Hint: assertThrows passes if expected exception is thrown [OK]

Common Mistakes:

• Thinking test fails if exception is thrown
• Confusing exception message with test result
• Assuming syntax error without checking code

4. Identify the error in this JUnit 5 test snippet:

assertThrows(NullPointerException.class, () -> {
  String s = null;
  s.length();
});

medium

A. Exception class should be RuntimeException.class

B. Lambda syntax is incorrect

C. No error; test will pass as NullPointerException is thrown

D. s.length() does not throw NullPointerException

Solution

1. Step 1: Analyze the code inside lambda

   Calling s.length() on a null string throws NullPointerException.

2. Step 2: Check assertThrows parameters

   Expected exception is NullPointerException.class, matching the thrown exception.

3. Final Answer:

   No error; test will pass as NullPointerException is thrown -> Option C

4. Quick Check:

   NullPointerException thrown and expected = pass [OK]

Hint: NullPointerException thrown matches expected exception [OK]

Common Mistakes:

• Assuming s.length() throws different exception
• Thinking lambda syntax is wrong
• Confusing exception class with superclass

5. Consider this test method:

void testDivideByZero() {
  ArithmeticException thrown = assertThrows(ArithmeticException.class, () -> {
    int result = 10 / 0;
  });
  assertEquals("/ by zero", thrown.getMessage());
}

What does this test verify beyond just exception throwing?

hard

A. It verifies the method returns zero

B. It verifies the exception message is exactly "/ by zero"

C. It verifies no exception is thrown

D. It verifies the exception type is RuntimeException

Solution

1. Step 1: Understand assertThrows return value

   assertThrows returns the thrown exception object, here stored in thrown.

2. Step 2: Analyze the assertEquals check

   The test checks that the exception message equals "/ by zero", verifying the exact error message.

3. Final Answer:

   It verifies the exception message is exactly "/ by zero" -> Option B

4. Quick Check:

   Exception message checked = It verifies the exception message is exactly "/ by zero" [OK]

Hint: assertThrows returns exception to check message [OK]

Common Mistakes:

• Thinking it checks return value of division
• Assuming exception type is RuntimeException
• Ignoring the message assertion