Nested class lifecycle in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to use the correct annotation for a nested test class lifecycle.

JUnit

import org.junit.jupiter.api.*;

@TestInstance(TestInstance.Lifecycle.[1])
@Nested
class InnerTest {
    @Test
    void testMethod() {
        Assertions.assertTrue(true);
    }
}

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

APER_CLASS

BSINGLETON

CSTATIC

DPER_METHOD

Attempts:

3 left

💡 Hint

Common Mistakes

Using PER_CLASS lifecycle without understanding it creates one instance for all tests.

Confusing PER_METHOD with PER_CLASS lifecycle.

By default, nested test classes in JUnit use PER_METHOD lifecycle, which creates a new instance for each test method.

2fill in blank

medium

Complete the code to annotate a nested test class that shares the same instance for all tests.

JUnit

import org.junit.jupiter.api.*;

@TestInstance(TestInstance.Lifecycle.[1])
@Nested
class SharedInstanceTest {
    int counter = 0;

    @Test
    void testIncrement() {
        counter++;
        Assertions.assertTrue(counter > 0);
    }
}

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

ASTATIC

BPER_CLASS

CSINGLETON

DPER_METHOD

Attempts:

3 left

💡 Hint

Common Mistakes

Using PER_METHOD lifecycle which creates a new instance for each test, so state is not shared.

Confusing SINGLETON or STATIC which are not valid lifecycle options.

Using PER_CLASS lifecycle means the same instance of the nested test class is used for all test methods, allowing state sharing.

3fill in blank

hard

Fix the error in the nested test class lifecycle annotation to make the code compile.

JUnit

import org.junit.jupiter.api.*;

@TestInstance(TestInstance.Lifecycle.[1])
@Nested
class ErrorTest {
    @Test
    void testSomething() {
        Assertions.assertEquals(1, 1);
    }
}

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

APER_CLASS

BINSTANCE

CPER_METHOD

DSINGLETON

Attempts:

3 left

💡 Hint

Common Mistakes

Using invalid lifecycle values like INSTANCE or SINGLETON.

Misspelling lifecycle enum constants.

The option INSTANCE is invalid. The correct lifecycle options are PER_CLASS or PER_METHOD. Here, PER_CLASS is the fix to compile.

4fill in blank

hard

Fill both blanks to create a nested test class with a per-class lifecycle and a setup method that runs once before all tests.

JUnit

import org.junit.jupiter.api.*;

@TestInstance(TestInstance.Lifecycle.[1])
@Nested
class SetupTest {

    @Before[2]
    void init() {
        System.out.println("Setup before all tests");
    }

    @Test
    void testOne() {
        Assertions.assertTrue(true);
    }
}

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

APER_CLASS

BPER_METHOD

CAll

DEach

Attempts:

3 left

💡 Hint

Common Mistakes

Using PER_METHOD lifecycle with non-static @BeforeAll causes errors.

Using @BeforeEach instead of @BeforeAll for setup before all tests.

Using PER_CLASS lifecycle allows the use of @BeforeAll on non-static methods in nested classes.

5fill in blank

hard

Fill all three blanks to define a nested test class with per-class lifecycle, a non-static @BeforeAll method, and a test method that asserts a counter increments.

JUnit

import org.junit.jupiter.api.*;

@TestInstance(TestInstance.Lifecycle.[1])
@Nested
class CounterTest {
    int counter = 0;

    @Before[2]
    void setup() {
        counter = 1;
    }

    @Test
    void testIncrement() {
        counter[3];
        Assertions.assertEquals(2, counter);
    }
}

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

APER_METHOD

BPER_CLASS

C++

DAll

Attempts:

3 left

💡 Hint

Common Mistakes

Using PER_METHOD lifecycle with non-static @BeforeAll causes errors.

Using -- instead of ++ causing the counter to decrease.

Using @BeforeEach instead of @BeforeAll for setup before all tests.

With PER_CLASS lifecycle, @BeforeAll can be non-static. The counter is incremented with ++ to reach 2.

Practice

1. In JUnit 5, what is the purpose of using a @Nested class inside a test class?

easy

A. To group related tests together for better organization

B. To run tests in parallel automatically

C. To disable tests temporarily

D. To create a separate test suite file

Solution

1. Step 1: Understand the role of @Nested

   The @Nested annotation allows grouping related test methods inside inner classes to organize tests logically.

2. Step 2: Compare other options

   The other options describe unrelated features: disabling tests temporarily, running tests in parallel automatically, and creating separate test suite files, which are not the purpose of @Nested.

3. Final Answer:

   To group related tests together for better organization -> Option A

4. Quick Check:

   @Nested groups tests = C [OK]

Hint: Remember: @Nested groups tests inside main class [OK]

Common Mistakes:

• Thinking @Nested runs tests in parallel
• Confusing @Nested with @Disabled
• Assuming @Nested creates separate test files

2. Which lifecycle annotation is used to run a method once before all tests in a @Nested class?

