Execution order of lifecycle methods in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

JUnit Lifecycle Method Execution Order

What is the order of printed output when this JUnit 5 test class runs?

JUnit

import org.junit.jupiter.api.*;

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

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

    @BeforeEach
    void beforeEach() {
        System.out.print("B");
    }

    @Test
    void test1() {
        System.out.print("C");
    }

    @Test
    void test2() {
        System.out.print("D");
    }

    @AfterEach
    void afterEach() {
        System.out.print("E");
    }

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

A ABCEDECF

B ABCEBDEF

C ABCEDEDF

D FEDBECBA

💡 Hint

Remember @BeforeAll and @AfterAll run once per class, @BeforeEach and @AfterEach run before and after each test.

The order is:

• BeforeAll runs once: prints 'A'
• BeforeEach before test1: prints 'B'
• test1 runs: prints 'C'
• AfterEach after test1: prints 'E'
• BeforeEach before test2: prints 'B'
• test2 runs: prints 'D'
• AfterEach after test2: prints 'E'
• AfterAll runs once: prints 'F'

Combined output: ABCEBDEF

❓ assertion

intermediate

Correct Assertion for Lifecycle Method Calls

Given a test class with @BeforeEach and @AfterEach methods that increment counters, which assertion correctly verifies that @BeforeEach ran twice after two tests?

JUnit

import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

public class CounterTest {
    static int beforeEachCount = 0;

    @BeforeEach
    void beforeEach() {
        beforeEachCount++;
    }

    @Test
    void testOne() {}

    @Test
    void testTwo() {}
}

A assertTrue(beforeEachCount == 1);

B assertNotNull(beforeEachCount);

C assertFalse(beforeEachCount > 2);

D assertEquals(2, beforeEachCount);

💡 Hint

Each test triggers @BeforeEach once.

There are two tests, so @BeforeEach runs twice, incrementing beforeEachCount to 2.

Option D correctly asserts the count is 2.

Other options either check wrong values or irrelevant conditions.

🔧 Debug

advanced

Identify the Lifecycle Annotation Causing the Error

This JUnit 5 test class fails to run with an error. Which lifecycle annotation is incorrectly used causing the failure?

JUnit

import org.junit.jupiter.api.*;

public class ErrorTest {

    @BeforeAll
    static void setup() {
        System.out.println("Setup");
    }

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

A @BeforeAll method must return a value

B @Test method must be static

C @BeforeAll method must be static or the test class annotated with @TestInstance(Lifecycle.PER_CLASS)

D @Test method must have parameters

💡 Hint

Check JUnit 5 rules for @BeforeAll method signature.

In JUnit 5, @BeforeAll methods must be static unless the test class uses @TestInstance(Lifecycle.PER_CLASS).

Here, setup() is non-static and no @TestInstance annotation is present, causing the error.

🧠 Conceptual

advanced

Understanding @TestInstance Lifecycle Impact

How does annotating a JUnit 5 test class with @TestInstance(Lifecycle.PER_CLASS) affect the execution of lifecycle methods?

A It allows @BeforeAll and @AfterAll methods to be non-static and run once per class instance

B It makes @BeforeEach and @AfterEach methods run only once for all tests

C It forces all test methods to be static

D It disables @AfterAll methods

💡 Hint

Think about instance creation and static method requirements.

@TestInstance(Lifecycle.PER_CLASS) creates one instance of the test class for all tests.

This allows @BeforeAll and @AfterAll methods to be non-static because they run on the single instance.

Other options are incorrect because @BeforeEach/@AfterEach still run before/after each test, @AfterAll is not disabled, and test methods do not need to be static.

❓ framework

expert

Order of Execution in Nested Test Classes with Lifecycle Methods

Consider this JUnit 5 test class with a nested class. What is the correct order of printed output when running all tests?

JUnit

import org.junit.jupiter.api.*;

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

    @BeforeAll
    void outerBeforeAll() {
        System.out.print("1");
    }

    @BeforeEach
    void outerBeforeEach() {
        System.out.print("2");
    }

    @Test
    void outerTest() {
        System.out.print("3");
    }

    @Nested
    @TestInstance(TestInstance.Lifecycle.PER_CLASS)
    class InnerTest {

        @BeforeAll
        void innerBeforeAll() {
            System.out.print("4");
        }

        @BeforeEach
        void innerBeforeEach() {
            System.out.print("5");
        }

        @Test
        void innerTest() {
            System.out.print("6");
        }

        @AfterEach
        void innerAfterEach() {
            System.out.print("7");
        }

        @AfterAll
        void innerAfterAll() {
            System.out.print("8");
        }
    }

    @AfterEach
    void outerAfterEach() {
        System.out.print("9");
    }

    @AfterAll
    void outerAfterAll() {
        System.out.print("0");
    }
}

A 123942567980

B 123942567979

C 123942567981

D 247885135960

💡 Hint

Remember lifecycle methods run in order: outer beforeAll, outer beforeEach, test, afterEach, then nested class lifecycle methods.

Execution order:

1. Outer @BeforeAll: prints '1'
2. Outer @BeforeEach before outerTest: '2'
3. outerTest: '3'
4. Outer @AfterEach after outerTest: '9'
5. Inner @BeforeAll: '4'
6. Outer @BeforeEach before innerTest: '2'
7. Inner @BeforeEach: '5'
8. innerTest: '6'
9. Inner @AfterEach: '7'
10. Outer @AfterEach after innerTest: '9'
11. Inner @AfterAll: '8'
12. Outer @AfterAll: '0'

Combined output: 123942567980

Practice

1. In JUnit 5, which lifecycle method runs exactly once before any test methods in the class?

easy

A. @AfterAll

B. @BeforeEach

