Test independence in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why is test independence important in JUnit?

In JUnit testing, why should each test method be independent from others?

A To reduce the total number of test methods needed

B To ensure tests can run in any order without affecting results

C To allow tests to share state for faster execution

D To make tests dependent on the success of previous tests

💡 Hint

Think about what happens if tests rely on each other's data or state.

Test independence ensures that tests do not affect each other, so they can run in any order and still produce reliable results.

❓ Predict Output

intermediate

Output of dependent JUnit tests

Consider these two JUnit test methods. What will be the output if testB runs before testA?

JUnit

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

public class SampleTest {
    private static int counter = 0;

    @Test
    public void testA() {
        counter = 5;
        assertEquals(5, counter);
    }

    @Test
    public void testB() {
        assertEquals(5, counter);
    }
}

A Both testA and testB pass

B Both testA and testB fail

C testA fails because counter is not set, testB passes

D testB fails because counter is 0, testA passes

💡 Hint

Remember static variables keep their value across tests unless reset.

testB expects counter to be 5 but it is 0 initially. Since testB runs first, it fails. testA sets counter to 5 and passes.

❓ assertion

advanced

Correct assertion for independent test

Which assertion best ensures that a JUnit test is independent and does not rely on previous test state?

A assertTrue(sharedFlag) set by another test

B assertNotNull(sharedObject) without initialization in this test

C assertEquals(expectedValue, actualValue) with setup in @BeforeEach

D assertEquals(0, counter) relying on static variable from previous test

💡 Hint

Think about where the test data comes from and if it is initialized fresh each time.

Using @BeforeEach to set up expected values ensures each test runs with fresh data, making it independent.

🔧 Debug

advanced

Identify the cause of flaky JUnit tests

These JUnit tests sometimes fail and sometimes pass. What is the most likely cause?

JUnit

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;

public class FlakyTest {
    private static List<String> sharedList = new ArrayList<>();

    @Test
    public void testAdd() {
        sharedList.add("item");
        assertEquals(1, sharedList.size());
    }

    @Test
    public void testClear() {
        sharedList.clear();
        assertEquals(0, sharedList.size());
    }
}

A Tests share mutable static state causing order-dependent failures

B Tests use different assertion methods causing conflicts

C Tests have syntax errors causing random failures

D Tests run in parallel causing thread safety issues

💡 Hint

Look at how the sharedList is used and modified.

Using a static shared list modified by tests causes flaky results depending on test execution order.

❓ framework

expert

Best practice to ensure test independence in JUnit 5

Which JUnit 5 feature helps guarantee test independence by resetting state before each test method?

A @BeforeEach annotated method to initialize fresh state

B @TestMethodOrder to run tests in a specific sequence

C @BeforeAll to set up shared state once for all tests

D @RepeatedTest to run the same test multiple times

💡 Hint

Think about how to prepare the environment freshly for each test.

@BeforeEach runs before every test method, allowing fresh setup and ensuring tests do not share state.

Practice

1.

What does test independence mean in JUnit testing?

Choose the best explanation.

easy

A. Tests must run in a specific order to pass correctly.

B. Tests should always use the same objects to save memory.

C. Tests share data to reduce setup time.

D. Each test runs without depending on the results or state of other tests.

Solution

1. Step 1: Understand test independence concept

   Test independence means tests do not rely on each other's results or states.

2. Step 2: Compare options with definition

   Only Each test runs without depending on the results or state of other tests. correctly states that tests run alone without dependencies.

3. Final Answer:

   Each test runs without depending on the results or state of other tests. -> Option D

4. Quick Check:

   Test independence = tests run alone [OK]

Hint: Tests should not rely on others to pass [OK]

Common Mistakes:

• Thinking tests must run in order
• Sharing data between tests
• Reusing objects without reset

2.

Which JUnit annotation is best used to prepare fresh data before each test to ensure test independence?

easy

A. @BeforeClass

B. @BeforeEach

C. @AfterAll

D. @Test

Solution

1. Step 1: Identify setup annotations in JUnit

   @BeforeEach runs before every test method, preparing fresh data each time.

2. Step 2: Match annotation to test independence need

   @BeforeClass runs once before all tests, not before each, so it doesn't ensure fresh data per test.

