Why coverage measures test completeness in JUnit - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

What does code coverage measure in testing?

In software testing, code coverage is used to measure how much of the code is tested. What exactly does code coverage measure?

A The number of bugs found during testing

B The number of tests written for the software

C The time taken to run all tests

D The percentage of code lines executed by tests

💡 Hint

Think about what 'coverage' means in everyday life, like covering a surface.

Code coverage measures how many lines or parts of the code are actually run when tests are executed. It shows how much of the code is 'covered' by tests.

❓ Predict Output

intermediate

JUnit test coverage output interpretation

Given this JUnit test and code, what coverage percentage will be reported?

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 50%

B 100%

C 0%

D 75%

💡 Hint

Only one method is tested out of two.

The test only calls the add method, so only that method's code is executed. The subtract method is not tested, so coverage is 50%.

❓ assertion

advanced

Which assertion best checks test completeness using coverage?

You want to assert that your JUnit tests cover all branches of a method. Which assertion best reflects this completeness?

A assertFalse(coveragePercentage > 0)

B assertTrue(coveragePercentage == 100, "All branches covered")

C assertNotNull(coveragePercentage)

D assertEquals(coveragePercentage, 50)

💡 Hint

Complete coverage means 100% coverage.

To confirm all branches are covered, coverage must be 100%. The assertion checks this exactly.

🔧 Debug

advanced

Why does coverage report less than 100% despite all tests passing?

You have written JUnit tests that pass, but coverage reports only 80%. What is the most likely reason?

A JUnit tests have syntax errors

B Coverage tool is not installed

C Some code branches or lines are not executed by any test

D Tests are running too fast

💡 Hint

Passing tests do not guarantee all code paths run.

Tests may pass but not cover all code paths, so coverage is less than 100%. This shows incomplete test coverage.

❓ framework

expert

How to configure JUnit to measure branch coverage accurately?

Which configuration or tool setup ensures JUnit tests measure branch coverage accurately?

A Use JaCoCo agent with JVM argument and enable branch coverage in report settings

B Use System.out.println statements to track coverage manually

C Run JUnit tests without any coverage tool attached

D Disable assertions in JUnit tests

💡 Hint

Coverage tools need to instrument code to measure branches.

JaCoCo is a popular coverage tool that instruments code at runtime. Enabling branch coverage in its settings ensures accurate measurement of all branches during JUnit test execution.

Practice

1. What does code coverage measure in JUnit testing?

easy

A. The memory used during testing

B. How much of the code is executed by tests

C. The number of test cases written

D. The speed of test execution

Solution

1. Step 1: Understand the meaning of coverage

   Coverage shows which parts of the code are run when tests execute.

2. Step 2: Relate coverage to test completeness

   Higher coverage means more code is tested, indicating more complete tests.

3. Final Answer:

   How much of the code is executed by tests -> Option B

4. Quick Check:

   Coverage = executed code portion [OK]

Hint: Coverage = code run by tests, not test count [OK]

Common Mistakes:

• Confusing coverage with test speed
• Thinking coverage counts test cases
• Assuming coverage measures memory use

2. Which JUnit annotation is used to mark a method as a test to be included in coverage?

easy

A. @Test

B. @AfterEach

C. @BeforeAll

D. @Ignore

Solution

1. Step 1: Identify JUnit test method annotation

   The @Test annotation marks methods as test cases to run.

2. Step 2: Understand coverage relation

   Only methods run as tests contribute to coverage measurement.

3. Final Answer:

   @Test -> Option A

4. Quick Check:

   @Test marks test methods [OK]

Hint: Look for @Test to include method in coverage [OK]

Common Mistakes:

• Using @BeforeAll as test method
• Confusing @Ignore with test execution
• Thinking @AfterEach runs tests

3. Given this JUnit test code snippet, what is the coverage result for method calculate?

public class Calculator {
  public int calculate(int x) {
    if (x > 0) return x * 2;
    else return 0;
  }
}

@Test
public void testCalculatePositive() {
  Calculator c = new Calculator();
  assertEquals(4, c.calculate(2));
}

medium

A. 50% coverage of calculate method

B. 100% coverage of calculate method

C. 0% coverage of calculate method

D. 75% coverage of calculate method

Solution

1. Step 1: Analyze test input and branches

   The test calls calculate(2), which triggers the if branch (x > 0).

2. Step 2: Check coverage of else branch

   The else branch (return 0) is never executed, so not covered.

3. Final Answer:

   50% coverage of calculate method -> Option A

4. Quick Check:

   One branch covered, one not = 50% [OK]

Hint: Test all branches for full coverage [OK]

Common Mistakes:

• Assuming one test covers all branches
• Ignoring else branch coverage
• Confusing coverage with test success

4. Identify the problem in this JUnit test that causes incomplete coverage of method isValid:

public boolean isValid(int n) {
  if (n > 0) return true;
  else return false;
}

@Test
public void testIsValid() {
  assertTrue(isValid(1));
}

medium

A. Test method missing @Test annotation

B. Test uses assertTrue incorrectly

C. Method isValid has syntax error

D. Test does not check negative input branch

Solution

1. Step 1: Review test input coverage

   The test only calls isValid(1), covering the positive branch.

2. Step 2: Check missing branch coverage

   The negative or zero input branch (else) is not tested, causing incomplete coverage.

3. Final Answer:

   Test does not check negative input branch -> Option D

4. Quick Check:

   Missing else branch test = incomplete coverage [OK]

Hint: Test all input types to cover branches [OK]

Common Mistakes:

• Assuming one positive test covers all
• Thinking assertTrue usage affects coverage
• Ignoring missing @Test annotation

5. You have a method with multiple conditions:

public String classify(int age) {
  if (age < 13) return "child";
  else if (age < 20) return "teen";
  else return "adult";
}

To achieve 100% coverage, which set of test inputs should you include in your JUnit tests?

hard

A. 0, 12, 20

B. 10, 18

C. 5, 15, 25

D. 15, 25

Solution

1. Step 1: Identify all branches in classify method

   There are three branches: age < 13, 13 ≤ age < 20, and age ≥ 20.

2. Step 2: Select test inputs covering all branches

   Inputs 5 (child), 15 (teen), and 25 (adult) cover all branches fully.

3. Final Answer:

   5, 15, 25 -> Option C

4. Quick Check:

   One input per branch = full coverage [OK]

Hint: Test one value per branch for full coverage [OK]

Common Mistakes:

• Missing one branch input
• Using boundary values without covering all branches
• Assuming fewer tests cover all cases