easy

A. @BeforeAll

B. @AfterAll

C. @AfterEach

D. @BeforeEach

Solution

1. Step 1: Identify lifecycle annotations for nested classes

   In JUnit 5, @BeforeAll runs once before all tests in the class, including nested classes if used inside them.

2. Step 2: Differentiate from other annotations

   @BeforeEach runs before each test method, not once; @AfterEach and @AfterAll run after tests, so they don't fit the requirement.

3. Final Answer:

   @BeforeAll -> Option A

4. Quick Check:

   Run once before all tests = @BeforeAll [OK]

Hint: Before all tests in nested class use @BeforeAll [OK]

Common Mistakes:

• Using @BeforeEach instead of @BeforeAll for once-only setup
• Confusing @AfterAll with setup annotations
• Not placing @BeforeAll inside nested class

3. Consider this JUnit 5 test structure:

class OuterTest {
  @BeforeAll
  static void setupOuter() { System.out.println("Outer setup"); }

  @Nested
  class InnerTest {
    @BeforeAll
    static void setupInner() { System.out.println("Inner setup"); }

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

What will be the order of printed lines when running testOne()?

medium

A. Inner setup\nOuter setup\nTest one

B. Outer setup\nInner setup\nTest one

C. Outer setup\nTest one\nInner setup

D. Test one\nOuter setup\nInner setup

Solution

1. Step 1: Understand lifecycle order in nested classes

   The @BeforeAll in the outer class runs first, then the @BeforeAll in the nested class, followed by the test method.

2. Step 2: Trace the print statements

   First prints "Outer setup", then "Inner setup", then "Test one" as per the method calls.

3. Final Answer:

   Outer setup\nInner setup\nTest one -> Option B

4. Quick Check:

   Outer before all, then inner before all, then test [OK]

Hint: Outer @BeforeAll runs before nested @BeforeAll [OK]

Common Mistakes:

• Assuming nested @BeforeAll runs before outer
• Mixing order of test and setup prints
• Forgetting static requirement for @BeforeAll in nested

4. Given this nested test class, what is the error that prevents @BeforeAll from running?

class OuterTest {
  @Nested
  class InnerTest {
    @BeforeAll
    void setup() { System.out.println("Setup"); }

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

medium

A. Missing @Test annotation on setup method

B. @BeforeAll cannot be used inside nested classes

C. @BeforeAll method must be static in nested classes

D. InnerTest class must be static

Solution

1. Step 1: Check @BeforeAll method requirements in nested classes

   In JUnit 5, @BeforeAll methods inside nested classes must be static unless the nested class is annotated with @TestInstance(Lifecycle.PER_CLASS).

2. Step 2: Analyze the given code

   The @BeforeAll method is non-static and the nested class is not annotated with @TestInstance, so this causes a runtime error.

3. Final Answer:

   @BeforeAll method must be static in nested classes -> Option C

4. Quick Check:

   @BeforeAll in nested must be static unless @TestInstance used [OK]

Hint: @BeforeAll in nested classes must be static [OK]

Common Mistakes:

• Thinking @BeforeAll cannot be used in nested classes
• Forgetting static keyword on @BeforeAll method
• Confusing @BeforeAll with @BeforeEach

5. You want to run a setup method once before all tests in both the outer and nested classes without making the nested class static. Which approach correctly achieves this in JUnit 5?

hard

A. Move all tests to the outer class and remove nested classes

B. Make the nested class static and keep @BeforeAll method static

C. Use @BeforeEach instead of @BeforeAll in nested class

D. Annotate the nested class with @TestInstance(Lifecycle.PER_CLASS) and make the @BeforeAll method non-static

Solution

1. Step 1: Understand static requirement for @BeforeAll in nested classes

   By default, @BeforeAll methods in nested classes must be static because nested classes are instance classes.

2. Step 2: Use @TestInstance(Lifecycle.PER_CLASS) to allow non-static @BeforeAll

   Annotating the nested class with @TestInstance(Lifecycle.PER_CLASS) changes lifecycle so @BeforeAll can be non-static, allowing setup without static nested class.

3. Step 3: Evaluate other options

   Make the nested class static and keep @BeforeAll method static requires static nested class, which is not desired. Use @BeforeEach instead of @BeforeAll in nested class changes setup frequency. Move all tests to the outer class and remove nested classes removes nested structure, losing organization.

4. Final Answer:

   Annotate the nested class with @TestInstance(Lifecycle.PER_CLASS) and make the @BeforeAll method non-static -> Option D

5. Quick Check:

   @TestInstance(PER_CLASS) allows non-static @BeforeAll in nested [OK]

Hint: Use @TestInstance(PER_CLASS) to avoid static @BeforeAll in nested [OK]

Common Mistakes:

• Making nested class static when not needed
• Using @BeforeEach instead of @BeforeAll for once-only setup
• Removing nested classes to fix lifecycle issues