assertThrows usage in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this JUnit test using assertThrows?

Consider the following JUnit 5 test method. What will be the result of running this test?

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 testDivideByZero() {
        Calculator calc = new Calculator();
        assertThrows(ArithmeticException.class, () -> calc.divide(10, 0));
    }
}

A Test passes because ArithmeticException is thrown as expected.

B Test fails because no exception is thrown.

C Test fails with a compilation error due to wrong assertThrows usage.

D Test passes but throws NullPointerException instead.

💡 Hint

Remember assertThrows expects the exception class and a lambda that triggers the exception.

The divide method throws ArithmeticException when dividing by zero. The assertThrows checks that this exception is thrown, so the test passes.

❓ assertion

intermediate

Which assertThrows usage correctly verifies NullPointerException?

You want to test that calling method process(null) throws NullPointerException. Which option uses assertThrows correctly?

JUnit

class Processor {
    void process(String input) {
        if (input == null) throw new NullPointerException("Input is null");
    }
}

A assertThrows(() -> processor.process(null), NullPointerException.class);

B assertThrows(NullPointerException.class, () -> processor.process(null));

C assertThrows(NullPointerException.class, processor.process(null));

D assertThrows(NullPointerException.class, () -> processor.process());

💡 Hint

assertThrows takes the exception class first, then a lambda expression.

Option B correctly passes the exception class and a lambda that calls process with null. Others have wrong argument order or missing argument.

🔧 Debug

advanced

Why does this assertThrows test fail to catch the exception?

Examine the test below. Why does it fail even though divide(10, 0) throws ArithmeticException?

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 testDivideByZero() {
        Calculator calc = new Calculator();
        assertThrows(ArithmeticException.class, calc.divide(10, 0));
    }
}

A The test fails because assertThrows requires a try-catch block inside.

B The test fails because ArithmeticException is not thrown by divide method.

C The test fails because the exception class is incorrect.

D The test fails because assertThrows expects a lambda, but a method call is passed instead.

💡 Hint

Check the second argument to assertThrows carefully.

assertThrows requires a lambda or executable that throws the exception when run. Passing calc.divide(10, 0) calls the method immediately, causing the exception before assertThrows runs.

🧠 Conceptual

advanced

What does assertThrows return and how can it be used?

In JUnit 5, assertThrows returns the caught exception. How can this feature be used in tests?

A To verify exception message or properties by inspecting the returned exception object.

B To suppress the exception so the test continues without failure.

C To automatically retry the test if the exception is thrown.

D To convert checked exceptions into unchecked exceptions.

💡 Hint

Think about why you might want to keep the exception object after catching it.

assertThrows returns the exception so you can check its message or other details to ensure it is the expected error.

❓ framework

expert

Which assertThrows usage correctly tests a checked exception in a method?

Given a method that throws IOException, which assertThrows usage correctly tests it?

JUnit

import java.io.IOException;

class FileReader {
    void readFile(String path) throws IOException {
        if (path == null) throw new IOException("Path is null");
    }
}

A assertThrows(IOException.class, () -> fileReader.readFile(null));

B assertThrows(IOException.class, () -> fileReader.readFile(null)); // with throws declaration on test method

C assertThrows(IOException.class, () -> { fileReader.readFile(null); });

D assertThrows(IOException.class, () -> fileReader.readFile(null)); // without throws declaration on test method

💡 Hint

Checked exceptions must be handled or declared. Lambdas in assertThrows must handle checked exceptions properly.

Option C uses a lambda block that can throw checked exceptions. Option C and C are similar but may cause compilation errors if the test method does not declare throws IOException. Option C is invalid if test method lacks throws declaration.