@AfterAll method in JUnit - Test Execution Trace

Test Overview

This test demonstrates the use of the @AfterAll method in JUnit. It verifies that a cleanup method runs once after all tests complete.

Test Code - JUnit

JUnit

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;

public class AfterAllExampleTest {

    private static int resource;

    @BeforeAll
    public static void setup() {
        resource = 5;
        System.out.println("Setup done");
    }

    @Test
    public void testAddition() {
        int result = resource + 10;
        Assertions.assertEquals(15, result);
    }

    @Test
    public void testMultiplication() {
        int result = resource * 2;
        Assertions.assertEquals(10, result);
    }

    @AfterAll
    public static void cleanup() {
        resource = 0;
        System.out.println("Cleanup done");
    }
}

Execution Trace - 4 Steps

Step	Action	System State	Assertion	Result
1	JUnit starts test run and calls @BeforeAll method	Static variable 'resource' is set to 5	—	PASS
2	JUnit runs testAddition method	resource = 5	Check if resource + 10 equals 15	PASS
3	JUnit runs testMultiplication method	resource = 5	Check if resource * 2 equals 10	PASS
4	JUnit calls @AfterAll method after all tests	resource is reset to 0	—	PASS

Failure Scenario

Failing Condition: @AfterAll method is missing or throws exception

Execution Trace Quiz - 3 Questions

When is the @AfterAll method executed in a JUnit test class?

A After all test methods have run

B Before each test method

C Before all test methods

D After each test method

Key Result

Use @AfterAll to run cleanup code once after all tests finish. The method must be static and public to work correctly.

Practice

1. What is the main purpose of the @AfterAll annotation in JUnit 5?

easy

A. To run a method before each test method

B. To run a method once after all tests in the class have finished

C. To run a method after each test method

D. To run a method before all tests in the class start

Solution

1. Step 1: Understand the role of @AfterAll

   The @AfterAll annotation is designed to mark a method that runs once after all test methods in the class have completed.

2. Step 2: Compare with other lifecycle annotations

   @BeforeEach and @AfterEach run before and after each test method respectively, not once after all tests.

3. Final Answer:

   To run a method once after all tests in the class have finished -> Option B

4. Quick Check:

   @AfterAll runs once after all tests [OK]

Hint: Remember: AfterAll runs once after all tests finish [OK]

Common Mistakes:

• Confusing @AfterAll with @AfterEach
• Thinking it runs before tests
• Assuming it runs multiple times

2. Which of the following is the correct way to declare a method with @AfterAll in JUnit 5?

easy

A. public void cleanup() { ... }

B. private static void cleanup() { ... }

C. public static void cleanup() { ... }

D. private void cleanup() { ... }

Solution

1. Step 1: Recall method requirements for @AfterAll

   In JUnit 5, methods annotated with @AfterAll must be static and usually public to be accessible.

2. Step 2: Check each option

   public void cleanup() { ... } is non-static, so invalid. private static void cleanup() { ... } is private, so invalid. public static void cleanup() { ... } is public static, which is correct. private void cleanup() { ... } is private and non-static, invalid.

3. Final Answer:

   public static void cleanup() { ... } -> Option C

4. Quick Check:

   @AfterAll method must be static and public [OK]

Hint: Always make @AfterAll methods static and public [OK]

Common Mistakes:

• Forgetting to make the method static
• Using private access modifier
• Omitting the static keyword

3. Consider the following JUnit 5 test class snippet:

import org.junit.jupiter.api.*;

public class TestExample {
    static int count = 0;

    @Test
    void testOne() {
        count++;
    }

    @Test
    void testTwo() {
        count++;
    }

    @AfterAll
    public static void afterAll() {
        System.out.println("Count: " + count);
    }
}

What will be printed when the tests run?

medium

A. Count: 2

B. Count: 1

C. Count: 0

D. Compilation error

Solution

1. Step 1: Analyze test method executions

   Both testOne() and testTwo() increment the static variable count by 1 each. So after both tests run, count will be 2.

2. Step 2: Understand @AfterAll output

   The afterAll() method runs once after all tests and prints the current value of count, which is 2.

3. Final Answer:

   Count: 2 -> Option A

4. Quick Check:

   Both tests increment count, printed after all tests [OK]

Hint: Static count increments twice, printed once after all tests [OK]

Common Mistakes:

• Assuming count resets between tests
• Thinking @AfterAll runs before tests
• Confusing instance and static variables

4. Given this JUnit 5 test class:

import org.junit.jupiter.api.*;

public class SampleTest {

    @AfterAll
    void cleanup() {
        System.out.println("Cleaning up");
    }

    @Test
    void test() {
        Assertions.assertTrue(true);
    }
}

What is the problem with this code?

medium

A. The @AfterAll method must be static

B. The @AfterAll method must return a value

C. The @AfterAll method cannot print output

D. The @Test method must be static

Solution

1. Step 1: Check @AfterAll method signature

   In JUnit 5, @AfterAll methods must be static unless the test class is annotated with @TestInstance(Lifecycle.PER_CLASS). Here, the method is non-static and no such annotation is present.

2. Step 2: Validate other options

   The method does not need to return a value, printing is allowed, and @Test methods do not need to be static.

3. Final Answer:

   The @AfterAll method must be static -> Option A

4. Quick Check:

   @AfterAll requires static method unless PER_CLASS used [OK]

Hint: Check if @AfterAll method is static without PER_CLASS annotation [OK]

Common Mistakes:

• Forgetting static requirement for @AfterAll
• Thinking @AfterAll must return a value
• Confusing @Test method static rules

5. You want to release a shared database connection after all tests in your JUnit 5 class run. Which of the following is the best way to do this using @AfterAll?

hard

A. Declare a non-static @AfterAll method that closes the connection

B. Use @BeforeAll to close the connection before tests

C. Close the connection inside each @Test method

D. Declare a static @AfterAll method that closes the connection

Solution

1. Step 1: Understand resource cleanup timing

   Shared resources like a database connection should be closed once after all tests finish, not before or during each test.

2. Step 2: Apply @AfterAll rules

   The cleanup method must be static to run after all tests. Closing the connection in a static @AfterAll method ensures proper cleanup.

3. Final Answer:

   Declare a static @AfterAll method that closes the connection -> Option D

4. Quick Check:

   Static @AfterAll method cleans shared resources after tests [OK]

Hint: Use static @AfterAll to clean shared resources once after tests [OK]

Common Mistakes:

• Making @AfterAll method non-static
• Closing resources before tests start
• Closing resources inside each test