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