Mahmoud Abas, Full-Stack Software Engineer & AI

Software Construction - Lab 4: Unit Testing with Java and JUnit 5

In the print dialog, choose "Save as PDF" as the destination.

Lab 4: Unit Testing with Java and JUnit 5

Frameworks, annotations, lifecycle, and practical JUnit 5 examples

Introduction to Unit Testing

Unit testing: Tests individual units or components of software to validate each performs as expected.

Done during development (coding phase) by the developers themselves
Tests isolate a section of code and verify its correctness
A unit may be an individual function, method, procedure, module, or object

Unit Test Tools

Tool	What it offers
`JUnit`	Free Java testing tool, provides assertions to identify test methods
`NUnit`	Widely used for `.NET` languages, open source, supports parallel data-driven tests
`JMockit`	Open source, offers mocking plus Line/Path/Data coverage metrics
`EMMA`	Open-source Java coverage toolkit (method, line, basic block), no external dependencies
`PHPUnit`	Unit testing tool for `PHP`, tests small code portions separately with predefined assertions

JUnit 5 Overview & Architecture

JUnit 5 is the most widely used Java testing framework, built to embrace Java 8+ style coding (lambda expressions); requires Java 8 or higher
Maintains backward compatibility with JUnit 3 and JUnit 4 tests

JUnit 5

Platform

TestEngine API, Console Launcher, build plugins

Jupiter

New programming/extension model, own TestEngine

Vintage

Runs old JUnit 3/JUnit 4 tests on JUnit 5

JUnit 5 Annotations

Annotation	What it does
`@Test`	Marks a method as a test
`@BeforeEach` / `@AfterEach`	Run before/after every test method
`@BeforeAll` / `@AfterAll`	Run once for the whole class (must be static)
`@DisplayName`	Custom, readable name for a class or test method
`@Disabled`	Skip a test class or method
`@RepeatedTest` / `@ParameterizedTest`	Repeat a test, or drive it with multiple input sets
`@Nested`	Group related tests inside inner classes
`@Tag`	Filter/discover tests by tag

Test Lifecycle

@BeforeAll

once, before any test

@BeforeEach

@Test

@AfterEach

after the last test

@AfterAll

once, after all tests

For each test method: @BeforeEach runs, then the @Test method, then @AfterEach
This guarantees a clean, isolated setup/teardown around every individual test

Writing a Basic Test

java

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

class CalculatorTest {
    private Calculator calculator;

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

