@Nested inner classes in JUnit - Build an Automation Script

Verify Calculator operations using @Nested inner classes in JUnit

Preconditions (2)

Step 1: Create a test class CalculatorTest

Step 2: Inside CalculatorTest, create a @Nested class AddTests

Step 3: In AddTests, write a test method testAddPositiveNumbers that asserts add(2,3) equals 5

Step 4: Inside CalculatorTest, create another @Nested class SubtractTests

Step 5: In SubtractTests, write a test method testSubtractPositiveNumbers that asserts subtract(5,3) equals 2

Step 6: Run the CalculatorTest class

✅ Expected Result: Both testAddPositiveNumbers and testSubtractPositiveNumbers pass successfully, showing that @Nested classes organize related tests

Automation Requirements - JUnit 5

Assertions Needed:

assertEquals for add method result

assertEquals for subtract method result

Best Practices:

Use @Nested annotation to group related test methods

Use descriptive method names for clarity

Keep test methods independent and focused

Use @BeforeEach if setup is needed inside nested classes

Automated Solution

JUnit

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

class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    int subtract(int a, int b) {
        return a - b;
    }
}

public class CalculatorTest {
    Calculator calculator = new Calculator();

    @Nested
    class AddTests {
        @Test
        void testAddPositiveNumbers() {
            assertEquals(5, calculator.add(2, 3));
        }
    }

    @Nested
    class SubtractTests {
        @Test
        void testSubtractPositiveNumbers() {
            assertEquals(2, calculator.subtract(5, 3));
        }
    }
}

This test class uses @Nested inner classes to group tests logically by operation type: addition and subtraction.

The Calculator class provides simple methods to add and subtract numbers.

Inside CalculatorTest, two nested classes AddTests and SubtractTests each contain one test method.

Each test method uses assertEquals to verify the expected result.

This structure helps organize tests clearly and makes it easier to maintain and understand related test cases.

Common Mistakes - 3 Pitfalls

{'mistake': 'Not using @Nested annotation on inner classes', 'why_bad': "JUnit will not recognize the inner classes as test containers, so tests inside won't run", 'correct_approach': 'Always annotate inner classes with @Nested to enable JUnit 5 to run their tests'}

Sharing mutable state between nested classes without setup

Writing multiple unrelated tests in one nested class

Bonus Challenge

Add a new @Nested class MultiplyTests with a test method that verifies multiplication of two numbers

Show Hint

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