@AfterAll method in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of @AfterAll method execution order

Consider the following JUnit 5 test class. What will be the output when the tests run?

JUnit

import org.junit.jupiter.api.*;

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class SampleTest {

    @BeforeAll
    void beforeAll() {
        System.out.println("BeforeAll");
    }

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

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

    @AfterAll
    void afterAll() {
        System.out.println("AfterAll");
    }
}

A BeforeAll\nAfterAll\nTestOne\nTestTwo

B BeforeAll\nTestOne\nTestTwo\nAfterAll

C TestOne\nTestTwo\nBeforeAll\nAfterAll

D TestOne\nBeforeAll\nTestTwo\nAfterAll

💡 Hint

Remember that @BeforeAll runs once before any tests, and @AfterAll runs once after all tests.

The @BeforeAll method runs once before any test methods. Then the test methods run in any order (usually the order they appear). Finally, the @AfterAll method runs once after all tests have completed.

Because the class uses @TestInstance(TestInstance.Lifecycle.PER_CLASS), the lifecycle allows non-static @BeforeAll and @AfterAll methods.

❓ assertion

intermediate

Correct assertion to verify @AfterAll cleanup

You want to verify that a resource is cleaned up after all tests run using @AfterAll. Which assertion correctly checks that the resource is null after cleanup?

JUnit

public class ResourceTest {
    private static Resource resource;

    @BeforeAll
    static void setup() {
        resource = new Resource();
    }

    @AfterAll
    static void cleanup() {
        resource = null;
    }

    @Test
    void testResourceNotNull() {
        Assertions.assertNotNull(resource);
    }

    // Which assertion below correctly verifies cleanup?
}

A Assertions.assertTrue(resource != null);

B Assertions.assertNotNull(resource);

C Assertions.assertNull(resource);

D Assertions.assertFalse(resource == null);

💡 Hint

After cleanup, the resource should be null.

The @AfterAll method sets resource to null. To verify cleanup, you assert that resource is null.

Option C uses assertNull, which is correct. Other options check for non-null or true/false conditions that do not match the expected null state.

🔧 Debug

advanced

Why does @AfterAll method cause a failure?

Given this JUnit 5 test class, why does the test suite fail with an exception related to the @AfterAll method?

JUnit

import org.junit.jupiter.api.*;

public class FailureTest {

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

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

A @AfterAll method must return a boolean

B @AfterAll method must be private

C @AfterAll method cannot print to console

D @AfterAll method must be static unless using @TestInstance(PER_CLASS)

💡 Hint

Check the method modifiers and class annotations.

By default, JUnit 5 requires @AfterAll methods to be static unless the test class is annotated with @TestInstance(TestInstance.Lifecycle.PER_CLASS).

In this code, the @AfterAll method is non-static and the class lacks the @TestInstance annotation, causing a runtime failure.

🧠 Conceptual

advanced

Purpose of @AfterAll in test lifecycle

What is the main purpose of the @AfterAll method in a JUnit 5 test class?

A To run code once after all test methods have executed, typically for cleanup

B To run code before each test method to set up test data

C To run code after each test method to reset mocks

D To run code only if a test method fails

💡 Hint

Think about when @AfterAll runs compared to individual tests.

The @AfterAll method runs once after all tests in the class have finished. It is used to clean up shared resources or perform final actions.

Other options describe @BeforeEach, @AfterEach, or conditional test failure hooks, which are different.

❓ framework

expert

Behavior of @AfterAll with parallel test execution

In a JUnit 5 test suite configured to run tests in parallel, how does the @AfterAll method behave?

A @AfterAll runs once after all parallel tests in the class complete, regardless of thread

B @AfterAll runs after each test thread finishes, multiple times

C @AfterAll runs before any parallel tests start

D @AfterAll runs only if tests run sequentially, skipped in parallel mode

💡 Hint

Consider the lifecycle scope of @AfterAll in parallel execution.

Even when tests run in parallel threads, the @AfterAll method runs once after all tests in the class finish.

It is not repeated per thread and is not skipped in parallel mode.