    @Test
    @DisplayName("Test Addition: 5 + 3 = 8")
    void testAddition() {
        assertEquals(8, calculator.add(5, 3), "5 + 3 should equal 8");
    }

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

A minimal Calculator class and its first JUnit 5 test class.

Common Assertions

java

assertEquals(10, 5 * 2, "5 * 2 should equal 10");
assertEquals(3.14, 3.141, 0.01);          // delta comparison
assertTrue(5 > 3);
assertNull(nullString);
assertArrayEquals(expected, actual);
assertSame(a, c);                          // same object reference
assertThrows(IllegalArgumentException.class, () -> calculator.divide(10, 0));
assertTimeout(Duration.ofMillis(100), () -> Thread.sleep(50));

assertAll("Calculator Operations",
    () -> assertEquals(8, calculator.add(5, 3)),
    () -> assertEquals(2, calculator.subtract(5, 3))
);

assertEquals checks value equality; assertSame checks reference identity
assertAll groups multiple assertions so all run even if one fails

Parameterized Tests

java

@ParameterizedTest(name = "{0} + {1} = {2}")
@CsvSource({
    "1, 2, 3",
    "5, 7, 12",
    "-5, 5, 0"
})
void testAdditionWithCsvSource(int a, int b, int expected) {
    assertEquals(expected, new Calculator().add(a, b));
}

@ParameterizedTest
@MethodSource("factorialProvider")
void testFactorial(int input, int expected) {
    assertEquals(expected, new Calculator().factorial(input));
}

static Stream<Arguments> factorialProvider() {
    return Stream.of(Arguments.of(0, 1), Arguments.of(5, 120));
}

@CsvSource inlines test data; @MethodSource pulls it from a static factory method

Repeated Tests and Test Order

java

@RepeatedTest(value = 5, name = "Repetition {currentRepetition} of {totalRepetitions}")
void testAdditionCommutative() {
    int a = random.nextInt(100), b = random.nextInt(100);
    assertEquals(calculator.add(a, b), calculator.add(b, a));
}

@RepeatedTest(n) reruns a test n times, useful for randomized/property-style checks
@TestMethodOrder(MethodOrderer.OrderAnnotation.class) plus @Order(n) on each @Test forces a specific execution order (tests are independent by default, use sparingly)

Advantages of Unit Testing

Learning and documentation, tests double as usage examples of the unit's API
Safe refactoring and maintenance, regression testing catches breaks quickly when code changes
Parallel development, modular tests let teams verify parts independently, without waiting on others

Disadvantages and Best Practices

Cannot catch every error, evaluating all execution paths is infeasible even in trivial programs
Focuses on individual units, cannot catch integration or system-level errors; must be paired with integration/system testing

Arrange: set up test data
Act: execute the method being tested
Assert: verify the results

Running Tests

xml

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.10.0</version>
    <scope>test</scope>
</dependency>

Maven: mvn test · Gradle: gradle test (with useJUnitPlatform() configured)
IDEs (IntelliJ, Eclipse, VS Code) run tests via right-click → Run, or the green play button next to each test method

Key Takeaways

Unit tests isolate a single function, method, or class and verify its correctness independently
JUnit 5 = Platform (TestEngine API) + Jupiter (new annotations/model) + Vintage (JUnit 3/JUnit 4 compatibility)
Lifecycle annotations (@BeforeAll/@BeforeEach/@AfterEach/@AfterAll) wrap every test with consistent setup and teardown
@ParameterizedTest (@CsvSource, @MethodSource) and @RepeatedTest multiply coverage from a single test method
Rich assertions (assertEquals, assertThrows, assertAll, assertTimeout) express precise expected behavior
Unit testing enables safe refactoring and documents behavior, but must be paired with integration and system testing

Open this lesson

Mahmoud AbasLab 4: Unit Testing with Java and JUnit 5

Tool

What it offers

JUnit

Free Java testing tool, provides assertions to identify test methods

NUnit

Widely used for .NET languages, open source, supports parallel data-driven tests

JMockit

Open source, offers mocking plus Line/Path/Data coverage metrics

EMMA

Open-source Java coverage toolkit (method, line, basic block), no external dependencies

PHPUnit

Unit testing tool for PHP, tests small code portions separately with predefined assertions

Annotation

What it does

@Test

Marks a method as a test

@BeforeEach / @AfterEach

Run before/after every test method

@BeforeAll / @AfterAll

Run once for the whole class (must be static)

@DisplayName

Custom, readable name for a class or test method

@Disabled

Skip a test class or method

@RepeatedTest / @ParameterizedTest

Repeat a test, or drive it with multiple input sets

@Nested

Group related tests inside inner classes

@Tag

Filter/discover tests by tag

public class Calculator { public int add(int a, int b) { return a + b; } public double divide(int a, int b) { if (b == 0) throw new IllegalArgumentException("Cannot divide by zero"); return (double) a / b; } } class CalculatorTest { private Calculator calculator; @BeforeEach void init() { calculator = new Calculator(); } @Test @DisplayName("Test Addition: 5 + 3 = 8") void testAddition() { assertEquals(8, calculator.add(5, 3), "5 + 3 should equal 8"); } @Test void testDivisionByZero() { assertThrows(IllegalArgumentException.class, () -> calculator.divide(10, 0)); } }

assertEquals(10, 5 * 2, "5 * 2 should equal 10"); assertEquals(3.14, 3.141, 0.01); // delta comparison assertTrue(5 > 3); assertNull(nullString); assertArrayEquals(expected, actual); assertSame(a, c); // same object reference assertThrows(IllegalArgumentException.class, () -> calculator.divide(10, 0)); assertTimeout(Duration.ofMillis(100), () -> Thread.sleep(50)); assertAll("Calculator Operations", () -> assertEquals(8, calculator.add(5, 3)), () -> assertEquals(2, calculator.subtract(5, 3)) );

@ParameterizedTest(name = "{0} + {1} = {2}") @CsvSource({ "1, 2, 3", "5, 7, 12", "-5, 5, 0" }) void testAdditionWithCsvSource(int a, int b, int expected) { assertEquals(expected, new Calculator().add(a, b)); } @ParameterizedTest @MethodSource("factorialProvider") void testFactorial(int input, int expected) { assertEquals(expected, new Calculator().factorial(input)); } static Stream<Arguments> factorialProvider() { return Stream.of(Arguments.of(0, 1), Arguments.of(5, 120)); }

@RepeatedTest(value = 5, name = "Repetition {currentRepetition} of {totalRepetitions}") void testAdditionCommutative() { int a = random.nextInt(100), b = random.nextInt(100); assertEquals(calculator.add(a, b), calculator.add(b, a)); }