3. Final Answer:

   @BeforeEach -> Option B

4. Quick Check:

   @BeforeEach prepares fresh data [OK]

Hint: Use @BeforeEach for fresh setup before every test [OK]

Common Mistakes:

• Using @BeforeClass which runs only once
• Confusing @AfterAll with setup
• Not using any setup annotation

3.

Consider this JUnit test class snippet:

class CounterTest {
  int count = 0;

  @Test
  void testIncrement() {
    count++;
    assertEquals(1, count);
  }

  @Test
  void testReset() {
    assertEquals(0, count);
  }
}

What will happen if these tests run in this order without any setup method?

medium

A. testIncrement passes but testReset may fail due to shared count state.

B. testIncrement fails if run after testReset because count is 0.

C. testIncrement may fail if testReset runs first because count is shared.

D. Both tests pass because count is reset manually.

Solution

1. Step 1: Analyze shared variable usage

   The variable count is shared across tests and not reset before each test, leading to order dependency.

2. Step 2: Consider test order impact

   If testIncrement runs first: count++ to 1, assert 1 passes (leaves count=1); testReset: assertEquals(0, 1) fails. If testReset first: assert 0 (initial) passes (leaves 0), testIncrement ++ to 1 passes. Thus, testReset may fail due to shared state.

3. Final Answer:

   testIncrement passes but testReset may fail due to shared count state. -> Option A

4. Quick Check:

   Shared state causes test order dependency [OK]

Hint: Shared variables cause test order dependency [OK]

Common Mistakes:

• Assuming tests run isolated without setup
• Ignoring shared mutable state
• Thinking manual reset in testReset fixes all issues

4.

Identify the problem in this JUnit test class and how to fix it to ensure test independence:

class ListTest {
  List<String> list = new ArrayList<>();

  @Test
  void testAdd() {
    list.add("item");
    assertEquals(1, list.size());
  }

  @Test
  void testClear() {
    list.clear();
    assertEquals(0, list.size());
  }
}

medium

A. Problem: list is shared and not reset; Fix: initialize list in @BeforeEach method.

B. Problem: list is not final; Fix: make list final to avoid changes.

C. Problem: testClear should run before testAdd; Fix: reorder tests.

D. Problem: list should be static; Fix: declare list as static.

Solution

1. Step 1: Identify shared mutable state

   The list is a shared instance variable and is not reset before each test, causing tests to affect each other.

2. Step 2: Apply proper setup for independence

   Initializing the list inside a method annotated with @BeforeEach ensures a fresh list before every test, maintaining independence.

3. Final Answer:

   Problem: list is shared and not reset; Fix: initialize list in @BeforeEach method. -> Option A

4. Quick Check:

   Use @BeforeEach to reset shared objects [OK]

Hint: Reset shared objects in @BeforeEach for independence [OK]

Common Mistakes:

• Making list final does not reset contents
• Reordering tests does not guarantee independence
• Using static list shares state across tests

5.

You have a JUnit test class where one test modifies a static shared resource, causing other tests to fail intermittently.

How can you redesign the tests to maintain test independence and avoid flaky failures?

hard

A. Combine all tests into one method to control resource usage.

B. Run tests sequentially to prevent concurrent modification.

C. Avoid using static shared resources; initialize fresh instances in @BeforeEach.

D. Use @AfterAll to reset the static resource once after all tests.

Solution

1. Step 1: Understand static shared resource issue

   Static resources are shared across all tests and can cause interference if modified without reset.

2. Step 2: Apply test independence principle

   To ensure independence, avoid static shared mutable state or reset it before each test by creating fresh instances in @BeforeEach.

3. Step 3: Evaluate other options

   Running tests sequentially or resetting once after all tests does not guarantee independence. Combining tests reduces clarity and independence.

4. Final Answer:

   Avoid using static shared resources; initialize fresh instances in @BeforeEach. -> Option C

5. Quick Check:

   Fresh instances per test ensure independence [OK]

Hint: No static shared state; fresh setup each test [OK]

Common Mistakes:

• Relying on test order or sequence
• Resetting static resource only once
• Merging tests reduces clarity and independence