Resource locking with @ResourceLock in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of concurrent tests with @ResourceLock

Consider the following JUnit 5 test class using @ResourceLock to manage concurrent access. What will be the output order of the printed statements when running all tests in parallel?

JUnit

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

@Execution(ExecutionMode.CONCURRENT)
public class ResourceLockTest {

    @Test
    @ResourceLock(value = "RESOURCE_A")
    void test1() throws InterruptedException {
        System.out.println("Start test1");
        Thread.sleep(100);
        System.out.println("End test1");
    }

    @Test
    @ResourceLock(value = "RESOURCE_A")
    void test2() throws InterruptedException {
        System.out.println("Start test2");
        Thread.sleep(100);
        System.out.println("End test2");
    }

    @Test
    void test3() {
        System.out.println("Start test3");
        System.out.println("End test3");
    }
}

A Start test3\nStart test1\nStart test2\nEnd test3\nEnd test1\nEnd test2

B Start test1\nStart test2\nEnd test1\nEnd test2\nStart test3\nEnd test3

C Start test1\nEnd test1\nStart test2\nEnd test2\nStart test3\nEnd test3

D Start test3\nEnd test3\nStart test1\nEnd test1\nStart test2\nEnd test2

💡 Hint

Remember that tests locking the same resource run sequentially, but tests without locks can run concurrently.

Tests test1 and test2 both lock RESOURCE_A, so they run one after another. test3 has no lock and can run concurrently, so it may start and finish before or during the others. The only guaranteed order is that test1 and test2 do not overlap.

❓ assertion

intermediate

Correct assertion for resource lock count

You have a test method annotated with @ResourceLock("DB_CONNECTION") that increments a shared counter. Which assertion correctly verifies that the counter increments exactly once per test execution when tests run concurrently?

JUnit

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

int counter = 0;

@Test
@ResourceLock("DB_CONNECTION")
void incrementCounter() {
    counter++;
}

A assertEquals(1, counter);

B assertEquals(2, counter);

C assertNotNull(counter);

D assertTrue(counter >= 1);

💡 Hint

The resource lock ensures only one test increments at a time, so the counter should be exactly 1 after one test.

Because the resource lock serializes access, the counter increments once per test execution. The correct assertion checks for exactly 1.

🔧 Debug

advanced

Identify the cause of test deadlock with @ResourceLock

Given two test methods each annotated with @ResourceLock on different resources but run concurrently, the test suite hangs indefinitely. What is the most likely cause?

JUnit

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

@Execution(ExecutionMode.CONCURRENT)
public class DeadlockTest {

    @Test
    @ResourceLock(value = "RESOURCE_1")
    void testA() {
        // locks RESOURCE_1
        // then tries to lock RESOURCE_2 inside
    }

    @Test
    @ResourceLock(value = "RESOURCE_2")
    void testB() {
        // locks RESOURCE_2
        // then tries to lock RESOURCE_1 inside
    }
}

A Incorrect @ResourceLock annotation syntax causing test hang

B JUnit does not support concurrent execution with @ResourceLock

C Circular wait due to nested resource locks causing deadlock

D Tests are not annotated with @Execution(ExecutionMode.SAME_THREAD)

💡 Hint

Think about what happens when two tests wait on each other's locked resources.

Deadlock occurs when testA holds RESOURCE_1 and waits for RESOURCE_2, while testB holds RESOURCE_2 and waits for RESOURCE_1, causing circular wait.

❓ framework

advanced

Behavior of @ResourceLock with multiple resources

What happens when a test method is annotated with @ResourceLock(value = {"RESOURCE_X", "RESOURCE_Y"}) in JUnit 5?

A The test locks RESOURCE_X first, then RESOURCE_Y sequentially during execution

B The test locks both RESOURCE_X and RESOURCE_Y simultaneously before execution

C The test locks only RESOURCE_X and ignores RESOURCE_Y

D The test locks RESOURCE_X and RESOURCE_Y but allows other tests to lock them concurrently

💡 Hint

Consider how @ResourceLock handles multiple resource names in its value array.

Annotating with multiple resources locks all listed resources simultaneously to prevent concurrent access conflicts.

🧠 Conceptual

expert

Effect of @ResourceLock on test execution order and concurrency

In a large test suite with many tests annotated with different @ResourceLock values, how does JUnit 5 determine which tests can run concurrently and which must run sequentially?

A Tests locking the same resource run sequentially; tests locking different resources run concurrently

B All tests run sequentially regardless of resource locks to avoid conflicts

C Tests run concurrently only if they have no @ResourceLock annotation

D JUnit randomly schedules tests ignoring resource locks

💡 Hint

Think about resource locking as a way to prevent simultaneous access to shared resources.

JUnit uses resource locks to serialize tests that share the same resource name, allowing tests with different resource locks to run in parallel safely.