Understanding Code Coverage: Types, Influencing Factors, and Improvement Strategies

As QA engineers, we often face questions about how well testing is performed, whether it covers all user scenarios, and whether it covers all development code, which leads us to the concept of coverage.

Basic Classification of Coverage

Coverage is a broad concept that can be divided into three main types: functional/scene coverage, interface coverage, and code coverage. The article focuses on code coverage, defined by Wikipedia as a software testing metric that describes the proportion and degree to which source code is exercised by tests.

Code Coverage Classification

Traditional code coverage metrics include function coverage, line coverage, branch coverage, condition coverage, and condition‑branch coverage. These range from coarse to fine granularity, with line coverage being the most commonly used today.

Factors Influencing Code Coverage

The article presents a diagram showing the relationship between the total product functionality (black area), the code under test (blue area), and the actually executed test scenarios (green area). The intersection of blue and green divided by blue yields the code coverage. Bugs that are leaked or missed correspond to pink and red areas, respectively, highlighting the importance of both code and scenario coverage.

Key conclusions include:

Leaked bugs occur in scenarios where neither the product code nor the test code is exercised.

Recalled bugs can exist both inside and outside the covered code, requiring broader scenario coverage.

Achieving 100% code coverage is generally impossible due to unreachable or irrelevant code paths.

Significance of Code Coverage

Coverage provides a numeric measure of test completeness; low coverage clearly indicates insufficient testing, while high coverage does not guarantee quality but is a useful indicator. Coverage trends over time reflect testing capability, help identify dead or redundant code, and can be correlated with bug recall rates.

How to Improve Code Coverage

Improvement can be approached from both development and test perspectives:

For development code: remove unused code, focus on low‑coverage modules, target uncovered branches and functions, and set realistic coverage goals.

For test code: avoid trivial always‑passing cases, evaluate the cost‑benefit of low‑impact tests, consider rarely‑triggered paths, and use automated techniques such as traffic replay to generate additional scenarios.

Static vs. Dynamic Coverage

Static coverage shows which lines are executed, while dynamic (or call‑chain) coverage captures runtime context, parameters, and stack information, offering finer‑grained insight and helping prioritize test cases.

Full vs. Incremental Coverage

Full coverage reports the absolute percentage for each run, whereas incremental coverage highlights changes between runs, distinguishing cases where code changes without test changes, test regressions, new covered scenarios, and new uncovered code.

Obtaining Code Coverage

The practical way to collect coverage data is through code instrumentation: inserting a probe after each statement that records execution. Different languages have dedicated tools, such as Go's built‑in coverage and Java's JaCoCo, which will be explored in future articles.