assertTimeout for performance in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the result of this JUnit test using assertTimeout?

Consider the following JUnit 5 test code snippet. What will be the test execution result?

JUnit

import static org.junit.jupiter.api.Assertions.assertTimeout;
import java.time.Duration;
import org.junit.jupiter.api.Test;

public class PerformanceTest {
    @Test
    void testFastOperation() {
        assertTimeout(Duration.ofMillis(100), () -> {
            Thread.sleep(50);
        });
    }
}

A Test fails because the operation exceeds the 100 milliseconds timeout.

B Test fails because Thread.sleep throws InterruptedException.

C Test passes because the operation completes within 100 milliseconds.

D Test is skipped due to missing @Timeout annotation.

💡 Hint

assertTimeout checks if the code block finishes within the given duration.

The test uses assertTimeout with 100 milliseconds. The code sleeps for 50 milliseconds, which is less than 100, so the test passes.

❓ assertion

intermediate

Which assertion correctly fails if the code block exceeds 200 milliseconds?

You want to fail a test if a code block takes longer than 200 milliseconds. Which JUnit assertion achieves this?

A assertTimeoutPreemptively(Duration.ofMillis(200), () -> { Thread.sleep(250); });

B assertTimeout(Duration.ofMillis(200), () -> { Thread.sleep(100); });

C assertTimeout(Duration.ofMillis(200), () -> { Thread.sleep(150); });

D assertTimeoutPreemptively(Duration.ofMillis(200), () -> { Thread.sleep(150); });

💡 Hint

assertTimeoutPreemptively interrupts the code if it exceeds the timeout.

assertTimeout does not interrupt the code, so it waits for completion even if it exceeds timeout. assertTimeoutPreemptively fails immediately if the timeout is exceeded.

🔧 Debug

advanced

Why does this assertTimeout test fail even if the code is slow?

Analyze the following test code and explain why it fails, even if the code block takes longer than 1 second.

JUnit

import static org.junit.jupiter.api.Assertions.assertTimeout;
import java.time.Duration;
import org.junit.jupiter.api.Test;

public class SlowTest {
    @Test
    void testSlowOperation() {
        assertTimeout(Duration.ofSeconds(1), () -> {
            Thread.sleep(1500);
        });
    }
}

A assertTimeoutPreemptively should be used to fail immediately on timeout, not assertTimeout.

B assertTimeout waits for the code to finish and then checks duration, so test fails after completion.

C Thread.sleep throws an exception that is caught by assertTimeout, so test passes.

D The test is missing @Timeout annotation, so timeout is ignored.

💡 Hint

assertTimeout waits for the code block to finish before checking the elapsed time and fails if it exceeds the timeout.

assertTimeout runs the code fully and then checks if it took longer than the timeout. It does not interrupt the code. So the test fails after 1.5 seconds because the duration exceeded the timeout.

🧠 Conceptual

advanced

What is the key difference between assertTimeout and assertTimeoutPreemptively in JUnit?

Choose the statement that best describes the difference between assertTimeout and assertTimeoutPreemptively.

A assertTimeout waits for the code block to finish before checking timeout; assertTimeoutPreemptively interrupts the code if timeout is exceeded.

B assertTimeoutPreemptively waits for completion; assertTimeout interrupts the code on timeout.

C Both assertions behave the same and do not interrupt the code block.

D assertTimeoutPreemptively only works with asynchronous code; assertTimeout works with synchronous code.

💡 Hint

One assertion interrupts the code on timeout, the other does not.

assertTimeout runs the code fully and then checks duration. assertTimeoutPreemptively interrupts the code execution if it exceeds the timeout, causing immediate failure.

❓ framework

expert

How to correctly use assertTimeoutPreemptively with a method that throws checked exceptions?

Given a method that throws InterruptedException, which is the correct way to use assertTimeoutPreemptively in JUnit 5 to test its performance?

JUnit

public void longRunningMethod() throws InterruptedException {
    Thread.sleep(300);
}

A assertTimeoutPreemptively(Duration.ofMillis(500), () -> longRunningMethod());

B assertTimeoutPreemptively(Duration.ofMillis(500), () -> { longRunningMethod(); });

C assertTimeoutPreemptively(Duration.ofMillis(500), () -> { longRunningMethod() throws InterruptedException; });

D assertTimeoutPreemptively(Duration.ofMillis(500), () -> { try { longRunningMethod(); } catch (InterruptedException e) { throw new RuntimeException(e); } });

💡 Hint

Checked exceptions must be handled or declared in lambda expressions.

Lambda passed to assertTimeoutPreemptively cannot throw checked exceptions directly. Wrapping the call in try-catch and rethrowing as unchecked exception is correct.