@Execution annotation in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Purpose of @Execution annotation in JUnit

What is the primary purpose of the @Execution annotation in JUnit 5?

A To provide a timeout value for test execution

B To define the order in which test methods are executed

C To mark a test method as disabled temporarily

D To specify whether tests in a class or method should run concurrently or sequentially

💡 Hint

Think about controlling how tests run in parallel or not.

The @Execution annotation controls whether tests run concurrently or sequentially. It helps manage parallel execution behavior in JUnit 5.

❓ Predict Output

intermediate

Output of test execution mode with @Execution

Given the following JUnit 5 test class, what is the expected execution mode of the tests?

JUnit

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.parallel.Execution;
import org.junit.jupiter.api.parallel.ExecutionMode;

@Execution(ExecutionMode.CONCURRENT)
public class SampleTest {

    @Test
    void testOne() throws InterruptedException {
        Thread.sleep(100);
        System.out.println("Test One");
    }

    @Test
    void testTwo() throws InterruptedException {
        Thread.sleep(100);
        System.out.println("Test Two");
    }
}

A Tests run concurrently, possibly overlapping in time

B Tests run in random order but sequentially

C Tests run sequentially, one after another

D Tests are skipped due to incorrect annotation usage

💡 Hint

Look at the ExecutionMode value used in the annotation.

The annotation @Execution(ExecutionMode.CONCURRENT) instructs JUnit to run tests concurrently, so the two tests may overlap in execution time.

❓ assertion

advanced

Correct assertion for verifying parallel execution

Which assertion best verifies that two test methods annotated with @Execution(ExecutionMode.CONCURRENT) actually ran in parallel?

A assertEquals(testOneStartTime, testTwoStartTime) // tests started at exactly the same time

B assertTrue(testOneEndTime - testTwoStartTime < 0) // testOne ended before testTwo started

C assertTrue(Math.abs(testOneEndTime - testTwoEndTime) < expectedOverlap) // tests overlapped in time

D assertFalse(testOneEndTime > testTwoStartTime) // testOne ended after testTwo started

💡 Hint

Parallel tests overlap in execution time, so their end times should be close.

To verify parallel execution, you check if the tests overlapped in time. Option C checks if the difference between their end times is less than an expected overlap threshold.

🔧 Debug

advanced

Why does @Execution annotation have no effect?

A developer added @Execution(ExecutionMode.CONCURRENT) to a test class, but tests still run sequentially. What is the most likely reason?

A The annotation is misspelled and ignored by JUnit

B The test runner does not support parallel execution or it is not enabled

C The tests have @Disabled annotation which forces sequential execution

D JUnit 5 does not support the @Execution annotation

💡 Hint

Check if parallel execution is enabled in the test environment.

Even if @Execution(ExecutionMode.CONCURRENT) is present, parallel execution must be enabled in the JUnit platform configuration or test runner. Otherwise, tests run sequentially.

❓ framework

expert

Combining @Execution with other parallel annotations

In JUnit 5, if a test class is annotated with @Execution(ExecutionMode.CONCURRENT) and individual test methods are annotated with @Execution(ExecutionMode.SAME_THREAD), what is the effective execution mode for those methods?

A Method-level SAME_THREAD overrides class-level CONCURRENT; those methods run sequentially

B Methods annotated with SAME_THREAD run sequentially; others run concurrently

C Class-level CONCURRENT overrides method-level SAME_THREAD; all run concurrently

D JUnit throws a runtime error due to conflicting annotations

💡 Hint

Method-level annotations override class-level annotations in JUnit.

In JUnit 5, method-level @Execution annotations override class-level ones. So methods with SAME_THREAD run sequentially even if the class is marked CONCURRENT.