C. @AfterEach

D. @BeforeAll

Solution

1. Step 1: Understand lifecycle annotations

   @BeforeAll is designed to run once before all tests in the class.

2. Step 2: Compare with other annotations

   @BeforeEach runs before each test, @AfterEach after each test, and @AfterAll once after all tests.

3. Final Answer:

   @BeforeAll -> Option D

4. Quick Check:

   @BeforeAll runs once before all tests [OK]

Hint: Remember: All = once before all tests [OK]

Common Mistakes:

• Confusing @BeforeEach with @BeforeAll
• Thinking @AfterAll runs before tests
• Mixing up @AfterEach and @BeforeEach

2. Which of the following is the correct syntax to define a method that runs after each test in JUnit 5?

easy

A. @AfterEach
void cleanup() {}

B. @AfterAll
void cleanup() {}

C. @BeforeEach
void cleanup() {}

D. @BeforeAll
void cleanup() {}

Solution

1. Step 1: Identify the annotation for after each test

   @AfterEach is the annotation that runs a method after every test method.

2. Step 2: Check method syntax

   The method should be void and can have any name, here 'cleanup()' is valid.

3. Final Answer:

   @AfterEach void cleanup() {} -> Option A

4. Quick Check:

   @AfterEach runs after each test method [OK]

Hint: AfterEach means after every single test method [OK]

Common Mistakes:

• Using @AfterAll instead of @AfterEach
• Confusing @BeforeEach with @AfterEach
• Missing void return type

3. Consider the following JUnit 5 test class:

@BeforeAll
static void initAll() { System.out.println("InitAll"); }
@BeforeEach
void init() { System.out.println("Init"); }
@Test
void testOne() { System.out.println("TestOne"); }
@Test
void testTwo() { System.out.println("TestTwo"); }
@AfterEach
void tearDown() { System.out.println("TearDown"); }
@AfterAll
static void tearDownAll() { System.out.println("TearDownAll"); }

What is the correct order of printed lines when running this test class?

medium

A. InitAll, Init, TestOne, TearDown, Init, TestTwo, TearDown, TearDownAll

B. Init, InitAll, TestOne, TearDown, TestTwo, Init, TearDownAll

C. InitAll, Init, TestOne, Init, TestTwo, TearDown, TearDownAll, TearDown

D. InitAll, TestOne, Init, TearDown, Init, TestTwo, TearDown, TearDownAll

Solution

1. Step 1: Understand lifecycle method order

   @BeforeAll runs once before all tests, then for each test @BeforeEach runs, test runs, then @AfterEach runs. Finally, @AfterAll runs once after all tests.

2. Step 2: Apply to given methods

   Output order: InitAll (once), then for testOne: Init, TestOne, TearDown; for testTwo: Init, TestTwo, TearDown; finally TearDownAll.

3. Final Answer:

   InitAll, Init, TestOne, TearDown, Init, TestTwo, TearDown, TearDownAll -> Option A

4. Quick Check:

   BeforeAll once, BeforeEach-Test-AfterEach per test, AfterAll once [OK]

Hint: Remember: BeforeAll/AfterAll once, BeforeEach/AfterEach per test [OK]

Common Mistakes:

• Mixing order of BeforeAll and BeforeEach
• Forgetting AfterEach runs after each test
• Placing AfterAll before AfterEach

4. Given the following JUnit 5 test class snippet, identify the error:

@BeforeAll
void setupAll() { System.out.println("Setup all"); }
@Test
void testMethod() { System.out.println("Test"); }

What is the problem with this code?

medium

A. @BeforeAll method must return boolean.

B. @BeforeAll method must be static.

C. @BeforeAll method cannot have a body.

D. @BeforeAll method must be private.

Solution

1. Step 1: Recall @BeforeAll requirements

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

2. Step 2: Check method signature

   The method 'setupAll' is not static, which causes a runtime error or test failure.

3. Final Answer:

   @BeforeAll method must be static. -> Option B

4. Quick Check:

   @BeforeAll requires static method by default [OK]

Hint: @BeforeAll methods are static unless configured otherwise [OK]

Common Mistakes:

• Making @BeforeAll non-static without lifecycle config
• Assuming @BeforeAll can be private
• Thinking @BeforeAll must return a value

5. You want to open a database connection once before all tests and close it once after all tests in a JUnit 5 test class. You also want to reset some data before each test and clean up after each test. Which combination of lifecycle methods should you use?

hard

A. @BeforeAll for resetting data, @AfterAll for cleanup, @BeforeEach for opening connection, @AfterEach for closing connection

B. @BeforeEach for opening connection, @AfterEach for closing connection, @BeforeAll for resetting data, @AfterAll for cleanup

C. @BeforeAll for opening connection, @AfterAll for closing connection, @BeforeEach for resetting data, @AfterEach for cleanup

D. @BeforeEach for resetting data, @AfterEach for cleanup, @BeforeAll for opening connection, @AfterAll for closing connection

Solution

1. Step 1: Assign tasks to lifecycle methods

   Opening and closing the database connection should happen once, so use @BeforeAll and @AfterAll.

2. Step 2: Use per-test methods for data reset and cleanup

   Resetting data and cleaning up should happen before and after each test, so use @BeforeEach and @AfterEach.

3. Final Answer:

   @BeforeAll for opening connection, @AfterAll for closing connection, @BeforeEach for resetting data, @AfterEach for cleanup -> Option C

4. Quick Check:

   Once methods for setup/teardown, each methods for per-test tasks [OK]

Hint: Once = BeforeAll/AfterAll, each test = BeforeEach/AfterEach [OK]

Common Mistakes:

• Opening connection before each test unnecessarily
• Resetting data only once before all tests
• Closing connection after each test causing overhead