assertThrows usage in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of assertThrows in JUnit?

assertThrows checks if a specific exception is thrown by a block of code during a test. It helps verify error handling.

beginner

How do you write a basic assertThrows statement in JUnit 5?

Use assertThrows(ExceptionClass.class, () -> { /* code that throws */ }); to test if the exception occurs.

intermediate

What does assertThrows return and how can it be used?

It returns the thrown exception object, allowing you to check its message or properties for more detailed assertions.

intermediate

Why is assertThrows preferred over try-catch blocks in tests?

assertThrows makes tests cleaner and clearer by directly expressing the expected exception without manual try-catch handling.

beginner

Can assertThrows be used to test checked and unchecked exceptions?

Yes, it works for both checked exceptions (like IOException) and unchecked exceptions (like NullPointerException).

What is the correct way to use assertThrows to check for a NullPointerException?

A assertThrows(NullPointerException.class, () -> methodThatThrows());

B assertThrows(() -> methodThatThrows(), NullPointerException.class);

C assertThrows(methodThatThrows(), NullPointerException.class);

D assertThrows(NullPointerException, methodThatThrows());

The correct syntax is assertThrows(ExceptionClass.class, Executable), so option A is correct.

What does assertThrows return after catching the exception?

A The method return value

B A boolean true

C The exception object thrown

D Nothing (void)

assertThrows returns the caught exception object for further checks.

Which of these is NOT a benefit of using assertThrows in tests?

A Automatically fixes bugs

B Directly checks for exceptions

C Cleaner test code

D Avoids manual try-catch

assertThrows helps test exceptions but does not fix bugs automatically.

Can assertThrows be used to test if no exception is thrown?

A Yes, it passes if no exception is thrown

B Yes, but only for checked exceptions

C No, it ignores exceptions

D No, it fails if no exception is thrown

assertThrows expects an exception; if none is thrown, the test fails.

Which JUnit version introduced assertThrows?

A JUnit 4

B JUnit 5

C JUnit 3

D JUnit 6

assertThrows was introduced in JUnit 5 for better exception testing.

Explain how to use assertThrows to test that a method throws an IllegalArgumentException.

Think about the syntax: assertThrows(ExceptionClass.class, executable)

Why is using assertThrows better than a try-catch block in JUnit tests?

Consider how test code looks with and without assertThrows

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