What is Test Coverage?

Definition

Test coverage is a broad term describing how thoroughly a test suite exercises the system under test. While often used interchangeably with "code coverage," test coverage is the larger concept: it includes not just how much code is executed during testing, but also how completely the system's requirements, behaviors, and risk scenarios are tested.

The distinction matters: high code coverage can coexist with low requirement coverage (you ran all the code but didn't test the most important behaviors) and low risk coverage (you tested the happy path but not the failure scenarios).

Dimensions of Test Coverage

Code coverage

The percentage of source code executed during the test run. Measured by instrumentation tools (Istanbul, JaCoCo, coverage.py). The most commonly tracked coverage metric because it is easy to measure.

Requirement coverage

Whether each specified requirement or user story has at least one test that verifies it. Code coverage does not guarantee requirement coverage — code can be executed without testing the specific behavior it is supposed to provide.

Risk coverage

Whether high-risk scenarios — error conditions, edge cases, security-sensitive inputs, concurrency issues — are tested. Code coverage tools do not distinguish between testing a happy path and testing a critical security boundary.

Integration coverage

Whether the interactions between system components are tested — not just individual units in isolation. High unit test coverage can coexist with low integration coverage if modules work correctly in isolation but fail when combined.

Test Coverage in Practice

A comprehensive test coverage approach combines multiple coverage types:

1. Unit tests for individual functions and classes — targeting high code coverage
2. Integration tests for component interactions — targeting integration coverage
3. End-to-end tests for complete user flows — targeting requirement coverage
4. Negative and edge-case tests for error handling and boundary conditions — targeting risk coverage

Coverage Gaps and Their Consequences

Coverage gaps create blind spots:

• Uncovered code paths contain bugs that tests never catch — shipping broken code
• Uncovered requirements mean functionality that was supposed to exist does not work — shipping incomplete features
• Uncovered risk scenarios mean the system fails predictably in conditions that were known but not tested

Test Coverage and Autonomous Code Governance

Test coverage is both an input and an output in autonomous code governance. As an input, coverage data informs which areas of the codebase lack testing — directing autonomous test generation to fill the gaps. As an output, every fix Hydra generates includes baseline tests that contribute to overall test coverage, incrementally improving the codebase's test posture over time.

The combination of autonomous fix generation and autonomous test generation means that governance activity directly improves coverage, rather than treating coverage improvement as a separate initiative.