Why coverage measures test completeness in JUnit

Introduction

Coverage shows how much of your code is tested. It helps find parts not checked by tests.

When you want to know if your tests check all important code parts.

Before releasing software to ensure key functions are tested.

When adding new features to confirm tests cover new code.

To find untested code that might cause bugs.

When improving test quality by increasing coverage.

Syntax

JUnit

No direct code syntax; coverage is measured by tools that analyze test runs.

Coverage tools track which lines or branches run during tests.

Higher coverage means more code is tested, but 100% coverage doesn't guarantee no bugs.

Examples

This test covers the add method of Calculator. Coverage tools will mark the add method as tested.

JUnit

// Example: JUnit test class
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

class CalculatorTest {
    @Test
    void testAdd() {
        Calculator calc = new Calculator();
        assertEquals(5, calc.add(2, 3));
    }
}

If no test calls subtract, coverage tools show subtract as uncovered, indicating incomplete tests.

JUnit

// Example: Missing test for subtract method
class Calculator {
    int add(int a, int b) { return a + b; }
    int subtract(int a, int b) { return a - b; }
}

Sample Program

This test class only tests the add method. Coverage tools will report that subtract is not covered, showing test incompleteness.

JUnit

import static org.junit.jupiter.api.Assertions.*;
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; }
}

class CalculatorTest {
    @Test
    void testAdd() {
        Calculator calc = new Calculator();
        assertEquals(5, calc.add(2, 3));
    }
}

Important Notes

Coverage helps find untested code but does not check test quality.

Use coverage with other testing practices for best results.

Summary

Coverage measures how much code tests run through.

It shows which parts of code are not tested yet.

Higher coverage helps improve test completeness but is not the only goal.