@Nested inner classes in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a nested test class using JUnit 5.

JUnit

import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

public class CalculatorTest {

    @[1]
    class AdditionTests {

        @Test
        void testAddPositiveNumbers() {
            // test code here
        }
    }
}

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

ATest

BNested

CBeforeEach

DDisplayName

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Test instead of @Nested for inner classes.

Forgetting to import the @Nested annotation.

The @Nested annotation is used to declare an inner test class in JUnit 5.

2fill in blank

medium

Complete the code to run a test method inside a nested class.

JUnit

import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

public class StringUtilsTest {

    @Nested
    class TrimTests {

        @[1]
        void testTrimSpaces() {
            // test code here
        }
    }
}

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

ATest

BBeforeEach

CAfterEach

DDisabled

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Nested on methods instead of classes.

Forgetting to annotate test methods with @Test.

The @Test annotation marks a method as a test method in JUnit 5.

3fill in blank

hard

Fix the error in the nested test class declaration.

JUnit

import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

public class MathTest {

    @Nested
    static class [1] {

        @Test
        void testMultiply() {
            // test code here
        }
    }
}

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

AMultiplicationTests

BMultiplyTests

CMultiplicationTest

DMultiplyTest

Attempts:

3 left

💡 Hint

Common Mistakes

Using static modifier on nested test classes (JUnit 5 requires non-static).

Using singular form for class name which is less clear.

Nested test classes must be non-static in JUnit 5, but the question asks to fix the error by naming the class properly. The class name should be a plural form to indicate multiple tests, so 'MultiplicationTests' is best practice.

4fill in blank

hard

Fill both blanks to correctly declare and annotate a nested test class and its test method.

JUnit

import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

public class ListTest {

    @[1]
    class RemoveTests {

        @[2]
        void testRemoveByIndex() {
            // test code here
        }
    }
}

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

ANested

BTest

CBeforeEach

DAfterEach

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping @Test and @Nested annotations.

Forgetting to annotate either the class or the method.

The nested class must be annotated with @Nested and the test method with @Test to run properly.

5fill in blank

hard

Fill all three blanks to create a nested test class with a test method and a display name annotation.

JUnit

import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;

public class CalculatorTest {

    @[1]
    @[2]("Addition operations")
    class AdditionTests {

        @[3]
        void testAddPositiveNumbers() {
            // test code here
        }
    }
}

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

ANested

BDisplayName

CTest

DBeforeEach

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting @DisplayName on the nested class.

Not annotating the test method with @Test.

The nested class is annotated with @Nested and @DisplayName to describe the group, and the test method is annotated with @Test.

Practice

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

easy

A. To group related test methods together for better organization

B. To run tests in parallel automatically

C. To replace the main test class entirely

D. To create test methods without annotations

Solution

1. Step 1: Understand the role of @Nested

   @Nested is used to group related tests inside a main test class, improving structure and readability.

2. Step 2: Compare options

   Only To group related test methods together for better organization correctly describes grouping related tests. Other options describe unrelated or incorrect behaviors.

3. Final Answer:

   To group related test methods together for better organization -> Option A

4. Quick Check:

   @Nested groups tests = A [OK]

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

Common Mistakes:

• Thinking @Nested runs tests in parallel
• Assuming @Nested replaces main test class
• Believing @Nested removes need for annotations

2. Which of the following is the correct way to declare a nested test class in JUnit 5?

easy

A. public class NestedTests { @Test void testMethod() {} }

B. @Test class InnerTests { void testMethod() {} }

C. @Nested class InnerTests { @Test void testMethod() {} }

D. class InnerTests { @Nested void testMethod() {} }

Solution

1. Step 1: Identify correct @Nested usage

   A nested test class must be annotated with @Nested and contain test methods annotated with @Test.

2. Step 2: Check each option

   @Nested class InnerTests { @Test void testMethod() {} } correctly shows @Nested on class and @Test on method. Others misuse annotations or omit them.

3. Final Answer:

   @Nested class InnerTests { @Test void testMethod() {} } -> Option C

4. Quick Check:

   @Nested on class + @Test on method = B [OK]

Hint: @Nested annotates class, @Test annotates methods [OK]

Common Mistakes:

• Putting @Test on class instead of method
• Missing @Nested on inner class
• Annotating methods with @Nested

3. Consider the following JUnit 5 test code snippet:

class CalculatorTest {
  @BeforeEach void setup() { System.out.println("Setup main"); }

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

  @Nested
  class MultiplyTests {
    @BeforeEach void setup() { System.out.println("Setup nested"); }

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

What will be the output when running the testMultiply method?

medium

A. Setup main
Test multiply

B. Setup nested
Test multiply

C. Test multiply

D. Setup main
Setup nested
Test multiply

Solution

1. Step 1: Understand @BeforeEach in nested classes

   Both the outer and nested @BeforeEach methods run before a nested test method.

2. Step 2: Trace method calls for testMultiply

   First, outer setup prints "Setup main", then nested setup prints "Setup nested", finally testMultiply prints "Test multiply".

3. Final Answer:

   Setup main Setup nested Test multiply -> Option D

4. Quick Check:

