Testing multiple exceptions in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of testing multiple exceptions in JUnit?

To verify that a method throws the correct exceptions under different error conditions, ensuring robust error handling.

intermediate

How can you test multiple exceptions in JUnit 5 using assertThrows?

Use separate assertThrows calls for each exception scenario, each with a lambda that triggers the exception.

intermediate

What is the advantage of using assertThrows over the @Test(expected=...) annotation?

assertThrows allows testing multiple exceptions in the same test method and lets you inspect the exception object for details.

intermediate

Example: How do you test that a method throws IllegalArgumentException and NullPointerException separately in one test?

Use two assertThrows calls: one for IllegalArgumentException and one for NullPointerException, each with code triggering that exception.

beginner

Why is it important to test multiple exceptions in one test method?

It saves time and keeps related exception tests together, making the test suite easier to maintain and understand.

Which JUnit method is best for testing multiple exceptions in one test?

A @Test(expected=Exception.class)

B assertThrows

C assertEquals

D fail()

assertThrows lets you test different exceptions separately in the same test method.

What does assertThrows return that can be useful?

A The thrown exception object

B A boolean true/false

C The method return value

D Nothing

assertThrows returns the exception object so you can check its message or properties.

If a method can throw NullPointerException and IllegalArgumentException, how should you test it?

A Use two assertThrows calls, one for each exception

B Use one assertThrows call for both exceptions

C Use @Test(expected=Exception.class)

D No need to test exceptions

Each exception should be tested separately with assertThrows to confirm correct behavior.

What happens if the expected exception is not thrown in assertThrows?

A The test is skipped

B The test passes

C An error is logged but test passes

D The test fails

If the exception is not thrown, assertThrows causes the test to fail.

Why might @Test(expected=Exception.class) be less flexible than assertThrows?

A It can only test one exception per test method

B It does not check exception messages

C Both A and C

D It requires more code

@Test(expected=...) can only check one exception and cannot inspect the exception details.

Explain how to test multiple exceptions in a single JUnit 5 test method using assertThrows.

Think about calling assertThrows multiple times inside one test.

Why is testing multiple exceptions important in software testing?

Consider what happens if exceptions are not tested.