Testing no exception thrown in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

JUnit test behavior when no exception is thrown

Consider the following JUnit 5 test method. What will be the test result when this test runs?

JUnit

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

public class CalculatorTest {
    @Test
    void testDivide() {
        assertDoesNotThrow(() -> {
            int result = 10 / 2;
        });
    }
}

A The test fails with a compilation error due to missing exception handling.

B The test fails because assertDoesNotThrow expects an exception to be thrown.

C The test passes because no exception is thrown during division.

D The test is ignored because no assertion is made.

💡 Hint

assertDoesNotThrow passes if the code inside the lambda runs without exceptions.

assertDoesNotThrow verifies that the code block does not throw any exceptions. Since 10 divided by 2 is valid, no exception occurs, so the test passes.

❓ assertion

intermediate

Correct use of assertDoesNotThrow in JUnit

Which of the following JUnit 5 assertions correctly tests that a method call does not throw any exception?

A assertDoesNotThrow(() -> myObject.myMethod());

B assertTrue(() -> myObject.myMethod());

C assertThrows(Exception.class, () -> myObject.myMethod());

D assertEquals(null, myObject.myMethod());

💡 Hint

assertDoesNotThrow expects a lambda expression that runs code without exceptions.

assertDoesNotThrow takes a lambda and passes if no exception is thrown during execution. Other options either expect exceptions or are invalid assertions.

🔧 Debug

advanced

Identify why a JUnit test with assertDoesNotThrow fails

Given the following test, why does it fail even though the method seems safe?

JUnit

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

public class ServiceTest {
    @Test
    void testProcess() {
        assertDoesNotThrow(() -> {
            process(null);
        });
    }

    void process(String input) {
        System.out.println(input.length());
    }
}

A The test fails because assertDoesNotThrow only works with checked exceptions.

B assertDoesNotThrow requires a try-catch block inside the lambda.

C The test fails because System.out.println cannot print null values.

D The method process throws a NullPointerException when input is null.

💡 Hint

Calling length() on a null String causes an exception.

process(null) calls input.length() where input is null, causing a NullPointerException, so assertDoesNotThrow fails.

🧠 Conceptual

advanced

Purpose of assertDoesNotThrow in test suites

Why would a tester use assertDoesNotThrow in a test case?

A To verify that a specific block of code runs without throwing any exceptions.

B To assert that a method returns a non-null value.

C To check that an exception is thrown by the code under test.

D To skip the test if an exception occurs.

💡 Hint

assertDoesNotThrow is about confirming absence of exceptions.

assertDoesNotThrow confirms that the tested code executes without exceptions, ensuring stability for that code path.

❓ framework

expert

Behavior of assertDoesNotThrow with checked exceptions

Consider a method that declares throwing a checked exception. How does assertDoesNotThrow handle this in JUnit 5?

JUnit

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

public class FileTest {
    void readFile() throws java.io.IOException {
        // Simulate file reading
    }

    @Test
    void testReadFile() {
        assertDoesNotThrow(() -> readFile());
    }
}

A assertDoesNotThrow only works with unchecked exceptions and will fail at compile time with checked exceptions.

B assertDoesNotThrow can handle checked exceptions if the lambda declares them or wraps them properly.

C assertDoesNotThrow automatically catches and ignores all exceptions, checked or unchecked.

D assertDoesNotThrow requires the test method to declare the checked exception in its throws clause.

💡 Hint

Lambda passed to assertDoesNotThrow can throw checked exceptions if declared.

assertDoesNotThrow accepts lambdas that can throw checked exceptions; it handles them by catching and failing the test if thrown.