@AfterEach method in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this JUnit test with @AfterEach?

Consider the following JUnit 5 test class. What will be printed to the console when the tests run?

JUnit

import org.junit.jupiter.api.*;

public class SampleTest {

    @BeforeEach
    void setup() {
        System.out.println("Setup");
    }

    @Test
    void testOne() {
        System.out.println("Test One");
    }

    @Test
    void testTwo() {
        System.out.println("Test Two");
    }

    @AfterEach
    void cleanup() {
        System.out.println("Cleanup");
    }
}

A Setup\nTest One\nCleanup\nSetup\nTest Two\nCleanup

B Setup\nTest One\nSetup\nTest Two\nCleanup\nCleanup

C Setup\nTest One\nTest Two\nCleanup\nCleanup

D Test One\nSetup\nCleanup\nTest Two\nSetup\nCleanup

💡 Hint

Remember that @BeforeEach and @AfterEach run before and after each test method.

JUnit runs @BeforeEach before each test and @AfterEach after each test. So for two tests, the sequence is: setup, testOne, cleanup, setup, testTwo, cleanup.

❓ assertion

intermediate

Which assertion correctly verifies @AfterEach method execution?

You want to verify that a resource is closed after each test using @AfterEach. Which assertion in the test class correctly checks this?

JUnit

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

class ResourceTest {
    private Resource resource;

    @BeforeEach
    void init() {
        resource = new Resource();
        resource.open();
    }

    @Test
    void testResourceUsage() {
        assertTrue(resource.isOpen());
    }

    @AfterEach
    void cleanup() {
        resource.close();
        // Which assertion here verifies cleanup?
        // ???
    }

    class Resource {
        private boolean open = false;
        void open() { open = true; }
        void close() { open = false; }
        boolean isOpen() { return open; }
    }
}

A assertNull(resource);

B assertTrue(resource.isOpen());

C assertEquals(true, resource.isOpen());

D assertFalse(resource.isOpen());

💡 Hint

After cleanup, the resource should be closed, so isOpen() should be false.

The @AfterEach method closes the resource, so after it runs, resource.isOpen() returns false. The assertion assertFalse(resource.isOpen()) correctly verifies this.

🔧 Debug

advanced

Why does the @AfterEach method not run after a test failure?

Given this test class, the @AfterEach method is not executed after a failing test. What is the most likely cause?

JUnit

import org.junit.jupiter.api.*;

class FailureTest {

    @Test
    void testFail() {
        Assertions.fail("Failing test");
    }

    @AfterEach
    void afterEach() {
        System.out.println("Cleanup after test");
    }
}

A The test framework version is outdated and does not support @AfterEach.

B @AfterEach is skipped if the test throws an exception.

C JUnit always runs @AfterEach even if the test fails; the problem is elsewhere.

D The test method must be static for @AfterEach to run.

💡 Hint

Think about JUnit 5 lifecycle guarantees.

JUnit 5 guarantees that @AfterEach runs after every test method, regardless of success or failure. If @AfterEach is not running, the issue is likely in the test setup or environment, not JUnit behavior.

🧠 Conceptual

advanced

What is the main purpose of the @AfterEach method in JUnit?

Choose the best description of the @AfterEach method's role in JUnit testing.

A To run code once before all tests in the class start.

B To run code after each test method to clean up resources or reset state.

C To run code before each test method to set up test data.

D To run code only if a test method fails.

💡 Hint

Think about when you want to reset or clean after tests.

@AfterEach runs after every test method to clean up or reset things so tests don't affect each other.

❓ framework

expert

How to ensure @AfterEach runs even if a test times out or is interrupted?

In JUnit 5, you want to guarantee that cleanup code in @AfterEach runs even if a test times out or is interrupted. Which approach ensures this behavior?

A Use try-finally inside the test method for cleanup instead of @AfterEach.

B Configure the test timeout with assertTimeoutPreemptively and place cleanup in @AfterEach.

C Use @AfterAll instead of @AfterEach for cleanup.

D JUnit 5 does not guarantee @AfterEach runs if a test is interrupted or times out.

💡 Hint

Consider how preemptive timeouts affect test lifecycle methods.

When using assertTimeoutPreemptively, the test thread is interrupted and @AfterEach may not run. To guarantee cleanup, use try-finally inside the test method itself.

Practice

1. What is the main purpose of a method annotated with @AfterEach in JUnit?

easy

A. To define a test method itself

B. To run code before any test methods start

C. To run cleanup code after each test method executes

D. To skip a test method during execution

Solution

