@AfterAll method in JUnit - Build an Automation Script

Verify @AfterAll method runs once after all tests

Preconditions (2)

Step 1: Create a test class with at least two test methods annotated with @Test

Step 2: Add a static method annotated with @AfterAll

Step 3: Inside the @AfterAll method, set a static boolean flag to true

Step 4: Run the test class

Step 5: Verify that the @AfterAll method was executed exactly once after all tests

✅ Expected Result: The @AfterAll method runs once after all test methods complete, and the static flag is set to true

Automation Requirements - JUnit 5

Assertions Needed:

Verify that the static flag is true after all tests run

Verify that the @AfterAll method is called exactly once

Best Practices:

Use static methods for @AfterAll

Use assertions inside test methods or after test execution to verify cleanup

Keep @AfterAll method simple and fast

Avoid side effects that affect other tests

Automated Solution

JUnit

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

public class AfterAllExampleTest {
    private static boolean afterAllExecuted = false;

    @Test
    void testOne() {
        Assertions.assertFalse(afterAllExecuted, "@AfterAll should not run before tests");
    }

    @Test
    void testTwo() {
        Assertions.assertFalse(afterAllExecuted, "@AfterAll should not run before tests");
    }

    @AfterAll
    static void cleanup() {
        afterAllExecuted = true;
        System.out.println("@AfterAll method executed");
    }

    @Test
    void verifyAfterAllExecuted() {
        // This test runs before @AfterAll, so we cannot assert here
        // Instead, we rely on external verification or test runner output
    }
}

This test class has two test methods testOne and testTwo. Both assert that the afterAllExecuted flag is false, ensuring the @AfterAll method has not run yet.

The @AfterAll method cleanup is static as required by JUnit 5. It sets the flag to true and prints a message.

Since @AfterAll runs after all tests, the flag will be true only after all tests complete. We cannot assert the flag inside tests because they run before @AfterAll.

To verify the @AfterAll method ran, you can check the console output or use a test runner that supports lifecycle callbacks.

Common Mistakes - 3 Pitfalls

Making the @AfterAll method non-static

Trying to assert @AfterAll execution inside test methods

Putting heavy or slow code inside @AfterAll

Bonus Challenge

Now add a test class using @TestInstance(Lifecycle.PER_CLASS) to allow a non-static @AfterAll method

Show Hint

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