@Nested inner classes in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

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

They help organize tests into logical groups inside a test class, making tests easier to read and maintain.

beginner

How do you declare a nested test class in JUnit 5?

By annotating a non-static inner class with @Nested inside a test class.

intermediate

Can @Nested classes access instance variables of the outer test class?

Yes, nested classes can access instance variables and methods of the outer test class, allowing shared setup.

intermediate

What is a benefit of using @Nested classes compared to separate test classes?

They keep related tests grouped together in one file, improving readability and reducing duplication.

intermediate

Does @Nested support lifecycle methods like @BeforeEach inside the nested class?

Yes, you can use lifecycle annotations like @BeforeEach and @AfterEach inside @Nested classes for setup and cleanup.

What annotation marks an inner class as a nested test class in JUnit 5?

A @SubTest

B @InnerTest

C @TestClass

D @Nested

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

Which of the following is a key benefit of using @Nested classes?

A They run tests faster than separate classes.

B They replace the need for @BeforeEach methods.

C They allow grouping related tests inside one test class.

D They automatically mock dependencies.

Nested classes help organize related tests together, improving code structure and readability.

Can @Nested classes have their own @BeforeEach methods?

A Only if they are static classes.

B Yes, they can have their own lifecycle methods.

C No, only the outer class can have lifecycle methods.

D Only if annotated with @TestInstance.

Nested classes can define their own lifecycle methods like @BeforeEach to set up tests.

What is the visibility requirement for a @Nested class in JUnit?

A It must be non-static and package-private or higher.

B It must be static and private.

C It must be public and static.

D It must be abstract.

A @Nested class must be a non-static inner class with at least package-private visibility.

Which statement is true about @Nested classes accessing outer class members?

A They can access instance variables and methods of the outer class.

B They cannot access any members of the outer class.

C They can only access static members of the outer class.

D They require special annotations to access outer members.

Nested classes have access to instance variables and methods of their outer class.

Explain how @Nested inner classes improve test organization in JUnit.

Think about how grouping tests helps keep code clean and easier to understand.

Describe the rules and best practices for writing @Nested classes in JUnit.

Consider class structure, annotations, and lifecycle support.

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