Unit Testing with JUnit

A unit test verifies that a single, small piece of code — typically one method — behaves correctly in isolation. JUnit is the dominant testing framework in the Java ecosystem, and JUnit 5 (also called JUnit Jupiter) is its current generation, built around annotations that mark methods as tests and assertions that check expected outcomes.

Tests matter because they turn "I think this still works" into "I know this still works." Without automated tests, verifying that a change hasn't broken existing behavior means manually re-checking the application by hand, which does not scale and is easy to skip under deadline pressure. A solid test suite catches regressions the moment they're introduced, often before the code is even committed.

Why it matters

Code that has no tests can be verified only by running the application and clicking through it. Unit tests check behaviour in milliseconds on every change, which is what makes refactoring safe. JUnit is the standard in Java, and writing tests is part of the job in practically every team.

Core JUnit 5 Annotations

JUnit 5 tests are ordinary methods marked with annotations that tell the test runner how and when to invoke them.

• @Test — marks a method as a test case to be executed by the JUnit runner.
• @BeforeEach — runs before every test method in the class, commonly used to set up fresh test fixtures so tests don't leak state between each other.
• @AfterEach — runs after every test method, often used for cleanup.
• @BeforeAll / @AfterAll — run once before/after all tests in the class (must be static methods).
• @DisplayName — gives a test a readable, human-friendly name in test reports.

Assertions

Assertions, from the org.junit.jupiter.api.Assertions class, are what actually determine pass or fail. assertEquals(expected, actual) checks two values match. assertTrue / assertFalse check a boolean condition. assertThrows(ExceptionType.class, () -> { ... }) verifies that a block of code throws a specific exception — essential for testing error-handling paths, not just happy paths. If an assertion fails, JUnit stops that test method and reports it as a failure with a clear expected-vs-actual message.

The Arrange-Act-Assert Pattern

Well-structured unit tests follow a consistent three-part shape. Arrange: set up the objects and inputs needed for the test. Act: call the method under test. Assert: check that the outcome matches expectations. Keeping these three steps visually separate (often with blank lines) makes tests easy to read at a glance, even for someone unfamiliar with the codebase, and keeps each test focused on verifying one specific behavior.

Example

// src/main/java/com/webnest/math/Calculator.java
package com.webnest.math;

public class Calculator {
    public int divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("Cannot divide by zero");
        }
        return a / b;
    }
}

// src/test/java/com/webnest/math/CalculatorTest.java
package com.webnest.math;

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

class CalculatorTest {

    private Calculator calculator;

    @BeforeEach
    void setUp() {
        // Arrange (shared setup): a fresh Calculator before every test
        calculator = new Calculator();
    }

    @Test
    void dividesTwoPositiveNumbers() {
        // Act
        int result = calculator.divide(10, 2);

        // Assert
        assertEquals(5, result);
    }

    @Test
    void throwsWhenDividingByZero() {
        assertThrows(ArithmeticException.class, () -> calculator.divide(10, 0));
    }
}

CalculatorTest
  ✔ dividesTwoPositiveNumbers()
  ✔ throwsWhenDividingByZero()

Tests run: 2, Failures: 0, Errors: 0, Skipped: 0

Exercise

This exercise needs JUnit 5 on the classpath, through Maven or Gradle, so it does not run in the playground. For the Calculator class given, write a test class with two tests: one checking that 10 divided by 2 is 5, and one checking that dividing by zero throws ArithmeticException. Create a fresh calculator before each test.

Expected result: the build tool reports two tests passed.

class Calculator {
    int divide(int a, int b) {
        return a / b;
    }
}

// CalculatorTest.java
// TODO: imports from org.junit.jupiter.api

class CalculatorTest {
    // TODO: a Calculator field, initialised before each test

    // TODO: test that divide(10, 2) returns 5

    // TODO: test that divide(1, 0) throws ArithmeticException
}

class Calculator {
    int divide(int a, int b) {
        return a / b;
    }
}

// CalculatorTest.java
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

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

class CalculatorTest {
    private Calculator calculator;

    @BeforeEach
    void setUp() {
        calculator = new Calculator();
    }

    @Test
    void dividesTwoNumbers() {
        assertEquals(5, calculator.divide(10, 2));
    }

    @Test
    void throwsWhenDividingByZero() {
        assertThrows(ArithmeticException.class, () -> calculator.divide(1, 0));
    }
}

Quick quiz

Interview questions