Line and branch coverage in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Line coverage in JUnit test

Given the following Java method and its JUnit test, what is the line coverage percentage after running the test?

JUnit

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }
}

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

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

A 75%

B 50%

C 25%

D 100%

💡 Hint

Only the add method is tested, subtract is not called.

The Calculator class has two methods: add and subtract. The test only calls add, so only the lines inside add are executed. Since subtract is not called, its lines are not covered. There are 4 lines of code in total (2 lines per method), and only 2 lines are executed, so coverage is 50%.

❓ assertion

intermediate

Branch coverage assertion in JUnit

Consider this method with a conditional branch and its JUnit test. Which assertion correctly verifies full branch coverage?

JUnit

public class NumberChecker {
    public boolean isPositive(int number) {
        if (number > 0) {
            return true;
        } else {
            return false;
        }
    }
}

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

public class NumberCheckerTest {
    @Test
    public void testIsPositive() {
        NumberChecker checker = new NumberChecker();
        assertTrue(checker.isPositive(5));
        // Missing test for negative or zero
    }
}

A Add assertFalse(checker.isPositive(-1)); to test negative number

B Add assertTrue(checker.isPositive(0)); to test zero

C Add assertFalse(checker.isPositive(1)); to test positive number

D Add assertTrue(checker.isPositive(-5)); to test negative number

💡 Hint

Branch coverage requires testing both true and false paths.

The method has a branch: if number > 0 returns true, else false. The test only checks a positive number (true branch). To cover the false branch, test with a negative number and assert false. Testing zero is optional but zero is not greater than zero, so it returns false, but the key is to cover both branches.

🔧 Debug

advanced

Debugging incomplete branch coverage

A JUnit test suite runs but reports only 80% branch coverage for this method. What is the most likely cause?

JUnit

public class Discount {
    public double calculate(double price, boolean isMember) {
        if (isMember) {
            return price * 0.9;
        } else {
            return price;
        }
    }
}

// Test code:
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

public class DiscountTest {
    @Test
    public void testCalculate() {
        Discount d = new Discount();
        assertEquals(90, d.calculate(100, true));
    }
}

A Test only covers isMember = true branch, missing isMember = false branch

B Test has wrong expected value causing assertion failure

C Method has syntax error causing partial coverage

D Test does not instantiate Discount class properly

💡 Hint

Branch coverage requires testing all branches of conditionals.

The test only calls calculate with isMember = true, so only the true branch is executed. The false branch (else) is never tested, so branch coverage is less than 100%. This causes 80% coverage reported.

🧠 Conceptual

advanced

Difference between line and branch coverage

Which statement best describes the difference between line coverage and branch coverage in software testing?

A Line coverage measures number of tests; branch coverage measures number of bugs

B Line coverage measures executed branches; branch coverage measures executed lines

C Line coverage measures executed lines; branch coverage measures executed decision outcomes

D Line coverage measures code complexity; branch coverage measures test speed

💡 Hint

Think about what happens when code has if-else statements.

Line coverage counts how many lines of code run during tests. Branch coverage counts how many possible paths (branches) in decision points like if-else are executed. Branch coverage is more detailed because it checks both true and false paths.

❓ framework

expert

JUnit 5 annotation for branch coverage reporting

Which JUnit 5 feature or tool integration helps generate detailed branch coverage reports automatically during test runs?

A Use @TestCoverage annotation to enable branch coverage

B Use @BranchCoverage annotation in JUnit 5 tests

C Use JUnit 5 built-in branch coverage reporter with @CoverageReport

D Use JaCoCo agent with Maven Surefire plugin to collect coverage data

💡 Hint

JUnit itself does not provide coverage, but integrates with external tools.

JUnit 5 does not have built-in annotations for coverage. Tools like JaCoCo integrate with JUnit tests via build tools (Maven, Gradle) to collect line and branch coverage data and generate reports automatically.