1. Step 1: Understand the role of @AfterEach

   The @AfterEach annotation marks methods that run after every test method to clean up or reset state.

2. Step 2: Compare options with this role

   Only To run cleanup code after each test method executes correctly describes this cleanup role after each test method.

3. Final Answer:

   To run cleanup code after each test method executes -> Option C

4. Quick Check:

   @AfterEach = cleanup after tests [OK]

Hint: Remember: @AfterEach runs after every test method [OK]

Common Mistakes:

• Confusing @AfterEach with @BeforeEach
• Thinking @AfterEach defines test methods
• Assuming @AfterEach skips tests

2. Which of the following is the correct method signature for a method annotated with @AfterEach in JUnit?

easy

A. public int cleanup()

B. public void cleanup()

C. public void cleanup(String param)

D. public static void cleanup()

Solution

1. Step 1: Recall method requirements for @AfterEach

   Methods with @AfterEach must be void, no-argument, and instance methods (not static).

2. Step 2: Check each option

   public void cleanup() matches: public, void return, no parameters, instance method. Options B and C have wrong return type or parameters. public static void cleanup() is static, which is not allowed.

3. Final Answer:

   public void cleanup() -> Option B

4. Quick Check:

   @AfterEach method = void, no-args, non-static [OK]

Hint: @AfterEach methods are void, no parameters, non-static [OK]

Common Mistakes:

• Adding parameters to @AfterEach methods
• Making @AfterEach methods static
• Using non-void return types

3. Consider the following JUnit test class snippet:

class ExampleTest {
  int count = 0;

  @AfterEach
  void reset() {
    count = 0;
  }

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

  @Test
  void testDecrement() {
    count--;
    assertEquals(-1, count);
  }
}

What will be the result when running both tests?

medium

A. Both tests pass because count resets after each test

B. Both tests fail because count is shared and not reset

C. testIncrement passes, testDecrement fails

D. testIncrement fails, testDecrement passes

Solution

1. Step 1: Understand @AfterEach effect on count

   The reset() method sets count to 0 after each test method runs, so each test starts fresh.

2. Step 2: Analyze each test

   In testIncrement(), count increments from 0 to 1, assertion matches. In testDecrement(), count decrements from 0 to -1, assertion matches. Both pass.

3. Final Answer:

   Both tests pass because count resets after each test -> Option A

4. Quick Check:

   @AfterEach resets state = tests independent [OK]

Hint: @AfterEach resets variables so tests don't affect each other [OK]

Common Mistakes:

• Assuming count keeps value between tests
• Forgetting @AfterEach runs after each test
• Confusing @AfterEach with @BeforeEach

4. Identify the error in this JUnit test class:

class SampleTest {

  @AfterEach
  public static void cleanup() {
    System.out.println("Cleaning up");
  }

  @Test
  void testSomething() {
    assertTrue(true);
  }
}

medium

A. The @AfterEach method should not be static

B. The @AfterEach method must return boolean

C. The @Test method must be static

D. The @AfterEach method must have parameters

Solution

1. Step 1: Check @AfterEach method signature rules

   @AfterEach methods must be instance methods (non-static), void, and no-argument.

2. Step 2: Identify the error in the code

   The method cleanup() is declared static, which violates the rule.

3. Final Answer:

   The @AfterEach method should not be static -> Option A

4. Quick Check:

   @AfterEach methods cannot be static [OK]

Hint: @AfterEach methods must be instance, not static [OK]

Common Mistakes:

• Making @AfterEach methods static
• Adding parameters to @AfterEach methods
• Changing return type from void

5. You have a test class where each test opens a database connection. You want to ensure the connection closes after each test to avoid resource leaks. Which is the best way to do this using @AfterEach?

hard

A. Do not close the connection; let JVM handle it

B. Call connection.close() at the start of each test method

C. Use @BeforeEach to close the connection before tests

D. Annotate a method that calls connection.close() with @AfterEach

Solution

1. Step 1: Understand resource cleanup best practice

   Resources like database connections should be closed after each test to avoid leaks and interference.

2. Step 2: Apply @AfterEach for cleanup

   Using a method annotated with @AfterEach to close the connection ensures it happens after every test, keeping tests independent and safe.

3. Final Answer:

   Annotate a method that calls connection.close() with @AfterEach -> Option D

4. Quick Check:

   @AfterEach = cleanup resources after tests [OK]

Hint: Use @AfterEach to close resources after each test [OK]

Common Mistakes:

• Closing resources before tests instead of after
• Not closing resources causing leaks
• Relying on JVM to close resources automatically