Coverage & Reporting

What it is

Coverage instruments your code to count which parts executed while the tests ran. Reporting turns that raw data into something a human reads: tables, charts, CI artefacts and dashboards over time.

1
  Run the tests
2
     │
3
     ▼
4
  Instrument code ──► record lines/branches/functions that ran
5
     │
6
     ▼
7
  Generate report ──► local HTML + CI artefact + dashboard
8
     │
9
     ▼
10
  Thresholds ──► pass/fail the build

Common coverage types:

Type	Measures	Catches
Line	Which lines ran	Dead code, untouched branches
Branch	Whether every if/else path was taken	Conditions never fully exercised
Function	Which functions were called	Forgotten APIs
Statement	Which statements ran	Similar to line

When to use it / when to avoid it

Use it for

Finding regions of code no test ever touches
CI thresholds to stop coverage sliding backwards over time
Stakeholder reporting: trends, not just an absolute number
Focusing on branch coverage where the code has many conditions

Avoid or reduce it when

Chasing a 100% target as a metric (coverage only says what ran)
Using coverage to judge quality instead of mutation testing
Enabling coverage on every CI job, slowing the build for a report nobody reads

Frameworks & tools

Tool	Ecosystem	Notes
Istanbul / nyc	JS/TS	The classic coverage tool, HTML/lcov output
c8	JS/TS	Uses Node’s native V8 coverage, fast
JaCoCo	Java/JVM	Bytecode coverage; Maven/Gradle integration
coverage.py	Python	The Python standard; `--branch` for branch coverage
go cover	Go	Built in; `go tool cover -html`
Allure	Cross-language	Polished test reports across many languages
ReportPortal	Cross-language	Analytics dashboards, flaky tracking over time

Quick setup

1
npm install -D @vitest/coverage-v8
2
npx vitest run --coverage

1
pip install coverage pytest-cov
2
pytest --cov=src --cov-branch --cov-report=html

1
go test -coverprofile=cover.out ./...
2
go tool cover -html=cover.out

1
<!-- JaCoCo via Maven -->
2
<plugin>
3
  <groupId>org.jacoco</groupId>
4
  <artifactId>jacoco-maven-plugin</artifactId>
5
  <version>0.8.12</version>
6
  <executions>
7
    <execution>
8
      <goals><goal>prepare-agent</goal></goals>
9
    </execution>
10
  </executions>
11
</plugin>

1
dotnet add package coverlet.collector
2
dotnet test --collect:"XPlat Code Coverage"

Example

1
import { defineConfig } from 'vitest/config';
2

3
export default defineConfig({
4
  test: {
5
    coverage: {
6
      provider: 'v8',
7
      reporter: ['text', 'lcov', 'html'],
8
      thresholds: { lines: 80, branches: 70 },
9
    },
10
  },
11
});

1
[run]
2
branch = True
3
source = src
4

5
[report]
6
fail_under = 80

1
# Whole-module coverage total
2
go test -coverprofile=cover.out ./...
3
go tool cover -func=cover.out | tail -n 1

1
mvn test
2
mvn jacoco:report allure:report
3
# open target/site/jacoco/index.html

1
import { allure } from 'allure-playwright';
2

3
test('sign in', async () => {
4
  await allure.step('open page', async () => { /* ... */ });
5
  await allure.step('submit form', async () => { /* ... */ });
6
});

Anti-patterns & best practices

Set thresholds as a ratchet. Prevent regressions rather than forcing 100%.
Prefer branch coverage in condition-heavy code; line coverage is easy to game.
Exclude generated code from reports so the numbers mean something.
Publish reports as CI artefacts and keep history to see trends, not snapshots.
Coverage is not quality. A line that ran may have no assertion checking it — pair it with mutation testing.
Have one consolidated report. Do not scatter a separate dashboard per language.