@Nested inner classes in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of nested test execution order

Consider the following JUnit 5 test class with @Nested inner classes. What will be the order of printed output when running the tests?

JUnit

import org.junit.jupiter.api.*;

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

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

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

    @Nested
    class InnerTest {

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

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

A

BeforeAll Outer
BeforeAll Inner
Outer Test
Inner Test

B

BeforeAll Outer
BeforeAll Inner
Inner Test
Outer Test

C

BeforeAll Inner
BeforeAll Outer
Outer Test
Inner Test

D

BeforeAll Outer
Outer Test
BeforeAll Inner
Inner Test

💡 Hint

Remember that @BeforeAll in nested classes runs after the outer @BeforeAll and before tests in that nested class.

The @BeforeAll method in the outer class runs first, printing "BeforeAll Outer". Then the outer test runs, printing "Outer Test". Next, the nested class's @BeforeAll runs before its tests, printing "BeforeAll Inner". Finally, the nested test runs, printing "Inner Test".

❓ assertion

intermediate

Correct assertion for nested test result

Given a nested test class that sets a boolean flag to true in its test method, which assertion correctly verifies the flag is true after the nested test runs?

JUnit

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

public class FlagTest {
    boolean flag = false;

    @Nested
    class Inner {
        @Test
        void setFlag() {
            flag = true;
        }
    }
}

A assertEquals(true, flag);

B assertTrue(flag);

C assertFalse(flag);

D assertNull(flag);

💡 Hint

Use the assertion that checks if a boolean is true.

assertTrue(flag); is the correct assertion to verify that the boolean flag is true after the nested test sets it.

🔧 Debug

advanced

Identify the cause of @BeforeAll not running in nested class

Why does the @BeforeAll method inside the nested class not execute when running the tests?

JUnit

import org.junit.jupiter.api.*;

public class SampleTest {

    @Nested
    class Inner {

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

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

A The @BeforeAll method must be annotated with @Test as well.

B @BeforeAll methods are ignored in nested classes by design.

C @BeforeAll methods in nested classes must be static unless the outer class uses @TestInstance(Lifecycle.PER_CLASS).

D The nested class must be public for @BeforeAll to run.

💡 Hint

Check the method modifiers and test instance lifecycle.

In JUnit 5, @BeforeAll methods must be static by default. For nested classes, if the outer class does not use @TestInstance(Lifecycle.PER_CLASS), the @BeforeAll method inside the nested class must be static. Otherwise, it will not run.

🧠 Conceptual

advanced

Purpose of @Nested in JUnit 5

What is the main purpose of using @Nested inner classes in JUnit 5 tests?

A To group related tests together and provide better test organization and readability.

B To run tests in parallel automatically.

C To allow tests to share static variables only.

D To disable tests temporarily without removing them.

💡 Hint

Think about how nested classes help structure tests.

@Nested allows grouping related tests inside inner classes, improving organization and readability by logically grouping tests that share setup or context.

❓ framework

expert

Behavior of @Nested with @TestInstance(Lifecycle.PER_CLASS)

In a JUnit 5 test class annotated with @TestInstance(Lifecycle.PER_CLASS), how does this affect the execution of @BeforeAll methods in @Nested inner classes?

A @BeforeAll methods in nested classes can be non-static and will run once per class instance.

B @BeforeAll methods must still be static even with @TestInstance(Lifecycle.PER_CLASS).

C @BeforeAll methods are ignored in nested classes when using @TestInstance(Lifecycle.PER_CLASS).

D @BeforeAll methods run before each test method regardless of static or instance.

💡 Hint

Consider how test instance lifecycle changes method requirements.

When using @TestInstance(Lifecycle.PER_CLASS), JUnit creates one instance of the test class per class, allowing @BeforeAll methods to be non-static. This applies to nested classes as well, so their @BeforeAll methods can be instance methods and run once per class instance.