@AfterAll method in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the @AfterAll method in JUnit?

The <code>@AfterAll</code> method runs once after all test methods in a class have finished. It is used to clean up resources shared by tests, like closing database connections.

intermediate

How must a method annotated with @AfterAll be declared in JUnit 5?

It must be <strong>static</strong> unless the test class is annotated with <code>@TestInstance(TestInstance.Lifecycle.PER_CLASS)</code>. This ensures it runs once after all tests.

beginner

Example of a simple @AfterAll method in JUnit 5:

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

intermediate

What happens if an exception is thrown inside an @AfterAll method?

The exception is reported as a test failure or error after all tests complete. It can affect the test report but does not stop other tests since it runs last.

beginner

Why use @AfterAll instead of @AfterEach?

@AfterAll runs once after all tests, good for expensive cleanup. @AfterEach runs after every test, which can be slower and redundant for shared resources.

What is the correct signature for an @AfterAll method in JUnit 5 without @TestInstance?

A public static void methodName()

B public void methodName()

C private void methodName()

D protected void methodName()

@AfterAll methods must be static unless the class uses @TestInstance(TestInstance.Lifecycle.PER_CLASS).

When is an @AfterAll method executed?

A Before each test method

B Once after all test methods in the class

C After each test method

D Before all test methods in the class

@AfterAll runs once after all tests finish.

Which annotation allows @AfterAll methods to be non-static?

A @TestInstance(TestInstance.Lifecycle.PER_CLASS)

B @TestInstance(Lifecycle.PER_METHOD)

C @BeforeAll

D @Test

Using @TestInstance(TestInstance.Lifecycle.PER_CLASS) lets @AfterAll methods be instance methods.

What is a common use case for @AfterAll?

A Initialize test data before each test

B Skip a test method

C Run a test multiple times

D Clean up shared resources after all tests

@AfterAll is used to clean up resources shared by all tests.

If an exception occurs in @AfterAll, what happens?

A Tests stop immediately

B Exception is ignored

C Exception is reported after all tests

D Tests rerun automatically

Exceptions in @AfterAll are reported after all tests complete.

Explain the role and requirements of the @AfterAll method in JUnit testing.

Think about when and why you would close shared resources.

Describe the difference between @AfterEach and @AfterAll annotations.

Consider how often each method runs during testing.

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