   Outer + nested setup run before nested test = D [OK]

Hint: Both outer and nested @BeforeEach run before nested tests [OK]

Common Mistakes:

• Assuming only nested setup runs
• Ignoring outer setup for nested tests
• Expecting only test method output

4. Given the following JUnit 5 test code:

class OuterTest {
  @Nested
  class InnerTest {
    @Test void testSomething() {}
  }

  @Test void testOuter() {}
}

Which of the following is a problem that will cause the tests NOT to run as expected?

medium

A. InnerTest class is not declared static

B. No problem; tests will run correctly

C. InnerTest class is missing @Test annotation

D. InnerTest class is not public

Solution

1. Step 1: Check requirements for @Nested classes

   @Nested classes must be non-static inner classes and can have any visibility (default or public).

2. Step 2: Analyze given code

   InnerTest is a non-static inner class with @Nested annotation and contains a @Test method. OuterTest has a @Test method too.

3. Final Answer:

   No problem; tests will run correctly -> Option B

4. Quick Check:

   @Nested inner classes run fine non-static = C [OK]

Hint: Nested classes should be non-static; visibility is flexible [OK]

Common Mistakes:

• Thinking nested classes must be static
• Expecting @Test on nested class itself
• Assuming nested class must be public

5. You want to organize tests for a Calculator class using JUnit 5. You decide to use @Nested classes to separate addition and subtraction tests. Which of the following code snippets correctly applies @Nested classes with proper setup methods so that the main setup runs before each nested test setup?

hard

A. class CalculatorTest {
@BeforeEach void setup() { System.out.println("Main setup"); }

@Nested
class AddTests {
@BeforeEach void setup() { System.out.println("Add setup"); }
@Test void testAdd() {}
}

@Nested
class SubtractTests {
@BeforeEach void setup() { System.out.println("Subtract setup"); }
@Test void testSubtract() {}
}
}

B. class CalculatorTest {
@Nested
class AddTests {
@BeforeEach void setup() { System.out.println("Add setup"); }
@Test void testAdd() {}
}

@Nested
class SubtractTests {
@BeforeEach void setup() { System.out.println("Subtract setup"); }
@Test void testSubtract() {}
}
@BeforeEach void setup() { System.out.println("Main setup"); }
}

C. class CalculatorTest {
@BeforeAll static void setup() { System.out.println("Main setup"); }

@Nested
class AddTests {
@BeforeEach void setup() { System.out.println("Add setup"); }
@Test void testAdd() {}
}

@Nested
class SubtractTests {
@BeforeEach void setup() { System.out.println("Subtract setup"); }
@Test void testSubtract() {}
}
}

D. class CalculatorTest {
@BeforeEach void setup() { System.out.println("Main setup"); }

@Nested
static class AddTests {
@BeforeEach void setup() { System.out.println("Add setup"); }
@Test void testAdd() {}
}

@Nested
static class SubtractTests {
@BeforeEach void setup() { System.out.println("Subtract setup"); }
@Test void testSubtract() {}
}
}

Solution

1. Step 1: Understand setup execution order

   @BeforeEach in outer class runs before each nested class's @BeforeEach method for every test.

2. Step 2: Analyze options for correct setup and class structure

   class CalculatorTest { @BeforeEach void setup() { System.out.println("Main setup"); } @Nested class AddTests { @BeforeEach void setup() { System.out.println("Add setup"); } @Test void testAdd() {} } @Nested class SubtractTests { @BeforeEach void setup() { System.out.println("Subtract setup"); } @Test void testSubtract() {} } } has non-static nested classes and main @BeforeEach before nested @BeforeEach, ensuring main setup runs first. class CalculatorTest { @Nested class AddTests { @BeforeEach void setup() { System.out.println("Add setup"); } @Test void testAdd() {} } @Nested class SubtractTests { @BeforeEach void setup() { System.out.println("Subtract setup"); } @Test void testSubtract() {} } @BeforeEach void setup() { System.out.println("Main setup"); } } places main setup after nested classes, which is allowed but less clear. class CalculatorTest { @BeforeAll static void setup() { System.out.println("Main setup"); } @Nested class AddTests { @BeforeEach void setup() { System.out.println("Add setup"); } @Test void testAdd() {} } @Nested class SubtractTests { @BeforeEach void setup() { System.out.println("Subtract setup"); } @Test void testSubtract() {} } } uses @BeforeAll which runs once, not before each test. class CalculatorTest { @BeforeEach void setup() { System.out.println("Main setup"); } @Nested static class AddTests { @BeforeEach void setup() { System.out.println("Add setup"); } @Test void testAdd() {} } @Nested static class SubtractTests { @BeforeEach void setup() { System.out.println("Subtract setup"); } @Test void testSubtract() {} } } uses static nested classes, which disables outer @BeforeEach running before nested ones.

3. Final Answer:

   Option A with non-static nested classes and main @BeforeEach before nested setups -> Option A

4. Quick Check:

   Non-static nested + outer @BeforeEach before nested = A [OK]

Hint: Use non-static nested classes; outer @BeforeEach runs before nested [OK]

Common Mistakes:

• Making nested classes static disables outer @BeforeEach
• Using @BeforeAll instead of @BeforeEach for setup
• Placing main setup after nested classes causing confusion