Arrange-Act-Assert pattern in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this JUnit test?

Consider the following JUnit test method using the Arrange-Act-Assert pattern. What will be the test result after execution?

JUnit

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

class CalculatorTest {
    @Test
    void testAdd() {
        // Arrange
        Calculator calc = new Calculator();
        int a = 5;
        int b = 3;

        // Act
        int result = calc.add(a, b);

        // Assert
        assertEquals(8, result);
    }
}

class Calculator {
    int add(int x, int y) {
        return x + y;
    }
}

A Test fails with NullPointerException

B Test passes successfully

C Test fails with assertion error

D Test fails with compilation error

💡 Hint

Check the add method logic and the expected assertion value.

The add method correctly returns the sum of 5 and 3, which is 8. The assertion expects 8, so the test passes.

❓ assertion

intermediate

Which assertion correctly follows the Assert step in Arrange-Act-Assert?

You have arranged and acted by calling a method that returns a list of 3 items. Which assertion correctly verifies the list size?

JUnit

List<String> items = List.of("apple", "banana", "cherry");

A assertEquals(3, items.size());

B assertTrue(items == 3);

C assertFalse(items.isEmpty());

D assertNull(items);

💡 Hint

Check which assertion compares the expected size to the actual size.

assertEquals(3, items.size()) correctly checks that the list has exactly 3 items, matching the expected count.

🔧 Debug

advanced

Identify the problem in this Arrange-Act-Assert test method

This JUnit test method is intended to test subtraction but fails unexpectedly. What is the main issue?

JUnit

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

class CalculatorTest {
    @Test
    void testSubtract() {
        // Arrange
        Calculator calc = new Calculator();
        int a = 10;
        int b = 4;

        // Act
        int result = calc.add(a, b);

        // Assert
        assertEquals(6, result);
    }
}

class Calculator {
    int add(int x, int y) {
        return x + y;
    }
}

A The Assert step expects wrong result value

B The Calculator class is missing the subtract method

C The Arrange step initializes variables incorrectly

D The Act step calls add instead of subtract method

💡 Hint

Check which method is called in the Act step versus what the test intends.

The test intends to subtract but calls add in the Act step, causing the assertion to fail.

🧠 Conceptual

advanced

Why is the Arrange-Act-Assert pattern important in unit testing?

Choose the best explanation for why the Arrange-Act-Assert pattern is used in writing unit tests.

A It automatically generates test data and expected results

B It forces tests to run faster by minimizing code

C It organizes tests clearly into setup, execution, and verification steps, improving readability and maintenance

D It allows tests to run in parallel without conflicts

💡 Hint

Think about how clear structure helps when reading or fixing tests later.

Arrange-Act-Assert separates test steps clearly, making tests easier to understand and maintain.

❓ framework

expert

In JUnit 5, which annotation best supports the Arrange-Act-Assert pattern for repeated setup before each test?

You want to run setup code before each test method to prepare test data (Arrange step). Which annotation should you use?

A @BeforeEach

B @BeforeAll

C @TestInstance

D @AfterEach

💡 Hint

Consider which annotation runs before every test method individually.

@BeforeEach runs the annotated method before each test, ideal for arranging test data freshly.