Nested class lifecycle in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

JUnit Nested Class Lifecycle: Execution Order

Consider the following JUnit 5 test code with nested classes. What is the order of printed output when the test suite runs?

JUnit

import org.junit.jupiter.api.*;

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

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

    @BeforeEach
    void beforeEachOuter() {
        System.out.println("Outer beforeEach");
    }

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

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

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

        @BeforeEach
        void beforeEachInner() {
            System.out.println("Inner beforeEach");
        }

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

A

Outer beforeAll
Inner beforeAll
Outer beforeEach
Outer test
Outer beforeEach
Inner beforeEach
Inner test

B

Outer beforeAll
Outer beforeEach
Outer test
Outer beforeEach
Inner beforeEach
Inner test
Inner beforeAll

C

Outer beforeAll
Outer beforeEach
Outer test
Inner beforeAll
Outer beforeEach
Inner beforeEach
Inner test

D

Inner beforeAll
Outer beforeAll
Outer beforeEach
Outer test
Outer beforeEach
Inner beforeEach
Inner test

💡 Hint

Remember that @BeforeAll in nested classes runs after the outer class's @BeforeAll, but before any tests in that nested class.

JUnit 5 runs @BeforeAll methods in the outer class first, then in the nested class before any tests in that nested class. @BeforeEach methods run before each test, starting from outer to inner. So the order is:

• Outer beforeAll
• Inner beforeAll
• Outer beforeEach
• Outer test
• Outer beforeEach
• Inner beforeEach
• Inner test

❓ assertion

intermediate

Correct Assertion for Nested Test Execution Count

You want to assert that exactly two tests run: one in the outer class and one in the nested class. Which assertion correctly verifies this using JUnit 5's TestInfo?

JUnit

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

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

    int testCount = 0;

    @Test
    void outerTest() {
        testCount++;
    }

    @Nested
    class InnerTest {

        @Test
        void innerTest() {
            testCount++;
        }
    }

    @AfterAll
    void afterAll() {
        // Assertion here
    }
}

A assertEquals(2, testCount);

B assertTrue(testCount == 1);

C assertNotNull(testCount);

D assertFalse(testCount > 2);

💡 Hint

You want to check the exact number of tests run, not just a condition.

The variable testCount increments once per test method run. Since there is one test in the outer class and one in the nested class, the total should be exactly 2. The assertion assertEquals(2, testCount); checks this precisely.

🔧 Debug

advanced

Fix the Lifecycle Annotation Misuse in Nested Class

This JUnit 5 nested test class fails to run the @BeforeAll method inside the nested class. What is the cause?

JUnit

import org.junit.jupiter.api.*;

public class OuterTest {

    @Nested
    class InnerTest {

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

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

A JUnit 5 does not support @BeforeAll in nested classes.

B The @BeforeAll method must be public to run in nested classes.

C The nested class must be static for @BeforeAll to run.

D The @BeforeAll method in the nested class must be static or the nested class must use @TestInstance(Lifecycle.PER_CLASS).

💡 Hint

Check JUnit 5 rules for @BeforeAll in non-static nested classes.

In JUnit 5, @BeforeAll methods in nested classes must be static unless the nested class is annotated with @TestInstance(Lifecycle.PER_CLASS). Otherwise, the method will not run and the test lifecycle is broken.

🧠 Conceptual

advanced

Understanding Nested Class Test Instance Lifecycle

In JUnit 5, what is the default test instance lifecycle for nested test classes if not explicitly annotated?

A The nested class inherits the lifecycle of the outer class automatically.

B A single instance is shared for all tests (PER_CLASS lifecycle).

C Each test method gets a new instance (PER_METHOD lifecycle).

D Nested classes do not have a lifecycle and are instantiated once.

💡 Hint

Think about the default behavior of JUnit 5 test instances.

By default, JUnit 5 creates a new instance of the test class for each test method (PER_METHOD lifecycle). This applies to nested classes as well unless overridden by @TestInstance(Lifecycle.PER_CLASS).

❓ framework

expert

Configuring Nested Class Lifecycle for Shared State

You want to share state between tests in a nested class without using static fields. Which JUnit 5 configuration achieves this correctly?

A Annotate the outer class with @TestInstance(TestInstance.Lifecycle.PER_CLASS) only.

B Annotate the nested class with @TestInstance(TestInstance.Lifecycle.PER_CLASS).

C Use @BeforeAll static methods to initialize shared state in the nested class.

D Make the nested class static and use static fields for shared state.

💡 Hint

Sharing state between tests requires a single instance of the test class.

Annotating the nested class with @TestInstance(TestInstance.Lifecycle.PER_CLASS) tells JUnit to create one instance of the nested class for all its tests, allowing instance fields to hold shared state. Static fields or methods are not required.