assertThrows for exceptions in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to assert that a NullPointerException is thrown.

JUnit

assertThrows([1].class, () -> { throw new NullPointerException(); });

Drag options to blanks, or click blank then click option'

AIllegalArgumentException

BIOException

CNullPointerException

DRuntimeException

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different exception class than the one thrown.

Forgetting to add .class after the exception name.

The assertThrows method expects the exception class that should be thrown. Here, NullPointerException.class is correct.

2fill in blank

medium

Complete the code to assert that an ArithmeticException is thrown when dividing by zero.

JUnit

assertThrows([1].class, () -> { int result = 10 / 0; });

Drag options to blanks, or click blank then click option'

AIllegalStateException

BNullPointerException

CArrayIndexOutOfBoundsException

DArithmeticException

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong exception class like NullPointerException.

Not matching the exception type thrown by the code.

Dividing by zero throws an ArithmeticException, so assertThrows should expect ArithmeticException.class.

3fill in blank

hard

Fix the error in the code to correctly assert that an IndexOutOfBoundsException is thrown.

JUnit

assertThrows([1].class, () -> { List<String> list = new ArrayList<>(); list.get(1); });

Drag options to blanks, or click blank then click option'

AIndexOutOfBoundsException

BIllegalArgumentException

CNullPointerException

DIOException

Attempts:

3 left

💡 Hint

Common Mistakes

Using NullPointerException instead of IndexOutOfBoundsException.

Forgetting to specify the correct exception class.

Accessing an invalid index in a list throws IndexOutOfBoundsException, so assertThrows should expect IndexOutOfBoundsException.class.

4fill in blank

hard

Fill both blanks to assert that a NumberFormatException is thrown when parsing an invalid number.

JUnit

assertThrows([1].class, () -> { Integer.parseInt([2]); });

Drag options to blanks, or click blank then click option'

ANumberFormatException

B"abc"

C"123"

DIllegalArgumentException

Attempts:

3 left

💡 Hint

Common Mistakes

Using a valid number string like "123" which does not throw exception.

Using the wrong exception class.

Parsing "abc" as an integer throws NumberFormatException, so the first blank is NumberFormatException.class and the second blank is the invalid string "abc".

5fill in blank

hard

Fill all three blanks to assert that an IllegalArgumentException is thrown with a custom message.

JUnit

IllegalArgumentException exception = assertThrows([1].class, () -> { throw new [2]([3]); });
assertEquals("Invalid input", exception.getMessage());

Drag options to blanks, or click blank then click option'

AIllegalArgumentException

C"Invalid input"

D"Error"

Attempts:

3 left

💡 Hint

Common Mistakes

Using different exception classes in assertThrows and throw statement.

Passing a wrong message string that does not match the assertion.

To assert the exception and check its message, use IllegalArgumentException.class for the first blank, throw new IllegalArgumentException for the second, and pass the message "Invalid input" as the third.

Practice

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

easy

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

B. To verify the return value of a method

C. To measure the execution time of a method

D. To skip a test case conditionally

Solution

1. Step 1: Understand the role of assertThrows

   assertThrows is designed to check if a certain exception occurs when running some code.

2. Step 2: Compare with other options

   Options B, C, and D describe different test functions unrelated to exception checking.

3. Final Answer:

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

4. Quick Check:

   assertThrows checks exceptions = A [OK]

Hint: Remember: assertThrows tests exceptions thrown by code [OK]

Common Mistakes:

• Confusing assertThrows with assertEquals
• Thinking assertThrows measures performance
• Using assertThrows to skip tests

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 the method signature

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

2. Step 2: Check each option

   assertThrows(Exception.class, () -> methodCall()); matches the correct order and lambda usage. Options A, B, and D have wrong argument order or missing lambda.

3. Final Answer:

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

4. Quick Check:

   Exception class first, then lambda = C [OK]

Hint: Exception class first, then lambda with code [OK]

Common Mistakes:

• Swapping the order of arguments
• Passing method call instead of lambda
• Omitting the lambda expression

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

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

@Test
void testDivideByZero() {
  assertThrows(ArithmeticException.class, () -> {
    int result = 10 / 0;
  });
}

medium

A. Test passes but exception type is wrong

B. Test fails because no exception is thrown

C. Test fails due to syntax error

D. Test passes because ArithmeticException is thrown

Solution

1. Step 1: Analyze the code inside assertThrows

   The code divides 10 by 0, which throws an ArithmeticException at runtime.

2. Step 2: Check if exception matches expected

   assertThrows expects ArithmeticException.class, which matches the thrown exception.

3. Final Answer:

   Test passes because ArithmeticException is thrown -> Option D

4. Quick Check:

   Exception thrown matches expected = A [OK]

Hint: Divide by zero throws ArithmeticException [OK]

Common Mistakes:

• Assuming no exception is thrown
• Confusing exception types
• Thinking test fails on exception

4. Identify the error in this JUnit test using assertThrows:

@Test
void testNullPointer() {
  assertThrows(NullPointerException, () -> {
    String s = null;
    s.length();
  });
}

medium

A. Lambda syntax is incorrect

B. NullPointerException is not thrown here

C. Missing .class after NullPointerException

D. assertThrows cannot test NullPointerException

Solution

1. Step 1: Check the exception argument

   The exception class must be passed as NullPointerException.class, not just the class name.

2. Step 2: Verify lambda and exception thrown

   The lambda syntax is correct and the code throws NullPointerException as expected.

3. Final Answer:

   Missing .class after NullPointerException -> Option C

4. Quick Check:

   Exception class needs .class suffix = B [OK]

Hint: Always add .class after exception name in assertThrows [OK]

Common Mistakes:

• Omitting .class after exception
• Miswriting lambda syntax
• Assuming exception not thrown

5. You want to test that a method parseNumber(String s) throws NumberFormatException only when the input is not a valid number. Which of these tests correctly uses assertThrows to check this behavior?

hard

A. assertThrows(NumberFormatException.class, () -> parseNumber(123));

B. assertThrows(NumberFormatException.class, () -> parseNumber("abc"));

C. assertThrows(Exception.class, () -> parseNumber(null));

D. assertThrows(NumberFormatException.class, () -> parseNumber("123"));

Solution

1. Step 1: Understand the method behavior

   parseNumber should throw NumberFormatException for invalid strings like "abc" but not for valid numbers like "123".

2. Step 2: Evaluate each test case

   assertThrows(NumberFormatException.class, () -> parseNumber("abc")); tests invalid input "abc" correctly. assertThrows(NumberFormatException.class, () -> parseNumber("123")); tests valid input, so no exception expected. assertThrows(Exception.class, () -> parseNumber(null)); uses a different exception and null input. assertThrows(NumberFormatException.class, () -> parseNumber(123)); passes an integer instead of string, causing compile error.

3. Final Answer:

   assertThrows(NumberFormatException.class, () -> parseNumber("abc")); -> Option B

4. Quick Check:

   Test invalid input throws NumberFormatException = D [OK]

Hint: Test invalid strings with assertThrows for NumberFormatException [OK]

Common Mistakes:

• Testing valid input expecting exception
• Passing wrong argument types
• Using wrong exception class