@AfterAll method in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to mark a method that runs once after all tests in a JUnit 5 test class.

JUnit

import org.junit.jupiter.api.[1];

public class CalculatorTest {

    @[1]
    static void cleanup() {
        System.out.println("Cleanup after all tests");
    }
}

Drag options to blanks, or click blank then click option'

ABeforeAll

BAfterEach

CAfterAll

DTest

Attempts:

3 left

💡 Hint

Common Mistakes

Using @AfterEach instead of @AfterAll

Not making the method static

The @AfterAll annotation marks a method to run once after all tests in the class have finished.

2fill in blank

medium

Complete the code to ensure the @AfterAll method is static as required by JUnit 5.

JUnit

import org.junit.jupiter.api.AfterAll;

public class DatabaseTest {

    @AfterAll
    [1] closeConnection() {
        System.out.println("Closing DB connection");
    }
}

Drag options to blanks, or click blank then click option'

Astatic void

Bvoid

Cpublic void

Dprivate void

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting static keyword

Making method non-static with @AfterAll

In JUnit 5, @AfterAll methods must be static unless using a test instance lifecycle that allows non-static.

3fill in blank

hard

Fix the error in the @AfterAll method declaration to make it valid in JUnit 5.

JUnit

import org.junit.jupiter.api.AfterAll;

public class ServiceTest {

    @AfterAll
    public [1] cleanup() {
        System.out.println("Service cleanup");
    }
}

Drag options to blanks, or click blank then click option'

Avoid

Bint

CString

Dboolean

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-void return types

Returning values from @AfterAll methods

@AfterAll methods must have void return type because they are lifecycle hooks, not test methods.

4fill in blank

hard

Fill both blanks to correctly define an @AfterAll method that prints a message and is static.

JUnit

import org.junit.jupiter.api.AfterAll;

public class NetworkTest {

    @AfterAll
    [1] [2] cleanupNetwork() {
        System.out.println("Network cleanup done");
    }
}

Drag options to blanks, or click blank then click option'

Astatic

Bvoid

Cpublic

Dprivate

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting static keyword

Using non-void return type

The method must be static and have void return type to be a valid @AfterAll method.

5fill in blank

hard

Fill all three blanks to create a valid @AfterAll method with public visibility, static modifier, and void return type.

JUnit

import org.junit.jupiter.api.AfterAll;

public class FileTest {

    @AfterAll
    [1] [2] [3] cleanupFiles() {
        System.out.println("Files cleaned up");
    }
}

Drag options to blanks, or click blank then click option'

Apublic

Bstatic

Cvoid

Dfinal

Attempts:

3 left

💡 Hint

Common Mistakes

Using private or default visibility

Omitting static keyword

Using non-void return type

A valid @AfterAll method is usually public, static, and void to be accessible and run after all tests.

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