Why coverage measures test completeness in JUnit - Quick Recap

Recall & Review

beginner

What does test coverage measure in software testing?

Test coverage measures how much of the code is executed by the tests. It shows which parts of the code have been tested and which parts have not.

beginner

Why is high test coverage important?

High test coverage means more code is tested, reducing the chance of bugs hiding in untested parts. It helps ensure the software works as expected.

intermediate

What is a limitation of relying only on test coverage?

Test coverage shows which code runs but not if the tests check the right results. So, high coverage doesn’t always mean good tests.

beginner

How can JUnit help measure test coverage?

JUnit runs tests and can be combined with tools like JaCoCo to report which code lines were executed during tests, showing coverage percentage.

intermediate

What does 100% test coverage mean?

It means every line of code was executed by tests at least once. But it doesn’t guarantee all bugs are found or all scenarios tested.

What does test coverage primarily measure?

A How many bugs are found

B How fast tests run

C How much code is executed by tests

D How many users use the software

Test coverage measures the amount of code executed during testing, not bugs found or speed.

Which tool can be used with JUnit to measure coverage?

A Git

B JaCoCo

C Postman

D Selenium

JaCoCo is a popular tool to measure code coverage with JUnit tests.

Does 100% test coverage guarantee bug-free software?

A No, coverage only shows code executed

B Yes, always

C Only if tests run fast

D Only if tests are manual

100% coverage means all code ran, but tests might not check correct behavior or all cases.

Why might test coverage be low?

A Tests don’t run some code parts

B Tests run too fast

C Code is too simple

D Software is too new

Low coverage happens when some code lines are never executed by tests.

What is a good practice when using coverage metrics?

A Write tests without assertions

B Ignore coverage numbers

C Only test the UI

D Use coverage with other quality checks

Coverage should be combined with assertions and other testing methods for best results.

Explain why test coverage is used to measure test completeness.

Think about what coverage tells us about the tests and what it does not.

Describe how JUnit and coverage tools work together to improve testing.

Consider the roles of both JUnit and tools like JaCoCo.

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