COMPLETE GUIDE

User Guide

From your first tracefile to safety-standard compliance gating — everything Fucini Coverage Studio can do, and exactly how to drive it.

Download

1. Introduction

Fucini Coverage Studio turns the coverage tracefiles your build already produces into first-class, in-editor coverage inside VS Code and inside Visual Studio. It reads twenty-five formats, normalises them into one canonical Fucini model, merges multiple runs deterministically, and reports it in the editor itself — gutters, CodeLens, hover and a Covered Files view — so there is no separate viewer to leave your editor for. The two editions share one reader: the same report gives the same numbers, to the digit, in both. This guide is written from VS Code; where Visual Studio differs, an In Visual Studio box says how.

It is built with functional-safety workflows in mind: MC/DC coverage, region and C++ instantiation coverage, a safety-weighted composite score, and a configurable COMPLIANT / NON-COMPLIANT verdict aligned to IEC 61508, ISO 26262 and DO-178C thinking.

Fucini Coverage Studio in VS Code: a file opened from the Coverage view, uncovered lines and half-taken branches in the editor, the MC/DC hover, the heatmap, the status-bar card and the annotated sourceScreenshot pending — add assets/img/marketplace-demo.gif (see SCREENSHOTS.md).

2. Install & requirements

  • VS Code ≥ 1.88 — the minimum version this extension supports — or Visual Studio 2022 or 2026, Community, Professional or Enterprise (see the box below).
  • A coverage tracefile your project already produces (see §4).

Install from the Marketplace, or from a .vsix via Extensions → ⋯ → Install from VSIX…. The extension activates on startup and adds a Coverage icon to the activity bar.

In Visual Studio. The same product ships as a second extension, Fucini Coverage Studio for Visual Studio, for Visual Studio 2022 and 2026 — Community, Professional and Enterprise. It does not use Visual Studio's own code coverage: in Visual Studio 2022 that is an Enterprise feature, so on Community and Professional this is the only coverage the IDE will show. Install the .vsix by opening it — the VSIX Installer asks which Visual Studio — or through Extensions → Manage Extensions; the extension loads when a solution or a folder opens. The Coverage window needs the Microsoft Edge WebView2 Runtime, which Windows 11 and Visual Studio 2026 already bring; the marks in the editor work without it.

3. Quick start

Want to see it working before wiring up your own project? Download the demo project (~6 KB — a tiny C project with a ready-made lcov.info):

  1. Unzip it anywhere, then open coverage-studio-demo.code-workspace in VS Code (File → Open Workspace from File…).
  2. Install Fucini Coverage Studio if you haven't already (see §2 above).
  3. The workspace's own .vscode/settings.json already points at the bundled coverage/lcov.info, so gutters and the Covered Files view appear as soon as the extension activates — no Load Coverage step needed.
  4. Want to regenerate the tracefile yourself (e.g. with a different compiler)? Run scripts/gen-coverage.sh (or .ps1 on Windows) — see the workspace's own README.md for the available compiler targets.

In Visual Studio. Open a solution, or a folder (File → Open → Folder, which is how a CMake project is opened) — the demo above opens as a folder, and its .vscode/settings.json is read there too. A report in the place the settings name is loaded by itself and the Fucini Coverage pane of the Output window says which files; otherwise Tools → Coverage Studio → Load Coverage File…, once — it is remembered. Open a source file and choose Show Coverage in Editor: red is a line that never ran, amber a decision taken only one way, and Ctrl+Shift+U, N walks to the next uncovered line. View → Other Windows → Coverage is the tree with every file's numbers and one score over all of them, which the status bar shows for the run and for the file you are in. Tools → Coverage Studio → Getting Started opens these steps as a page with a button for each; it opens by itself the first time.

  1. Generate a coverage tracefile with your normal test workflow.
  2. Command Palette (Ctrl+Shift+P) → Fucini Coverage: Load Coverage. With watch.enabled on (the default), a matching file loads automatically.
  3. Open a covered source file: the status bar shows its percentage, the Coverage view fills in, hovering a line shows its hit count, and the run appears in the native Test Coverage panel. Bars on uncovered lines, a hit-count heatmap and inline ×N counts are a setting away (editorGutter.mode, hitCounts.inline).
Covered (green) and uncovered (red) gutters in the editorScreenshot pending — add assets/img/gutters.png (see SCREENSHOTS.md).

4. Producing tracefiles

Any of the following are auto-detected on load:

Full copy-paste recipes per compiler — including Swift, Rust, Go, Python, .NET, PHP and more — live on the Coverage Recipes page: Swift · Clang · GCC · Rust · Go · Python · Java/Kotlin · JS/TS · .NET · PHP · Ruby.

C / C++ — LLVM (llvm-cov)

clang --coverage -fprofile-instr-generate -fcoverage-mapping test.c -o test
LLVM_PROFILE_FILE=test.profraw ./test
llvm-profdata merge -sparse test.profraw -o test.profdata
llvm-cov export ./test -instr-profile=test.profdata --format=json > coverage.json

llvm-cov JSON is the richest input — it carries regions, MC/DC and C++ template instantiations in addition to lines, branches and functions.

C / C++ — GCC (gcov → lcov)

gcc --coverage calc.c calc_test.c -o test && ./test
lcov --capture --directory . --output-file lcov.info
# or gcovr --cobertura coverage.xml
# or skip the conversion entirely: gcovr --json coverage.json

JavaScript / TypeScript — Istanbul / nyc

nyc --reporter=json mocha        # emits coverage/coverage-final.json

Java — JaCoCo

mvn test        # emits target/site/jacoco/jacoco.xml

Ruby — SimpleCov

# .resultset.json (built-in) or coverage.json via the simplecov-json gem

Go

go test ./... -coverprofile=coverage.out    # read directly, no conversion

Python — coverage.py

coverage run --branch -m pytest && coverage json    # emits coverage.json

PHP — PHPUnit (Clover)

XDEBUG_MODE=coverage phpunit --coverage-clover clover.xml

.NET / C# — Coverlet (OpenCover)

dotnet test /p:CollectCoverage=true /p:CoverletOutputFormat=opencover

On the Microsoft Testing Platform — xunit.v3 with UseMicrosoftTestingPlatformRunner, MSTest.Sdk, the NUnit and MSTest runners, TUnit — a test project is a program of its own, and on the .NET 10 SDK dotnet test will not start one at all. Run Tests with Coverage sees the platform in the project file and runs each such project as the program it is, with the platform's own flags: dotnet run --project tests/App.Tests/App.Tests.csproj -- --coverage --coverage-output-format cobertura --results-directory <folder>/coverage/App.Tests. --coverage comes from the Microsoft.Testing.Extensions.CodeCoverage package (MSTest.Sdk brings it) — the recipe names the package when no project has it; with Microsoft.Testing.Extensions.TrxReport the run also writes test-results.trx beside the report, so failing tests are marked as for a VSTest run. The report the platform names after a GUID is renamed to coverage.cobertura.xml after the run, as Microsoft's collector's is, so one run's report replaces the last one's. A solution that mixes platform and VSTest test projects runs each its own way, in both editors.

Run Tests with Coverage on an xunit.v3 project on the Microsoft Testing Platform: the terminal runs dotnet run --project with the platform's --coverage flags, and the coverage is loadedScreenshot pending — add assets/img/mtp-run.png (see SCREENSHOTS.md).
Run Tests with Coverage on a test project on the Microsoft Testing Platform: the terminal runs the project as the program it is, with the platform's own flags, and the report it wrote is loaded.
Visual Studio: the Coverage window after Run Tests with Coverage on a solution of two test projects on the Microsoft Testing Platform, one report per projectScreenshot pending — add assets/img/vs-mtp-run.png (see SCREENSHOTS.md).
In Visual Studio: the same run over a solution of two platform test projects, one report per project, each renamed to coverage.cobertura.xml.
FormatTypical fileExtra metrics
LCOVlcov.infolines, branches, functions
llvm-cov JSONcoverage.json+ regions, MC/DC, instantiations
Cobertura XMLcoverage.xmllines, branches
JaCoCo XMLjacoco.xmllines, branches, functions
Istanbul / nyccoverage-final.jsonstatements, branches, functions
SimpleCov.resultset.jsonlines
Clover XMLclover.xmllines, branches, functions
OpenCover XMLcoverage.opencover.xmllines, branches, functions
coverage.py JSONcoverage.jsonlines, branches
gcov / gcovr JSONcoverage.jsonlines, branches, functions
Go coverage profilecoverage.outlines
SonarQube genericcoverage.xmllines, branches
GNATcoverage XML (Ada)*.xmllines, branches, MC/DC
BullseyeCoverage XMLcoverage.xmllines, condition/decision
Visual Studio*.coveragexmllines, branches
Coveralls JSONcoveralls.jsonlines, branches
Xcode xccov JSONcoverage.jsonfunctions and file totals — no per-line data
gcov plain text*.gcovlines, branches, function calls
VectorCASTcoverage.xmllines, branches, MC/DC pairs, functions, function calls
Testwell CTC++*.txtlines, condition/decision
Lauterbach TRACE32*.xmlstatements, decisions, conditions, MC/DC, functions, calls, object code
EMMA XML (Java)coverage.xmllines
UCIS / Aldec UCDB*.xmlstatements, decision branches
NCover XMLCoverage.xmllines, functions
dotCover DetailedXMLdotCover.xmllines, functions
PIT (mutation)mutations.xmlmutation score — contributes no coverage
Stryker (mutation)mutation-report.jsonmutation score — contributes no coverage

A native C++ project, measured from Visual Studio

In Visual Studio. Visual Studio's own coverage of a C++ project was Enterprise-only, and the free OpenCppCoverage plugin that filled the gap was retired. Tools → Coverage Studio → Run Native Project with Coverage takes the startup project — a .vcxproj — asks MSBuild where it builds to and on which toolset, and measures it one of two ways. On the ClangCL toolset, with LLVM's llvm-profdata and llvm-cov on the machine (Visual Studio's C++ Clang tools for Windows component brings them), it builds the project again into coverage\native\ with -fprofile-instr-generate -fcoverage-mapping, through a props file MSBuild is told to import first — nothing in the project changes — runs the program with LLVM_PROFILE_FILE set, merges the profile and exports coverage\native\lcov.info, exact to the region. On any other toolset, with OpenCppCoverage installed, it builds the project as it is — a Debug build has the PDBs — and runs it under OpenCppCoverage, which writes coverage\native\opencppcoverage.xml. Every command goes to the Fucini Coverage pane, and the report is loaded and remembered as a test run's is. A project that cannot be measured is told why and what to install. MSBuild 17.8 (Visual Studio 2022 17.8) or later, for the question it asks.

Visual Studio: Run Native Project with Coverage on a C++ project — the instrumented build, the run, and the gutter filling inScreenshot pending — add assets/img/vs-native-run.gif (see SCREENSHOTS.md).
In Visual Studio: Run Native Project with Coverage on a C++ project — the build, the run, and the editor filling in.

5. Loading & discovery

By default the extension scans from the workspace root. Point it more precisely with two settings:

{
  "fuciniCoverage.coverageFile.defaultLocation": "${workspaceFolder}/build",
  "fuciniCoverage.coverageFile.paths": [
    "coverage.json",
    "reports/*.info",
    "${env:CI_ARTIFACTS}/lcov.info",
    "https://ci.example.com/artifacts/latest/coverage.xml"
  ]
}
  • Each paths entry is relative to defaultLocation (or the workspace root when unset).
  • An entry containing * is searched recursively; a bare filename matches only directly in the base folder.
  • When paths is empty, the extension looks for coverage.json, then lcov.info, loading whichever it finds first.
  • Pick Coverage File uses the files you pick instead of these paths — each pick adds to the set, and all of them are merged — until you unload them or edit these settings.
  • Variables — every path setting expands ${workspaceFolder}, ${workspaceFolderBasename}, ${userHome}, ${env:NAME}, ${command:id} and ${config:section.key}. A variable the extension does not know is left as written, so a typo shows up in the discovery log as the path it looked for rather than vanishing. ${command:id} runs that command first — only in a trusted workspace, for at most five seconds — so ${command:cmake.buildDirectory} follows the selected CMake kit.
  • URL entries — an http(s):// entry is fetched into the extension's storage on every load and loaded from there; the Coverage view names the URL. Each fetch is conditional (ETag / Last-Modified), so an unchanged artifact downloads nothing, and when a fetch fails the last downloaded copy is loaded instead, with the reason in the output. remote.headers adds Name: value headers with variables expanded, remote.refreshMinutes re-fetches on a timer, and a #lcov.info fragment names the format when the URL itself does not end in a file name.
  • Ignore globs — fuciniCoverage.ignore drops whole files (vendored, generated, third-party) from the run as it loads, so every view, gate and export counts without them; the load result says how many were left out and the output names them. Patterns match the workspace-relative and the absolute path, and a pattern with no / matches a folder or file name at any depth, like .gitignore.
  • Multi-root workspaces — every folder is discovered on its own terms: defaultLocation, paths, pathRemap, ignore, watch.* and remote.* are read per folder, so a folder's own .vscode/settings.json or its .code-workspace entry applies, and ${workspaceFolder} in an entry means that entry's own folder. The tracefiles of every folder merge into one run, the Coverage view groups the files by folder, and a folder added to or removed from the workspace reloads coverage by itself.
  • Reload after a task — watch.reloadAfterTasks names tasks (a label from tasks.json, or source: name as the Run Task list shows it) whose ending reloads coverage, whether or not watch.enabled is on — for builds the watcher cannot follow. An absolute paths entry outside the workspace is polled too, so a file appearing there is loaded.
  • Progress you can cancel — a load of ten or more tracefiles, or 8 MB or more of them, runs under a progress notification with a Cancel button that names the file being read and the phase; a smaller one only spins the status bar. Cancelling leaves the previous run loaded and says so.

Since 1.2026.6 an absolute entry may hold a wildcard too: ${workspaceFolder}/build/coverage-merged/*.lcov.info loads every such file in that folder, and ** stands for any depth. The folders before the first wildcard are where it looks, and they are watched, so a report a build writes there loads by itself. The Visual Studio edition reads such an entry the same way, and since 1.2026.5 a relative wildcard is searched at any depth there too, as it always was here.

With no paths configured, the first of the well-known report names found under the base folder is loaded. First the four it always looked for — coverage.json, lcov.info, coverage.out, clover.xml — then, since 0.2026.83, jacoco.xml, coverage.xml, cobertura.xml, coverage.cobertura.xml, coverage.opencover.xml and coverage-final.json, and then the places default configurations write to: coverage/ (nyc, Jest, vitest, PHPUnit, SimpleCov), target/site/jacoco/jacoco.xml (Maven), build/reports/jacoco/test/jacocoTestReport.xml (Gradle) and TestResults/*/coverage.cobertura.xml (dotnet test). So a Java or .NET project shows its coverage on first open, as an lcov project always did.

Since 1.2026.3 a .NET solution needs even less: every test project's TestResults/<run>/ folder is among the well-known places, not only the workspace folder's own, and Microsoft's collector's <user>_<machine>_<date>.cobertura.xml is found beside Coverlet's coverage.cobertura.xml — so a solution whose tests were run in Visual Studio's Test Explorer shows its coverage on first open, every run folder loads, and the merge keeps the newest run's word on each file. And fuciniCoverage.ignore.generated, on by default, leaves designer and generated files — *.Designer.cs, *.g.cs, *.generated.cs, *.razor.g.cs, AssemblyInfo, global usings, Migrations/ and obj/ — out of every total, page and export before ignore is applied, so a generated table nobody tests does not cost the solution its gate.

In Visual Studio: a URL, and a project outside the solution folder. An https:// entry in coverageFile.paths is fetched the way the baseline is — the same remote.headers, the same ${env:…}, the same cache — and loaded like a file beside the solution; when the server does not answer, the copy fetched before stands in and the log says so (FUCINI_REMOTE_001). A project the solution lists from a folder beside its own rather than under it — a solution kept in a build folder of its own, say — is searched for reports and watched for new ones as the solution folder is; the project folders are named in the log at load.

Visual Studio: a tracefile loaded from a URL — the Coverage window names the address it came from, and the editor is painted from itScreenshot pending — add assets/img/vs-remote-tracefile.png (see SCREENSHOTS.md).
In Visual Studio: a tracefile fetched from a URL, named by its address in the Coverage window; when the server does not answer, the copy fetched before stands in.

In Visual Studio: coverage after every test run. Run your tests as you always do. Tools → Coverage Studio → Collect Coverage in Test Explorer… puts one .runsettings with Microsoft's Cobertura collector beside the solution. Visual Studio picks it up when Tools → Options → Test → Auto detect runsettings files is on; otherwise select it once under Test → Configure Run Settings. From then on every run writes a report under the test project, and the watch on the solution loads it the moment it appears, merged with whatever the settings name — from Test Explorer, a terminal or a script alike. Nothing hooks Test Explorer, so Visual Studio 2026 and Microsoft.Testing.Platform work as they are. Run Tests with Coverage is the VS Code command: it recognises dotnet test, vitest, jest, pytest, go, cargo, maven, gradle, phpunit and ctest, runs the tests with coverage on in the Output window and loads what they wrote; a test project without coverlet.collector is run with the collector the test SDK ships, and testRun.skipWhenTestsFail keeps the last good coverage on screen when a run ends red.

A CI artifact behind a token, re-checked every quarter of an hour — the token stays in the environment, never in settings.json:

{
  "fuciniCoverage.coverageFile.paths": [
    "https://ci.example.com/api/builds/latest/artifacts/coverage#lcov.info"
  ],
  "fuciniCoverage.remote.headers": ["Authorization: Bearer ${env:CI_TOKEN}"],
  "fuciniCoverage.remote.refreshMinutes": 15
}
A tracefile loaded from a URL: the Coverage view names the address it came fromScreenshot pending — add assets/img/remote-tracefile.png (see SCREENSHOTS.md).

A reload is silent on purpose — a dialog after every build is a question with one answer. What is not silent is the Coverage icon: while the view is not in front of you it carries the number of tracefiles that have been read again, and its tooltip names them. Open the view and the count is gone.

A build rewrites two reports while the Explorer is open: the Coverage icon in the activity bar gains a count, its tooltip names what reloaded, and opening the view clears itScreenshot pending — add assets/img/coverage-badge.gif (see SCREENSHOTS.md).

Files that should never count, whatever the tracefile says about them:

{
  "fuciniCoverage.ignore": ["vendor/**", "**/*.generated.ts", "build/**"]
}

A reload when the test task ends, for a build the file watcher cannot follow — a run that replaces a symlinked output tree, a report on a network share, a coverage step that post-processes its file:

{
  "fuciniCoverage.watch.reloadAfterTasks": ["npm: test", "coverage-report"]
}

6. Merging runs

Every existing paths entry is loaded and merged into one run. The merge is deterministic — the result does not depend on load order — and a file measured by more than one tracefile takes its numbers from whichever has the newest mtime on disk: a module’s own rerun replaces what a wider, older run said about it rather than adding to it. The Coverage view shows what that did: every file row names the tracefile its numbers came from, the badge is outlined where those numbers overruled an older report, each tracefile row above the tree counts how many of its files were overruled or overruled others, and clicking a tracefile row highlights its files in the tree until it is clicked again (coverageView.mergedMarks turns the outline and the highlight off).

Four reports merged onto one source file: llvm-cov brings lines, functions, regions, branches, MC/DC and instantiations, two TRACE32 exports bring function calls and object code, and a mutation report brings the mutation scoreScreenshot pending — add assets/img/four-reports-one-file.svg (see SCREENSHOTS.md).

A merged run can carry more than the six classic metrics, each from the report that measures it: function calls, object code and a mutation score next to lines, functions, regions, branches, MC/DC and instantiations. The Coverage view shows a column for every metric the run carries — and none for one it does not — ordered by the weight each metric carries in your score, heaviest first and at any width: what will not fit scrolls sideways rather than disappearing. Drag the view into the bottom panel and it becomes a table. The status-bar cards, the HTML report and the CSV and Markdown exports follow the same rule: what a report carries is shown, what it does not carry is left out rather than printed as a zero.

The Coverage view in a real window: eight tracefiles from five languages above a tree with MC/DC, Conditions, Branches, Regions and the weighted score in columns beside every file, and a covered C# file open next to itScreenshot pending — add assets/img/coverage-view-editor.png (see SCREENSHOTS.md).
The Coverage view as a wide panel: C, C++, JavaScript, Python and .NET merged into one tree, with MC/DC, branches, regions, functions, lines, instantiations, mutation score, Max CRAP and the weighted score in columns beside every file, and an em dash where a metric does not applyScreenshot pending — add assets/img/coverage-view-columns.png (see SCREENSHOTS.md).
The Coverage view over a workspace of eleven projects: every tracefile listed, the tree collapsed to one row per project with its percentage and bar, scrolled through, expanded, and a file opened from itScreenshot pending — add assets/img/workspace-overview.gif (see SCREENSHOTS.md).
Visual Studio: the Coverage window over a folder of eleven projects — collapsed to one row per project with its bar, then expanded, then a file opened from itScreenshot pending — add assets/img/vs-workspace-overview.gif (see SCREENSHOTS.md).
In Visual Studio: the Coverage window over a folder of eleven projects — collapsed to one row per project with its bar, then expanded, then a file opened from it.

Which report a file comes from

When several loaded reports measure the same file, the newest one wins it outright — right when a module's own rerun replaces what an older, wider run said. It is wrong when the reports measure the same code on purpose: then the editor flips between them with every build, and each tells only part of the story. coverageFile.sources says what to do instead, per file. Three situations call for it:

  • One report is the better one. llvm-cov's coverage.json carries MC/DC, a GCC gcov.info of the same build only lines and branches: pick coverage.json, and keep the other for the few files only GCC builds.
  • Several test suites of one build. Unit tests, integration tests and hardware-in-the-loop each write a report; each on its own leaves lines the others ran. Combine, union: a line is covered where any report ran it, and the counts add up.
  • One code base, two compilers. The same sources built by clang and by GCC take different paths through toolchain-specific code — an intrinsic here, a portable fallback there — and each report says the other half never ran. Combine, agree: a line is covered only where every report that measures it ran it, and the lines they disagree on are marked in teal. That is the question a cross-compiler check asks: what did every build I ship actually exercise?

You rarely write the rules by hand. Right-click a file in the Coverage view and choose Choose Coverage Source... (or run Choose Coverage Source for This File... on the open file): it lists every report that measures the file, each with its own lines, branches and MC/DC, then Combine them — agree and Combine them — union; pick one and say whether it holds for the file, its folder or a pattern. Clear Coverage Source for This File... takes the rule out again. In the settings each rule is a glob over the files, a glob over the report (a pattern without / matches the report's file name, {a,b} names several) and, to combine, "combine": "agree" or "union". The first rule whose files match and whose report measures the file decides; a file only one report measures is never taken from it. Branches, MC/DC and regions of a combined file come from the report richest in them. coverageFile.mergeStrategy: "order" settles the files no rule speaks for by the order of coverageFile.paths instead of the times.

{
  "fuciniCoverage.coverageFile.paths": ["clang.json", "gcc/bits.gcov.json.gz"],
  "fuciniCoverage.coverageFile.sources": [
    { "files": "src/**", "report": "{clang.json,bits.gcov.json.gz}", "combine": "agree" }
  ]
}

What you see: the file's row in the Coverage view names the report its numbers come from, or, combined, every report and the mode with ≠ n for the lines in dispute. The gutter and the Annotated Source mark those lines in teal and say which report ran them how often. The status bar's hover card names the source of the open file and, for the whole run, the rules in force and how the other files were decided. The demo's samples/c-cross-check is the two-compiler case, ready to open. Visual Studio does all of this too: Choose Coverage Source... on a row of the Coverage window, and Choose and Clear Coverage Source for This File... under Tools > Coverage Studio.

Choosing and combining sources is part of the paid plans. On Community the newest report wins every file, as it does with no rule, and a rule in the settings is said to be unused rather than silently ignored.

Choose Coverage Source on bits.c: clang.json with lines, branches and MC/DC, bits.gcov.json.gz with lines and branches, and the two ways to combine them
In VS Code: Choose Coverage Source... on bits.c from the Coverage view — the clang report, the GCC report, or both combined.
Animation in VS Code: bits.c combined by agree with four teal lines, Choose Coverage Source opened from the Coverage view, and the file reloaded combined by union
In VS Code: from agree to union in two clicks — the disputed lines stay teal, the numbers change.
Animation in Visual Studio: bits.c combined by agree, the Coverage window's row menu, Choose Coverage Source and its two dialogs, and the file reloaded combined by union
In Visual Studio: the same from the Coverage window's row menu — the reports, then how far the rule reaches, then the file loaded again.
bits.c with the clang and GCC reports combined by agree: the Coverage view row names both reports with four disputed lines, and the builtin and the portable loop are marked in teal
In VS Code: bits.c, clang and GCC combined by agree — the row says ≠ 4, and the four lines only one build ran are teal.
bits.c with the clang and GCC reports combined by union: every line covered, the four disputed lines still teal, and the status bar naming the union
The same file combined by union: every line either build ran is covered, so bits.c reaches 100% of its lines — and the lines the builds disagree on stay teal.
The Annotated Source of bits.c, combined by agree: the source line under the title names both reports, and each teal row says how often each report ran it
The Annotated Source names the combination under the title, and every teal row how often each report ran it.
The status bar's hover card for bits.c, ending with the coverage source: both reports, combined by agree, disagreeing on four lines
The file's hover card in the status bar says where its numbers come from; the run's card counts the files each rule decided.
Visual Studio: Choose Coverage Source on bits.c from the Coverage window's row menu — the clang report, the GCC report and the two ways to combine them; behind it the row's agree badge with four disputed lines and the teal lines in the margin
In Visual Studio: Choose Coverage Source... from a row of the Coverage window — the same reports and the same two ways to combine them; the status bar names the combination.

7. Path remapping

CI often records absolute build-machine paths that don't exist on your workstation. Rewrite them with ordered rules:

{
  "fuciniCoverage.pathRemap": [
    { "from": "/builds/ci/project", "to": "${workspaceFolder}" },
    { "from": "\\\\", "to": "/" }
  ]
}

Rules apply in order; the first match wins per prefix. Use this to fold Windows/Unix separator differences or map a container path onto your checkout.

You rarely have to write the rule yourself. The most common “it loaded but nothing lights up” is a tracefile whose paths come from a container or a CI checkout (/build/src/a.c, /home/runner/work/repo/repo/src/a.c, C:\agent\_work\1\s\src\a.c) while the workspace has src/a.c. When a load leaves files unmatched, the extension looks the file names up in the workspace, infers the prefix rule that explains the most of them, logs it as [FUCINI_REMAP_002], and the load result offers Apply Suggested Remap — one click appends the rule to fuciniCoverage.pathRemap and reloads. Suggest Path Remap Rule runs the same analysis on demand from the palette. Nothing is written without the click.

A to may use ${workspaceRoot}, which stands for the workspace folder the tracefile lives in; in a multi-root workspace it tries that folder first, then every other folder that turns out to have the file. The rules themselves are read per folder, so each root of a multi-root workspace can carry its own.

8. In-editor coverage

  • Gutters & ruler — by default the editor's own gutter shows only findings: MC/DC bars, since-last-run triangles, edited-line dots. editorGutter.mode adds uncovered-only bars or a hit-count heatmap (below); the colour-coded view of a whole file is the Annotated Source.
  • Function CodeLens — coverage % above each function; click to jump to its first uncovered line. Toggle with codeLens.enabled.
  • Branch & MC/DC hover — hover a decision line for per-arm taken/not-taken counts and a per-condition vector table. Enable a coloured margin bar with mcdcGutter.enabled.
  • Dead-code warnings — functions with measurable lines and zero coverage are flagged in the Problems panel (deadCode.enabled).
  • Next / Previous Uncovered — jump between gaps.
  • Status bar — a run-wide $(dashboard) NN% item and a per-file item, both colour-coded by the composite score; hover for a full metrics table.
  • Explorer badges — per-file and per-folder coverage badges, with the metric breakdown on hover. Off by default: turn them on with explorerBadges.enabled.
  • Since last run — a red triangle on every line executed in the previous run and not in this one, a green one for the reverse, with the overview ruler and the hit counts on hover.
  • Edited buffers — every mark, hover and CodeLens moves with the text as you edit, and withdraws from a rewritten line, where a grey dot says why.
  • Inline hit counts — hitCounts.inline writes ×12 after each line a statement starts on, ×0 included: the number that has always been on hover, without hovering. Toggle Inline Hit Counts flips it; the status-bar menu offers it as Show or Hide, whichever applies.
  • Per-line Problems entries — problems.perLine puts an Information diagnostic, with a squiggle in the editor, on every contiguous block of lines that never ran in an open document (a forty-line dead function is one entry, not forty) and, as uncoveredAndPartial, on every line whose branch arm was never taken. The entries follow their lines as you edit and go when the document closes; the per-file entry behind problems.enabled is unchanged.
  • Line tint — lineHighlight puts a translucent wash behind the lines themselves for what the gutter marks (uncovered, or heatmap for the executed lines as well). Its own setting, so the gutter can stay clean while the gaps are tinted, or the other way round.
  • Overview ruler — overviewRuler decides the scrollbar stripe independently of the gutter: follow (with the bars, as before), uncovered (always, so the gutter can be off and the scrollbar still maps the file's gaps) or off.
  • Which tracefile covered a line — with several reports merged, the hit-count hover ends with Covered by: and each report that covered that line, lcov's TN: suite name included; clicking a tracefile row in the Coverage view lights the lines it contributed in every open editor.
Function CodeLens and MC/DC hover tooltipScreenshot pending — add assets/img/codelens-hover.png (see SCREENSHOTS.md).
A function CodeLens on a C# method: 37.14% covered, 13 of 35 lines, branches 10 of 22, complexity 22, CRAP 142.2 — with the uncovered branches of the method marked underneathScreenshot pending — add assets/img/codelens-crap.png (see SCREENSHOTS.md).
Alt+N jumps from one uncovered line to the next, Alt+P goes backScreenshot pending — add assets/img/jump-between-gaps.gif (see SCREENSHOTS.md).
Explorer badges: a coverage percentage on every measured file and folder of all five demo projects, beside a covered C# file with its gutters, hit counts and CodeLensScreenshot pending — add assets/img/explorer-badges.png (see SCREENSHOTS.md).

Editor gutter modes

editorGutter.mode decides what the editor's own gutter shows about coverage, on top of the findings it always shows. off (the default) is only those. uncovered puts a bar on every line that never ran and an amber one on every line with a branch arm never taken, and nothing on covered lines, so a green wall does not hide the three red ones. coverage adds a green bar on every covered line, so the whole file reads red, amber and green in the colour scale's colours. heatmap adds a warm shade on every executed line instead, hotter the more often it ran — it shows how often a line ran, not whether it is covered, so a file at 100% is yellow to brown there, never green. Choose Editor Gutter Mode... picks one from the palette or the status-bar menu; the mode button at the right of the status bar, or Alt+G, moves on to the next with one press (statusBar.showModeToggle hides the button). Both write the setting. The example turns on the uncovered bars and the inline counts together:

{
  "fuciniCoverage.editorGutter.mode": "uncovered",
  "fuciniCoverage.hitCounts.inline": true
}
Uncovered mode: a red bar and wash on lines that never ran, amber on a line with a branch arm never taken, and the execution count written after each lineScreenshot pending — add assets/img/gutters.png (see SCREENSHOTS.md).
The coverage mode in VS Code: green bars on lines that ran in full, amber where a branch arm never did, red where nothing ran; the status bar names lcov.info as the report and the mode button reads Coverage
In VS Code: the coverage mode — green where a line ran in full, amber where a branch arm never did, red where nothing ran. The file’s status-bar item names the report its numbers come from; the mode button beside it says Coverage.
Alt+G pressed four times: heatmap, off, uncovered and back to coverage
In VS Code: Alt+G four times — heatmap, off, uncovered, and back to coverage.
Visual Studio: Gutter: Coverage on Quote.cs, green, amber and red bars beside the hit counts
In Visual Studio: Gutter: Coverage (Red, Amber, Green) on Quote.cs.

The heatmap is relative to the file. The shade of a line compares its count with the hottest line of the same file, on a logarithmic scale, in five steps — so a loop body that ran a thousand times and a function that ran twice are both visible, rather than one drowning the other, and a file where everything ran exactly once is uniformly warm rather than uniformly pale. On a dark theme the ramp runs from dim olive to vivid orange, on a light theme from pale yellow to brown: either way more colour means more executions, and red stays reserved for lines that never ran. lineHighlight: "heatmap" puts the same shades behind the code as a wash, and hitCounts.inline writes the exact count after the line.

{
  "fuciniCoverage.editorGutter.mode": "heatmap",
  "fuciniCoverage.lineHighlight": "heatmap",
  "fuciniCoverage.hitCounts.inline": true
}
The heatmap on a dark theme: functions that ran once in dim olive, the decision that ran five times in vivid orange, lines that never ran in redScreenshot pending — add assets/img/heatmap-dark.png (see SCREENSHOTS.md).
The same file on a light theme: pale yellow for lines that ran once, brown for the hottestScreenshot pending — add assets/img/heatmap-light.png (see SCREENSHOTS.md).
Switching from uncovered mode to the heatmap, on a dark and then on a light themeScreenshot pending — add assets/img/heatmap.gif (see SCREENSHOTS.md).

The colours are yours. colorScale.lowColor, midColor and highColor paint the red, amber and green of the gutter, the washes and every percentage; heatmap.colors and heatmap.colorsDark hold the heatmap's five shades for a light and a dark theme, from the line that ran least to the one that ran most. The settings page shows the result before anything is saved: under Colour scale, a preview stays in view while the rows scroll past — the gradient with its two pivots, a few percentages in their colours, and a small light and a small dark editor painted in the coverage mode and in the heatmap — and it repaints as a colour is picked.

{
  "fuciniCoverage.heatmap.colors": ["#e3f2fd", "#90caf9", "#42a5f5", "#1e88e5", "#0d47a1"]
}
The settings page in VS Code: two colours typed in, the pinned colour preview repainting each time
In VS Code: two colours typed into the settings page — the preview repaints each time.
Visual Studio: the same settings page and the same colour preview
In Visual Studio: the same page, the same preview.

The part of a line that never ran

A line is covered or it is not, and the truth is often in between: return x > hi ? hi : x; ran, its hi arm never did. With lineHighlight on, the never-executed part of an executed line is tinted in the editor, for every format that carries column ranges (llvm-cov, Istanbul, Go, dotnet-coverage) — the same spans the annotated source marks. Only on lines that ran: a line that never ran is already marked as a whole. A C++ template counts as executed where any instantiation executed it; what each instantiation did is what the instantiation metric reports.

An executed line whose opening brace is tinted: the if ran, the block it opens never didScreenshot pending — add assets/img/partial-line.png (see SCREENSHOTS.md).

Which tests ran this line

Some reports say not only that a line ran but which tests ran it: coverage.py written with coverage json --show-contexts and dynamic_context = test_function in .coveragerc, OpenCover collected with -coverbytest, and an lcov tracefile written one section per test (TN:), whose sections are added up into one record with a test per line. Hover the start of a line, where the hit count is, and the tests are named — shortened to class and method, the first five by name and the rest as a count; the function's CodeLens says how many tests ran it. Show Tests That Ran This Line — the Command Palette, the editor's context menu, in Visual Studio Tools → Coverage Studio or Ctrl+Shift+U, T — lists them, busiest first, and opens the one you pick where it is written in the workspace. A dotnet test run cannot say which test ran what; set testRun.perTest and Run Tests with Coverage lists the test classes and runs them one at a time, each report tagged with its class, so the hover, the lens and the command can answer for .NET too. It is kept per file, so it survives a merge with a report that knows nothing about tests.

{
  "fuciniCoverage.testRun.perTest": true
}
# .coveragerc
[run]
dynamic_context = test_function

coverage run -m pytest && coverage json --show-contexts
Hovering the start of two lines of a Python file: each names the tests that ran it; an uncovered line names noneScreenshot pending — add assets/img/tests-per-line.gif (see SCREENSHOTS.md).
Show Tests That Ran This Line: the caret on a line, the list of tests that ran it busiest first, and the picked test opened where it is writtenScreenshot pending — add assets/img/tests-for-line.gif (see SCREENSHOTS.md).
Show Tests That Ran This Line: the list, busiest first, and the test opened where it is written.
Visual Studio: the caret on line 62 of Quote.cs, Show Tests That Ran This Line, the dialog listing Tests.QuoteTests, and Go to Test opening QuoteTests.cs
In Visual Studio: Show Tests That Ran This Line on line 62 of Quote.cs — the test that ran it, and Go to Test opening it.

Pass or fail on the marks

A covered line looks the same whether its test passed or not. Where the report says which tests ran a line and the runner's results file says how they ended, a line that a failing test ran gets a red bar at its start and a stripe in the overview ruler; its hover names the failing tests, and Show Tests That Ran This Line writes failed beside each. The place to look when a test is red is the code it went through. The results are read at every load from the folder of each report — any .trx, and the names the JUnit writers use (TEST-*.xml, junit*.xml, test-results*.xml) — and from testResults.paths, as paths or globs relative to the folder. Run Tests with Coverage asks dotnet test for a test-results.trx beside the report, so with testRun.perTest on nothing has to be set up. testResults.enabled turns the reading off.

{
  "fuciniCoverage.testResults.paths": ["build/test-results/**/*.xml", "reports/junit.xml"]
  }
A failing test: a red bar on the lines it ran, the hover naming it under Failing tests that ran this line, and Show Tests That Ran This Line writing failed beside itScreenshot pending — add assets/img/pass-fail.gif (see SCREENSHOTS.md).
Visual Studio: a failing test — the red bar on the lines it ran, the hover naming it, and Show Tests That Ran This Line writing failed beside itScreenshot pending — add assets/img/vs-pass-fail.gif (see SCREENSHOTS.md).
In Visual Studio: a red test — the red bar on the lines it ran, the hover naming it, and Show Tests That Ran This Line writing failed beside it.

The tests a change touches

A full run answers slowly what Run Tests Affected by My Changes… answers at once: of all the tests, which went through the code I just edited? git is asked for the working tree's diff against testImpact.baseRef — HEAD by default, which is what is not committed yet; origin/main for everything the branch changes — and the tests that ran a changed line are listed, the one that ran most of the change first. Picking a test opens it. Where the reports came from a per-test run (testRun.perTest), the first entry runs only those tests, each class into its own report, so every other class's report stands and the totals stay the whole suite's. A test that only ran lines below an insertion or a removal is listed too: its report would otherwise name the wrong lines.

An uncommitted edit, Run Tests Affected by My Changes…, the list with the test that ran most of the change first, and the run of only those testsScreenshot pending — add assets/img/test-impact.gif (see SCREENSHOTS.md).
Visual Studio: an edit, Run Tests Affected by My Changes…, the list with the test that ran most of the change first, and the run of only thoseScreenshot pending — add assets/img/vs-test-impact.gif (see SCREENSHOTS.md).
In Visual Studio: an edit, Run Tests Affected by My Changes…, the list with the test that ran most of the change first, and the run of only those.

The fewest tests that still run every line

Show Minimal Test Set… answers two questions from the same per-test lines: which few tests would still run every line the suite runs — for the quick run before a commit — and which tests run no line that another does not run already. The chosen tests come first, each with the lines it adds and the lines only it runs; then the rest, each marked as adding nothing. The choice is the greedy one — the test that runs most, then the one that adds most to that — so it is close to the smallest set and the same every time. Redundant by lines is not redundant by what a test checks: a test that adds no line may still be the only one that asserts a value on those lines. The list says where to look when a suite is pruned, never what to delete.

Show Minimal Test Set…: the chosen tests first, then the tests that add nothingScreenshot pending — add assets/img/minimal-test-set.png (see SCREENSHOTS.md).
Visual Studio: Show Minimal Test Set… — the chosen tests, then the tests that add nothingScreenshot pending — add assets/img/vs-minimal-test-set.png (see SCREENSHOTS.md).
In Visual Studio: Show Minimal Test Set… — the chosen tests, then the tests that add nothing.

Run this test, with coverage

Put the caret in a test and run Run This Test with Coverage — the Command Palette, the editor's context menu, in Visual Studio Tools → Coverage Studio or Ctrl+Shift+U, R — and that test alone runs with coverage on: the test method the caret is in, or the test class or describe block when it is between methods, or the file when it is above every class. What is under the caret is read off the text, so it works for C#, VB and F# ([Fact], [Test], [TestMethod] and the like), JavaScript and TypeScript (it, test, describe) and Python (def test_…) whatever language service is installed. The folder's recipe is narrowed to it — dotnet test --filter "FullyQualifiedName~…", jest or vitest <file> -t "…", a pytest node id — and what it wrote is loaded like any run; a runner that cannot be narrowed says so and Run Tests with Coverage runs them all.

Run This Test with Coverage: the caret in a Fact, the one dotnet test --filter run in the terminal, the gutter of the class under test filling inScreenshot pending — add assets/img/run-this-test.gif (see SCREENSHOTS.md).
Run This Test with Coverage: one test, one run, the class under test lit.
Visual Studio: the caret in the Fact AGoldCustomerGetsTenPercent, Run This Test with Coverage, the run appearing in the Tracefiles list and the lenses saying run by 1 test(s)
In Visual Studio: Run This Test with Coverage in a [Fact] — the run in the Tracefiles list, the lenses saying one test ran the code.

Go and Rust. In a Go file the caret's func TestXxx (or Fuzz…, Example…) runs alone, in its own package and by its exact name — go test ./pkg/calc -run "^TestTotal$" — and outside a test the file's package runs. In a Rust file the #[test] function runs by its path in the crate with --exact; with the caret in a mod and in no test, that module's tests run; an integration test under tests/ runs in its own binary (--test api). A runner is only handed files of its own language: a TypeScript file in a Go folder gets a sentence, not a run of nothing.

On the Microsoft Testing Platform the run is the test project's own program and the filter is the framework's: xunit.v3's exact --filter-method for a test and --filter-class for a class — Ns.Quote no longer also runs Ns.QuoteBuilderTests — the VSTest --filter for MSTest and NUnit, TUnit's --treenode-filter. A nested class is Ns.Outer+Inner, as the test listing prints it, for the per-test mode too.

Coverage after every save

With testRun.onSave on, saving a source runs the tests that cover it, with coverage, a moment after the save, and the gutter follows. For a .NET solution the saved file's project is found through the .csproj graph and only the test projects that reference it — directly, or through other projects — are run, one dotnet test <project> each; any other runner runs its whole recipe; a file no project owns and no report measures runs nothing. Several saves in a row are one run, and a run already going is not interrupted. The rest is as Run Tests with Coverage does it: the terminal, the Output pane, the report loaded. Off by default — it is a habit to choose, not a default to discover.

{
  "fuciniCoverage.testRun.onSave": true
}
Coverage after every save: an edit to a C# file, Ctrl+S, the covering test project runs by itself, and the gutter changesScreenshot pending — add assets/img/coverage-on-save.gif (see SCREENSHOTS.md).
Coverage after every save: edit, save, and the gutter follows a moment later.
Visual Studio: with testRun.onSave on, a comment line added to Quote.cs and saved, the tests running by themselves and the lens above Price changing
In Visual Studio: testRun.onSave on — Quote.cs saved, the tests running by themselves, the lens above the method changing.

The app itself, with coverage

A test run says what the tests reach. What a person reaches — clicking through the screens before a release, replaying a customer's steps — is coverage too, and Run App with Coverage… collects it. The folder's .NET app — an Exe, a WinExe, a web or worker project, never a test project; a pick where there are several — is started under Microsoft's dotnet-coverage in a console of its own, so that a console app can be typed into, and runs until you close it. What you walked through is then loaded like any run, and in a coverage session it is added to what the tests ran. How the app ended is not held against the run. It needs the tool once: dotnet tool install --global dotnet-coverage.

Run App with Coverage…: the console app started under dotnet-coverage, a few inputs, closed, and its coverage loadedScreenshot pending — add assets/img/run-app.gif (see SCREENSHOTS.md).
Visual Studio: Run App with Coverage… — the console app, a few inputs, closed, and its coverage loadedScreenshot pending — add assets/img/vs-run-app.gif (see SCREENSHOTS.md).
In Visual Studio: Run App with Coverage… — the console app, a few inputs, closed, and its coverage loaded.

Mutants, where they are

A mutation tool — PIT for Java, Stryker for JavaScript, C# and Scala, Mull for C and C++ — changes your code in small ways and runs the tests against each change. A change no test notices is a surviving mutant: the code ran, and nothing checked what it did. The mutation score says how many were caught; since 0.2026.83 the editor says where the others are. A line with one carries a note after it (⚑ 2 mutants survived), the changed text is underlined where the report says which text that was (Stryker and Mull do), the overview ruler has a stripe, and hovering shows what was changed, how many tests ran it, and for the mutants that were caught, which test caught them.

A surviving mutant in the editor: the note after the line, the underlined text, and the hover naming the change — ConditionalBoundary: value <= loScreenshot pending — add assets/img/mutant-hover.png (see SCREENSHOTS.md).

Survived means tests ran the changed code and all passed. Untested (the report's no coverage) means no test runs that code at all, so nothing could have noticed. Mutants that were caught are counted on hover and never marked, and mutants that were never a fair test — one that would not compile — are outside the score. The annotated source has a row under each such line and a Next Mutant button (U), and the HTML reports have a Surviving Mutants section that links to the line. Nothing needs switching on, and a project without a mutation report sees nothing of it.

Surviving mutants marked in the editor, the hover naming the change, and the annotated source jumping from one to the next with UScreenshot pending — add assets/img/mutants.gif (see SCREENSHOTS.md).

Would a test notice? A mutation run at the caret

A project's mutation run takes an hour; one function's takes a minute. Run Mutation Tests Here runs that minute: the function the caret is in — or the lines selected, or the file — is what the folder's mutation runner is told to mutate, and its report is loaded beside the coverage on screen, where the surviving mutants are marked. For C# it is Stryker.NET (dotnet tool install --global dotnet-stryker), told the span of characters and the test project that reaches the file's project; for JavaScript and TypeScript StrykerJS, told the lines; for Java PIT with Maven, told the class. How the runner ended is not held against the run: a score under its threshold is an exit code, and still a report. A runner that wrote nothing is said, with what it needs installed.

Run Mutation Tests Here on one function: Stryker.NET runs that minute, and the surviving mutants are marked in the editorScreenshot pending — add assets/img/mutation-here.gif (see SCREENSHOTS.md).
Visual Studio: Run Mutation Tests Here on one function, and the surviving mutants markedScreenshot pending — add assets/img/vs-mutation-here.gif (see SCREENSHOTS.md).
In Visual Studio: Run Mutation Tests Here on one function, and the surviving mutants marked.

VS Code's own Test Coverage view

With testCoverage.publish on (the default), every loaded run also goes to the editor's native Test Coverage view — the Test Explorer's coverage panel, the per-file percentages it puts in the Explorer, and the editor's own Show Inline Coverage toggle — as lines, branch arms and functions, with the details loaded on demand, whatever tracefile they came from and with no test adapter involved. Show in Test Coverage View publishes the active run and opens the panel whatever the setting says; the status-bar menu offers it behind quickActions.showTestCoverage. Off, no Fucini Coverage entry appears in the Test Explorer at all. When a tracefile names its tests (lcov’s TN: sections), each test appears under Fucini Coverage in the Test Explorer and the view can filter a file’s coverage by test.

VS Code's own Test Coverage view filled from the loaded reports, one bar each for statements, branches and functionsScreenshot pending — add assets/img/test-coverage-view.png (see SCREENSHOTS.md).

Uncovered lines in the Problems panel

Off by default because it is noisy by nature, and only ever for the documents that are open — a two-thousand-file run cannot flood the panel. Independent of problems.enabled, which keeps to one entry per file:

{
  "fuciniCoverage.problems.perLine": "uncoveredAndPartial"
}
The Problems panel: one entry per file below the statement threshold, and a possible-dead-code entry for every function that never ranScreenshot pending — add assets/img/problems-panel.png (see SCREENSHOTS.md).

9. Diff coverage

Restrict decorations to lines that changed versus a git base ref — ideal for reviewing exactly what a PR did or didn't cover:

{
  "fuciniCoverage.gitDiff.enabled": true,
  "fuciniCoverage.gitDiff.baseRef": "origin/main"
}

Choose Diff Base… picks the ref from the repository's own branches and tags — the ref in force first, then the local branches, then the remote ones — with a last entry for typing a tag, a commit or any other ref, and writes it to gitDiff.baseRef for the folder. Diff coverage, the new-code gate and the indirect changes all diff against it; a base spelled wrong by hand (origin/main where the remote has master) gave a diff of nothing and said nothing. In Visual Studio the command is under Tools → Coverage Studio, and the list comes from git for-each-ref.

Choose Diff Base…: the picker with the ref in force first, the local branches, a tag and the entry for typing one; a branch picked; the coverage reloaded against itScreenshot pending — add assets/img/choose-diff-base.gif (see SCREENSHOTS.md).
Choose Diff Base…: the ref in force first, then the repository's branches and tags, then the entry for typing one; the pick is written to the folder's settings and the run reloads against it.
Visual Studio: the Choose Diff Base dialog over the editor, listing HEAD as current, two branches, a tag and the entry for typing a refScreenshot pending — add assets/img/vs-choose-diff-base.png (see SCREENSHOTS.md).
In Visual Studio: the same list in a dialog, from git for-each-ref.
Diff coverage: only the five lines changed against the base ref are marked and judged — 5 of 5 lines, 7 of 8 branchesScreenshot pending — add assets/img/diff-coverage.png (see SCREENSHOTS.md).

In Visual Studio. The same two settings, read from the same files: the extension runs git diff <baseRef> itself for every file of the run and cuts the run down to the lines your branch changed — in the margin, in the Coverage window and in the gates. The Output pane says what git answered when it answers nothing.

A gate on new code

threshold.newCode is a gate of its own, beside the ones on the whole run: of the lines changed against gitDiff.baseRef that can be measured, the least percentage that must have run. A project at 62% overall can still ask that what is written today is tested. It is counted at every load on the whole run, which stays on screen — gitDiff.enabled is the other thing, the changed lines in the place of the run. Check Coverage Thresholds and the compliance entries in Problems fail it in a sentence of its own: New code 72.00% < 80% (18 of 25 line(s) changed against origin/main ran). A change with no line that can be measured — comments, a README — fails nothing.

{
  "fuciniCoverage.threshold.newCode": 80,
  "fuciniCoverage.gitDiff.baseRef": "origin/main"
  }
Check Coverage Thresholds failing New code 72.00% < 80% beside a run that passes its own gatesScreenshot pending — add assets/img/new-code-gate.png (see SCREENSHOTS.md).
Visual Studio: Check Coverage Thresholds failing the new-code gate in the Error List, beside a run that passes its own gatesScreenshot pending — add assets/img/vs-new-code-gate.png (see SCREENSHOTS.md).
In Visual Studio: Check Coverage Thresholds failing the new-code gate, beside a run that passes its own gates.

New code by tag, by author, by date

New code is by default the lines the working tree changes against gitDiff.baseRef — a branch, a commit, or a tag: "v1.4.0" is everything since that release. Two settings ask what a ref cannot. gitDiff.author takes part of an author's name, and new code is then the lines git gives to that author; gitDiff.since takes a day, and it is the lines last changed on that day or later, whatever branch they came in by; both together, that author's lines since that day. They are read off git blame, a file at a time — which a large run will feel at every load — and take the diff's place for diff coverage and for the gate above. A line not committed yet counts either way.

{
  "fuciniCoverage.gitDiff.author": "Ada",
  "fuciniCoverage.gitDiff.since": "2026-09-01"
  }
The same gate scoped by author and date: new code by Ada since 2026-09-01Screenshot pending — add assets/img/new-code-author.png (see SCREENSHOTS.md).

Indirect changes: what moved though nobody touched it

A diff says which lines changed; two runs say which lines stopped or started running. The lines worth a look are the ones where the two disagree: code nobody edited that no longer runs, because a test was deleted, a branch upstream returns early now, a fixture changed. A review of the diff cannot see them — they are outside it by definition. Show Indirect Coverage Changes… lists them per file, the file that lost most first, and opens the one you pick at its first such line. The run is held against the CI baseline where baseline.report names one — which is what a pull request is judged by — and against the run before it otherwise; the lines the working tree changes against gitDiff.baseRef, and everything below a place where that change moves the file's lines, are left out.

Show Indirect Coverage Changes…: a file that lost lines nobody edited, after a test was removed between two runsScreenshot pending — add assets/img/indirect-changes.png (see SCREENSHOTS.md).
Visual Studio: Show Indirect Coverage Changes… — a file that lost lines nobody editedScreenshot pending — add assets/img/vs-indirect-changes.png (see SCREENSHOTS.md).
In Visual Studio: Show Indirect Coverage Changes… — a file that lost lines nobody edited, after a test was removed between two runs.

10. The composite score

Rather than reporting six numbers, the extension folds them into one Weighted Harmonic Mean (WHM). For metrics with percentages pᵢ and weights wᵢ:

WHM = ( Σ wᵢ ) / ( Σ wᵢ / pᵢ )

A harmonic mean is dominated by its smallest term, so a weak metric cannot be masked by a perfect one — exactly the property you want from a safety gate. Default weights:

MetricWeightRationale
MC/DC4IEC 61508 SIL 3–4 / ISO 26262 ASIL C–D / DO-178C DAL A–B.
Branches2IEC 61508 SIL 2+ / ISO 26262 ASIL B+.
Conditions3Between branches and MC/DC (DO-178C, ISO 26262).
Regions1.5Sub-statement paths (e.g. partial short-circuit).
Lines1IEC 61508 SIL 1+ / ISO 26262 ASIL A+.
Functions1Dead-code gate.
Instantiations0.5C++ template coverage; narrowest scope.
Function calls1Call sites that were executed (gcov, VectorCAST, Testwell CTC++, TRACE32).
Object code0Off unless you give it a weight: it subsumes statement coverage.
Mutation score0Off unless you give it a weight: it is not coverage.

Set any weight to 0 to drop that metric from the score. Metrics not present in the data (e.g. MC/DC in a plain lcov run) are simply omitted.

Object code and the mutation score weigh 0 until you decide otherwise (whmWeights.objectCode, whmWeights.mutation). Object-code coverage subsumes statement coverage, so weighing both counts the same evidence twice; a mutation score is not coverage at all — a suite can run every line and detect nothing. Both still have a column of their own and a threshold of their own.

The default weights of the composite score: MC/DC 4, branches 2, regions 1.5, lines, functions and function calls 1, instantiations 0.5; object code and mutation score 0 until given a weightScreenshot pending — add assets/img/score-weights.svg (see SCREENSHOTS.md).

Condition coverage

a && b is one decision — two branches — and two conditions with four outcomes. A suite can take both branches and never see b false: branch coverage is complete and condition coverage is three of four. That level sits between branch coverage and MC/DC in DO-178C and ISO 26262, and since 0.2026.83 it is a metric of its own rather than folded into branches: a row in the status-bar cards, a column in the Coverage view, the reports and the exports, a weight of 3 in the score (whmWeights.conditions) and a gate (threshold.conditions; not gated under the standard profile, 100 under safety).

One decision, a && b, and the same two tests: branches 2 of 2, conditions 3 of 4 because b is never seen false, MC/DC 1 of 2 because b is never shown to matterScreenshot pending — add assets/img/branch-condition-mcdc.svg (see SCREENSHOTS.md).

Read from BullseyeCoverage condition probes, a TRACE32 cond export and GCC 14 built with -fcondition-coverage. A report that does not tell conditions from decisions has no such row, column or weight. If you use Bullseye or TRACE32: conditions used to count as branches, so your branch percentage changes with this release, and with the new weight your composite score; set whmWeights.conditions to 0 for the score as it was.

GCC 14, line by line. -fcondition-coverage makes gcov say which outcome of which condition is missing — condition 1 never true, condition 0 never either way — and each condition is marked on its line and named in the hover, from gcov's JSON and from its text listing (condition outcomes covered 3/6). The metric is where the others are: threshold.conditions gates it and is left unjudged where a run has no such figure, Copy Coverage Summary has a Conditions column, badge.metric takes conditions, and the search box takes conditions < 80. A function's branch figure leaves its conditions' outcomes out, as the file's and the run's do.

GCC 14 condition coverage: the mark on the line and the hover naming the outcome never seenScreenshot pending — add assets/img/gcc-conditions.png (see SCREENSHOTS.md).

Complexity and CRAP

Some reports carry the cyclomatic complexity of every function: OpenCover (which is what Coverlet writes), JaCoCo, Clover and Cobertura. Where they do, the extension computes a CRAP score — Change Risk Anti-Patterns — for the function, from that complexity and from the coverage it measured itself:

CRAP = complexity² × (1 − coverage)³ + complexity

A simple, fully tested function scores its own complexity and nothing more; a complex, barely tested one scores in the hundreds. In the C# sample of the demo project Price() has complexity 22 and about 37% of its lines covered, which makes 142.2, while Shipping() has complexity 12 and is fully covered, which makes 12. The customary line is 30: a function at or above it is listed under Riskiest Methods in the HTML report, worst first.

CRAP against line coverage for two methods: Price() with complexity 22 sits at 142.2 and needs about 75% coverage to get under 30; Shipping() with complexity 12 is fully covered and scores 12Screenshot pending — add assets/img/crap-curve.svg (see SCREENSHOTS.md).

The complexity and the score are on the function's CodeLens and next to the function in the annotated source. Max CRAP is the highest score of any function in a file — the worst one, not an average — and is a column in the Coverage view, the HTML report and the CSV and Markdown exports. It is information: it has no threshold and no weight in the composite score. Reports that carry no complexity (lcov, gcov, Istanbul, coverage.py) have no CRAP, and no empty column either.

Since 0.2026.83 C and C++ have it too. llvm-cov reports no complexity, so it is counted from the branch data the report already carries: the conditions written in the function's own file, plus one — McCabe's definition, and what the source-level tools count for .NET and Java. Conditions that came out of a macro from another file, every assert for one, are not counted.

The Riskiest Methods section of the HTML report: Price() with complexity 22, 37.14% of its lines covered, CRAP 142.2Screenshot pending — add assets/img/riskiest-methods.png (see SCREENSHOTS.md).

Risk hotspots, and which files to show

Under the tree of the Coverage view, Risk hotspots lists the functions where complex code meets little coverage, worst first, each opening its file at the function. A function qualifies by CRAP score — hotspots.crapThreshold, 30 by default, the figure the metric's authors proposed — or by cyclomatic complexity alone, hotspots.complexityThreshold, off by default; only reports that carry complexity (OpenCover, Cobertura from Coverlet, JaCoCo, llvm-cov) have any. Community sees the count and the worst score; the ranked list is Pro. Beside the sort, a second dropdown says which files the tree shows — all, files with gaps, untested files, or the files changed since the last run; folders follow their files and keep their own numbers. Both are in Visual Studio too, in the Coverage window.

Visual Studio: the Coverage window with the filter beside the sort and the risk hotspots under the treeScreenshot pending — add assets/img/vs-hotspots.png (see SCREENSHOTS.md).
In Visual Studio: the Coverage window, with the filter beside the sort and the risk hotspots under the tree.

Namespaces, classes and methods

For a .NET report that names its classes — Cobertura and Coverlet's coverage.cobertura.xml, OpenCover — a third dropdown, Folders / Namespaces, draws the same run as namespaces, classes and methods: a namespace's number is its classes' added up, a class's its methods', exactly as a folder's is its files', with the same sort and the same filter. A method row opens the file at the method; a class declared in no namespace is under (no namespace). The choice is written to coverageView.perspective; a run that carries no class names has no dropdown and shows its folders. In Visual Studio the Coverage window has the same dropdown.

The Coverage view drawn as namespaces, classes and methods, the dropdown on Namespaces, a method row about to open its fileScreenshot pending — add assets/img/namespace-perspective.png (see SCREENSHOTS.md).
The same run by namespace, class and method.
Visual Studio: the Coverage window with the dropdown on Namespaces, the Pricing namespace open on Customer and its methods
In Visual Studio: the Coverage window by namespace, class and method.

Under the buttons and dropdowns, a search box. A word keeps the rows whose name or path carries it — every word typed has to be there; a comparison keeps the rows whose figure passes it — < 80% on the score, lines >= 90, branches = 0, functions != 100, mcdc < 50 — and invoice < 80 wants both. Method rows of the namespace perspective and the risk hotspots are searched with the files, so a function is found where the run has it. The tree is filtered as you type, in the page, without a redraw; a folder holding a match opens for it and closes again when the box empties; Esc clears it. The same box, the same grammar, in Visual Studio.

Typing lines < 80 into the Coverage view's search box: the tree keeps only the files under eighty percent, folders opening to show themScreenshot pending — add assets/img/tree-search.gif (see SCREENSHOTS.md).
Searching the tree: a name, then lines < 80.

The tree follows the editor

The file you are looking at is highlighted in the Coverage view, the folders above it are opened and its row is scrolled into view — the tree no longer has to be searched for the file that is already open. The tree keeps its scroll position otherwise, and nothing is redrawn. coverageView.followActiveEditor, on by default, turns it off for those who would rather leave the tree where they put it.

Switching editor tabs: the Coverage view's highlighted row follows, the folders above it openedScreenshot pending — add assets/img/follow-editor.gif (see SCREENSHOTS.md).
Visual Studio: switching documents, and the Coverage window's highlighted row followingScreenshot pending — add assets/img/vs-follow-editor.gif (see SCREENSHOTS.md).
In Visual Studio: switching documents, and the Coverage window's highlighted row following.

11. Compliance gating

The COMPLIANT / NON-COMPLIANT verdict (shown in the annotated-source view, the HTML report and both status-bar hovers) is driven by per-metric thresholds and a mode:

The status-bar hover card: NON-COMPLIANT, 3 of 5 gates below threshold — functions and regions pass, lines and branches miss narrowly (amber), MC/DC misses outright (red)Screenshot pending — add assets/img/statusbar.png (see SCREENSHOTS.md).
ModeCOMPLIANT when…
strict (default)every individually-gated metric meets its own threshold — no trade-offs.
whmthe single weighted composite score meets threshold.weighted.
boththe weighted gate AND the strict per-metric gate are met.
eitherthe weighted gate OR the strict per-metric gate is met (loosest).

A threshold of 0 switches that gate off, and a metric the report does not carry is never judged. What a threshold you have not set stands for is decided by the profile below. Run Fucini Coverage: Check Coverage Thresholds to evaluate on demand.

In Visual Studio. Tools → Coverage Studio → Check Coverage Thresholds judges the run against the same threshold.* keys and says so in the status bar and the Output pane; with compliance.diagnostics, problems.enabled, problems.perLine or deadCode.enabled the findings sit in the Error List beside the compiler's own — one entry per file below a gate, one per uncovered range, one per function that never ran — each opening its file at the line.

Visual Studio: Check Coverage Thresholds, with the findings in the Error List beside the compiler's ownScreenshot pending — add assets/img/vs-error-list.png (see SCREENSHOTS.md).
In Visual Studio: Check Coverage Thresholds, with the findings in the Error List.

Threshold profiles

threshold.profile decides what a threshold you have not set stands for. standard, the default since 0.2026.82, is what an ordinary project that is not safety related can be held to. safety is every gate at 100 — what a safety case asks for, and exactly what shipped up to 0.2026.81.

Metricstandardsafety
Lines80100
Functions80100
Regions75100
Branches70100
Composite score75100
MC/DC, instantiations, function calls, object codenot gated100
Conditionsnot gated100
Mutation scorenot gatednot gated

A threshold you did set wins over either profile. The example gates branches at 90 and everything else at 100; to hold only some metrics to 100, stay on standard and set those yourself. One caveat follows from how settings work: a value equal to the shipped default cannot be told from no value at all, so under safety a threshold written as exactly its standard figure — 80 for lines, say — still counts as 100.

{
  "fuciniCoverage.threshold.profile": "safety",
  "fuciniCoverage.threshold.branch": 90
}
The settings panel: the threshold profile above the grid of thresholds, showing the standard figuresScreenshot pending — add assets/img/threshold-profile.png (see SCREENSHOTS.md).
Switching the threshold profile to safety in the settings panel: the live preview asks for 100% everywhere; back on standard it asks for 80, 70, 80 and 75 and marks the rest as not gatedScreenshot pending — add assets/img/threshold-profiles.gif (see SCREENSHOTS.md).

If you relied on the old defaults, you are judged more leniently after updating to 0.2026.82 until you select safety. An install that ran before is told so once, with a Keep 100% (safety) button that writes the profile into your user settings; for a shared project put it in the workspace settings as well, so that everybody is judged alike. Configure Coverage Compliance & Thresholds... has the profile above the threshold grid, and its live preview judges with the gates actually in force. In every card and report, a metric whose gate is off shows its figure with a neutral dash instead of a tick or a cross.

The status-bar card under the standard profile: two of four gates below threshold, and a neutral mark on the metrics that are not gatedScreenshot pending — add assets/img/statusbar-metrics.png (see SCREENSHOTS.md).

11a. Object-code coverage

Every other metric here is measured from source: a tool instruments your code, the instrumented build runs, and the counters say which statements, branches or conditions were exercised. Object-code coverage measures something else — how much of the built binary actually executed, counted in instruction bytes, by watching the instruction stream rather than by instrumenting the source. That matters because a compiler emits code no line of your source accounts for: array-bounds checks, switch jump tables, register spills, stack probes, calls into runtime helpers for division or floating point on cores without the instruction. It is also the only metric here that answers does this cover assembly? — hand-written assembly is never instrumented and a source-based tool cannot reach it. DO-178C is explicit about why: at level A, where a compiler or linker generates code that is not directly traceable to source statements, objective 6.4.4.2b requires additional verification of exactly that generated code.

It subsumes statement coverage — every executed instruction came from a statement, so 100% object coverage implies 100% statement coverage. The converse does not hold, and that asymmetry is the whole point of measuring it. Two things follow. It takes no weight in the composite score, because averaging two measures of the same executions counts the same evidence twice; it is gated instead through fuciniCoverage.threshold.objectCode — a requirement rather than a weight, which is how the standard asks for it. And the gap is the deliverable: a run at 100% line coverage with less than 100% object coverage has located exactly the compiler-generated code your source does not account for, so the compliance card says 312 bytes never executed, with 100% line coverage rather than burying it as 94%. The reverse — a whole binary reported as run while its source was not — is a contradiction rather than a low score, nearly always a stale tracefile on one side of a merge or module names that never matched file paths, and it is reported as a finding.

Object-code coverage needs the binary to run somewhere its instructions can be observed. There are three routes and they differ enormously in cost. Only the third produces object-code coverage; the first two are here because they solve a related problem that is often the one actually worth solving.

  1. An instrumented build, running on the target. GCC cross-compilers accept -fprofile-arcs -ftest-coverage, so the instrumentation that works on a workstation works on the target — except that a bare-metal system has no filesystem to write .gcda counters to, and often no exit() to write them at. The counters live in RAM regardless, so the fix is to dump that memory and rebuild the files off-target; NASA JPL's embedded-gcov (Apache-2.0) does exactly that, without a filesystem, an operating system or a standard C library. This gives statement, branch and function coverage of a build made by your cross-compiler, for your instruction set, on your hardware — not object-code coverage, and the binary measured is instrumented, so larger and slower than the one you ship. Load the result as LCOV, gcovr JSON, gcov JSON, or, on a toolchain older than GCC 9, the plain-text .gcov listing.
  2. An instruction-set simulator. Run the real target binary in a simulator and derive coverage from the addresses it executed: no hardware, no instrumentation, no probe, and because it observes instructions it can produce genuine object-code coverage. The limit is fidelity — a simulator models the core well and the peripherals less well, so treat whole-system results with suspicion unless it models your silicon closely.
  3. On-chip trace and a debugger. The certification-grade route, and the only genuinely non-intrusive one: the core's trace unit reports the instruction stream to a debugger, which turns it into coverage. Nothing is instrumented, code size does not change and timing is unaffected — which is what makes the result evidence about the binary you actually ship. Check the silicon before budgeting for it: on many microcontroller families full trace is available only on an emulation or development variant with a large trace buffer and a high-speed trace port, while production parts expose a reduced trace unit whose vendor fallback is a software trace that instruments the code and costs CPU time — removing the very property the route was chosen for.

Many embedded projects measure coverage by compiling the same sources for the development machine and running the unit tests there. It is fast, it needs no hardware, and it is the right default for most teams — but it is worth being clear about what that evidence describes: a different compiler, a different optimiser, a different instruction set and a different binary from the one that ships. For most software that is an acceptable and well-understood trade-off. For work assessed against IEC 61508, ISO 26262 or DO-178C it is the standard host-versus-target objection, and the routes above are the standard answers to it — the first closes it for source coverage, the third for object code.

Today the export read for object code is Lauterbach TRACE32's COVerage.EXPORT.ListModule with metric="object"; load it as you would any other tracefile. The metric is scored and gated on a paid licence and during the evaluation period. A Community install does not score it, but it is told when a tracefile carries it — a compliance verdict that silently omitted the strongest evidence in the file would be worse than one that says what it left out.

12. Excluding non-code lines

With excludeComments on (the default), statements that fall entirely on comment-only or blank lines are excluded from totals — this also neutralises a known llvm-cov/gcov quirk where a stray hit count lands on a comment. Standard markers are honoured too:

x = risky();          // LCOV_EXCL_LINE
// LCOV_EXCL_START
debug_only_block();
// LCOV_EXCL_STOP

Preprocessor directives count as no code either, in C, C++, Objective-C, CUDA and C#: a line starting with # — #define, #include, #if — and the lines a trailing backslash continues it onto. gcov charges each use of a macro to the line it is defined on, so a header whose only reported line was #define CHANNEL_COUNT (33U) read as 100% covered because a loop in the .c file ran up to it, and one whose constant nothing used read as 0%. Such a header now has nothing to measure and is not listed.

Set excluded.includeInTotals to true to count excluded lines anyway.

Leaving a file or a folder out, from the tree

Right-click a file or a folder in the Coverage view and choose Exclude from Coverage — it is among the row's path actions too — or run Exclude This File from Coverage on the open file: the file's workspace-relative path, or the folder's /**, goes into fuciniCoverage.ignore in the folder's settings, once, and the reload takes it out of every total and every page; the pattern is there to be taken out again. In Visual Studio the row's menu and Tools → Coverage Studio have the same two, writing the same setting into the same file.

Right-click a folder row in the Coverage view, Exclude from Coverage, and the tree redraws without it while the pattern appears in settings.jsonScreenshot pending — add assets/img/exclude-from-tree.gif (see SCREENSHOTS.md).
Exclude from Coverage on a folder: the tree without it, the pattern in the settings.
Visual Studio: Exclude This File from Coverage on fees.ts, the tree without fees.ts, then .vscode/settings.json with the pattern src/fees.ts under fuciniCoverage.ignore
In Visual Studio: Exclude This File from Coverage on fees.ts — the tree without it, the pattern in .vscode/settings.json.

Attributes and namespaces, for .NET

Two settings read off the source what the report cannot say. ignore.attributes — ExcludeFromCodeCoverage by default — excludes the class, method or property below an attribute it names, as LCOV_EXCL_START/STOP would, whatever tool wrote the report: Coverlet honours the attribute, OpenCover, dotCover and a converted lcov do not, and now all of them agree. Names with or without the Attribute suffix, with or without a namespace; add GeneratedCode, Obsolete or your own. ignore.namespaces leaves out every file whose namespace declaration matches a prefix, * as the wildcard — Acme.Generated, Acme.*.Migrations, *Tests — and the Output pane names the files it took. Both are read in the same pass that reads the comment markers, in both editions.

{
  "fuciniCoverage.ignore.attributes": ["ExcludeFromCodeCoverage", "GeneratedCode"],
  "fuciniCoverage.ignore.namespaces": ["Acme.Generated", "*.Migrations"]
}

Excluding from the editor

Select the lines and take Exclude Selection from Coverage from the light bulb, the editor's context menu or the Command Palette — in Visual Studio the light bulb (Ctrl+.), the code window's right-click menu, Tools → Coverage Studio or Ctrl+Shift+U, X — and the exclusion is written where the code is: [ExcludeFromCodeCoverage] above a C#, VB or F# class, method or property, by its short name when the file already imports System.Diagnostics.CodeAnalysis and fully qualified when it does not, so that no using has to be added; LCOV_EXCL_LINE at the end of one line of code; LCOV_EXCL_START and LCOV_EXCL_STOP around several, at the first line's indentation — with the language's own comment sign, //, #, ', -- or ;. One undo step. The light bulb also offers it on a line the Problems entries mark as uncovered. A line already marked, or a member already attributed, is left as it is.

A selection in a C# method, the light bulb, Exclude from coverage, and the LCOV_EXCL_START and STOP lines appearing around itScreenshot pending — add assets/img/exclude-selection.gif (see SCREENSHOTS.md).
Exclude Selection from Coverage: the markers written around the selection, in the file's own comment sign.
Visual Studio: four lines of an else-if branch in Quote.cs selected, Exclude Selection from Coverage writing LCOV_EXCL_START and LCOV_EXCL_STOP around them, then ExcludeFromCodeCoverage above a method
In Visual Studio: Exclude Selection from Coverage — the LCOV_EXCL markers around a branch, then [ExcludeFromCodeCoverage] above a method.

An excluded line is grey, not nothing. A line taken out of the count on purpose — LCOV_EXCL_LINE, a region, [ExcludeFromCodeCoverage], or the report itself — used to be drawn like a line with no code at all, so once the coverage gutter mode put green on every line that ran, it could not be told from an untested one. It now gets a grey bar in the gutter and, where the line highlight is on, a grey wash, with how it was taken out and the reason written beside it on the hover; the statement hover says the same instead of going quiet. A comment the exclude pass took out is not marked, and a gap on the same line wins. fuciniCoverage.excluded.showMarks: false turns the marks off. The same in Visual Studio, bar and Quick Info alike.

A C file in coverage mode: executed lines green, an untested line red, and the line marked LCOV_EXCL_LINE grey, with its reason in the commentScreenshot pending — add assets/img/excluded-grey.png (see SCREENSHOTS.md).
Green for the lines that ran, red for the one that did not, and grey for the line taken out with LCOV_EXCL_LINE — three answers, not two.
Visual Studio: the same file with the excluded line grey in the margin and the Coverage window beside itScreenshot pending — add assets/img/vs-excluded-grey.png (see SCREENSHOTS.md).
In Visual Studio: the excluded line grey in the margin, Quick Info saying how it was taken out and why.

Branches only, and gcovr's markers

A defensive else, a default: no value reaches, the arm a compiler adds for an exception: the line runs and should count, and only its branch cannot be taken. LCOV_EXCL_BR_LINE and LCOV_EXCL_BR_START … LCOV_EXCL_BR_STOP take the branches on their lines out of the count and leave the lines in it. LCOV_EXCL_EXCEPTION_BR_LINE and its region take less still — only the arms an exception reaches, where the report says which those are, as gcov's JSON does. Every marker is read under gcovr's prefixes as well: GCOVR_EXCL_LINE, GCOVR_EXCL_START, GCOVR_EXCL_BR_LINE, GCOV_EXCL_STOP and the rest mean what the LCOV_EXCL_ ones mean, so a source written for gcovr reads the same here whatever tool made the report. Not read: GCOVR_EXCL_FUNCTION — nothing on that line says where the function ends.

if (handle == NULL) return E_FAIL;   // LCOV_EXCL_BR_LINE: the allocator never fails on target
  // LCOV_EXCL_BR_START generated state table
  switch (state) { /* … */ }
  // LCOV_EXCL_BR_STOP
LCOV_EXCL_BR_LINE on a line: the line still counted, its branch gone from the countScreenshot pending — add assets/img/branch-markers.png (see SCREENSHOTS.md).

Saying why: justified exclusions

Taking code out of the count is a claim — "this cannot be tested", "this is a developer aid" — and under DO-178C, ISO 26262 or IEC 61508 a claim that changes the number a certificate rests on has to be written down and reviewable. So an exclusion can say why, in the place it is written: the text after LCOV_EXCL_LINE or LCOV_EXCL_START, or the Justification of [ExcludeFromCodeCoverage].

abort();                 // LCOV_EXCL_LINE: defensive, unreachable by construction
  // LCOV_EXCL_START debug dump, never built for the target

  [ExcludeFromCodeCoverage(Justification = "a developer aid")]
  public static void DebugDump(decimal amount) { /* … */ }

The reasons are read at every load and the log counts them. Export Coverage Report… writes the list — exclusions and their justifications, as Markdown or CSV: the file, the lines, how it was written, and the justification or none given. A file left with nothing measurable is still in that list. With exclusions.requireReason on, an exclusion that gives no reason is a finding: a warning in Problems at its line, and a failure of Check Coverage Thresholds. Exclude Selection from Coverage then asks for the reason first and writes it with the marker or as the attribute's Justification; dismissed or left empty, nothing is excluded.

An exclusion without a reason flagged as a warning at its line, and the exported list with none givenScreenshot pending — add assets/img/justified-exclusions.png (see SCREENSHOTS.md).
Visual Studio: an exclusion without a reason as a warning at its line, and the exported list with none givenScreenshot pending — add assets/img/vs-justified-exclusions.png (see SCREENSHOTS.md).
In Visual Studio: an exclusion without a reason as a warning at its line, and the exported list with none given.

12a. Does this coverage still describe this file?

Coverage read from a tracefile describes the source as it was when the tests ran, and most formats say nothing about which version that was. Every file in the Coverage panel is therefore in one of three states:

  • ✓ Verified — the tracefile records what each measured line said, and it still matches the file.
  • Nothing shown — not disproved. Nothing contradicts the coverage and nothing confirms it. This is the ordinary state.
  • ⚠ Contradicted — the file itself disproves its coverage. The row is dimmed and the tooltip says what was found.

Only two formats can earn the tick, because only two record anything about the source they measured: lcov written with --checksum (off by default in geninfo; its documented purpose is to stop coverage from one version of a file being combined with another), and GNATcoverage XML, which embeds the text of every line it measured. Turning the lcov option on is worth it.

The warning needs neither, and works with every format: coverage recorded past the end of the file, a named function that is no longer where the report puts it, or executed lines that are blank in the file. Timestamps are never enough on their own — a git checkout moves every one without changing a byte — so a moved timestamp is at most a reason to look again. The check runs when coverage is loaded and again whenever a file is saved or changes on disk, so the mark follows the file: an edit that contradicts the run sets it, a checkout that restores the measured version clears it. The tooltip says exactly what proved it. Set staleWarning.enabled to false to switch all of it off.

12b. Unmeasured versus uncovered

A file the run never mentions is unmeasured: no test loaded it, so no tool wrote a line for it. That is not the same as uncovered — measured, with zero hits — and the extension has never scored an absent file as 0%. What it did not do, until 0.2026.69, was show the absent ones at all: a module with no tests whatsoever never appeared in the tree, the totals or the threshold check, and a reader saw “92%” for a project half of whose files had never been exercised.

Now, with a run loaded, the per-file status-bar item says not measured for a source file of the run's own kind that the run does not contain — “of the run's kind” meaning it has one of the file extensions the run measured, so a C project's headers and sources are candidates and its Python scripts are not. Everything beyond that is opt-in through fuciniCoverage.unmeasured.mode:

  • off (default) — nothing else changes.
  • list — the Coverage view gets an Unmeasured group at the bottom naming every such file, each row opening it; the load result counts them; badges mark them ? in the Explorer; and fuciniCoverage.threshold.unmeasuredFiles can fail Check Coverage Thresholds when there are more than a number you set. No percentage moves.
  • count — everything list does, and each unmeasured file also counts against the run as an uncovered file of its own code lines, so the status bar, the thresholds, the badges, history, every export and the Test Coverage view show the lower number. The file is drawn as unmeasured wherever it appears, its gutter bars say “not measured” rather than “never ran”, and the mismatch check leaves it alone — there is no measurement for its contents to contradict.
{
  "fuciniCoverage.unmeasured.mode": "list",
  "fuciniCoverage.threshold.unmeasuredFiles": 0
}

Header files are the known false positive in C: they have the run's extension family and no tracefile will ever name one, because on its own it compiles to nothing. fuciniCoverage.unmeasured.exclude therefore leaves out **/*.h, **/*.hpp, **/*.hh, **/*.inl and **/*.d.ts by default, in the same glob syntax as fuciniCoverage.ignore; add a platform port that is not built here, or generated stubs, and they drop out of the list, the count and the status-bar state. A file ignore names is never called unmeasured either — leaving it out was the point. threshold.unmeasuredFiles defaults to -1, which does not check; 0 fails the moment any file of the run's kind was never loaded by a test, and it only applies while unmeasured.mode is list or count.

A file the report names that is not on disk is the other way round: measured, but not there — a generated file the build deleted again, a helper of a dependency, a path no remap caught. It counts by default, since the report says it ran, and the Coverage view lists it. fuciniCoverage.missingSources.includeInTotals: false leaves such files out of the totals and the views, and the log names what was left out, file by file (FUCINI_MISSING_001), so that a remap which would bring them back can be written. The same setting in Visual Studio's fucini-coverage.json; on the command line, --exclude-missing-sources.

13. HTML reports

  • Generate Full HTML Report — a self-rendered, multi-page, per-directory report. Output goes to htmlReport.outputDir, or the extension's global storage when unset.
  • Open Annotated Source — a single-file annotated view. Point externalHtmlReport.dir at a pre-built llvm-cov show --format=html directory to use those pages instead of the built-in renderer.
  • Export Fucini JSON — the full normalised model for your own tooling.
  • Export Coverage Report... — the run as CSV (per file or per function), a Markdown summary, an LCOV tracefile, Cobertura XML, SARIF, or a self-contained SVG badge for your README. Also reachable from the button beside Generate Full HTML Report in the Covered Files view. Everything except the CSVs is lossy — MC/DC, regions and instantiations have nowhere to go in LCOV, Cobertura or SARIF — so Fucini JSON and the CSVs stay the formats that carry every metric.
  • Copy Uncovered Lines — a Markdown summary of every gap, ready to paste into a PR.

In Visual Studio. The Reports group of Tools → Coverage Studio: Show Annotated Source opens the active document as a page in the document well — every line in its colour, the findings beside it — scrolled with the editor in both directions; Open HTML Report writes the one-page report to htmlReport.outputDir (or %LOCALAPPDATA%\Fucini\CoverageStudio\html-report) and opens the browser; Generate Full HTML Report writes the index per folder and the page per file there; Export Coverage Report… offers the same eight formats and asks where to save; Generate Coverage Badge writes the badge where badge.outputPath says, after every load with badge.autoUpdate. The annotated page needs WebView2, as the Coverage window does; the reports on disk do not.

Visual Studio: Show Annotated Source — the file as a page in the document well, beside the editorScreenshot pending — add assets/img/vs-annotated-source.png (see SCREENSHOTS.md).
In Visual Studio: Show Annotated Source — the file as a page in the document well, beside the editor.
Multi-page HTML report directory indexScreenshot pending — add assets/img/report.png (see SCREENSHOTS.md).
The report, Directory Coverage Summary: one row per folder, a column for every metric the run carriesScreenshot pending — add assets/img/report-directory-summary.png (see SCREENSHOTS.md).
The report, File Coverage Summary: one row per file, with Max CRAP where the report carries complexityScreenshot pending — add assets/img/report-file-summary.png (see SCREENSHOTS.md).
The report, Coverage Gaps: every function with uncovered branches or MC/DC conditions, named as writtenScreenshot pending — add assets/img/report-coverage-gaps.png (see SCREENSHOTS.md).
The report, MC/DC Expression Detail: conditions covered per decisionScreenshot pending — add assets/img/report-mcdc-detail.png (see SCREENSHOTS.md).
Export Coverage Report: CSV per file or per function, a Markdown summary, LCOV, Cobertura XML, SARIF, or an SVG badgeScreenshot pending — add assets/img/export-picker.png (see SCREENSHOTS.md).
The report’s annotated page for src/calc.c: per-line hit counts, a fully covered function, an uncovered else branch, a 1/2 partial branch, an MC/DC expansion and a never-called functionScreenshot pending — add assets/img/annotated-source.png (see SCREENSHOTS.md).

Annotated source vs. plain source

Open Annotated Source replaces the active tab with a colour-coded coverage webview for that file, in the same column; Open Annotated Source to the Side does the same but in a split, so source and annotated view sit next to each other. To flip back and forth in place instead — handy on a small screen where a split leaves each pane too narrow — use Toggle Annotated Source: it swaps the active tab between the two, remembering which one you're currently looking at. From inside the annotated view itself, Show Source jumps straight back to the plain editor for that file.

Which HTML you actually see depends on externalHtmlReport.dir: when it's set and a page matching the active file already exists there (llvm-cov lays per-file pages out as <repo-name>/<relative-path>.html, so the report's own repo-name folder never needs configuring), that toolchain-generated page is shown instead of the built-in renderer — its local links/stylesheet are rewritten to work inside the webview, and it carries detail the built-in view doesn't reproduce (MC/DC expansion views, region highlighting, directory rollups). No matching page for that file, or the setting left empty? The built-in renderer is used instead. The extension only ever reads this directory — it never writes into it.

A coverage badge for the README

Generate Coverage Badge writes a shields-style SVG for the active run into the workspace — badge.outputPath, default coverage-badge.svg, relative to the workspace folder or absolute, with the same variables as every other path setting — and offers to open it. It is a plain file in your repository, so a README embeds it with no service behind it, no shields.io round trip, and it works in an air-gapped repository too:

![coverage](coverage-badge.svg)

coverage: 83%

badge.metric picks what the badge shows: lines (labelled coverage), branches, mcdc or weighted, the same composite score the status bar shows, labelled score. A run without data for the chosen metric gets a grey n/a rather than a red 0%. The colour follows your own colorScale.* tiers: lowColor below lowThreshold, midColor up to highThreshold, highColor from there. With badge.autoUpdate on, the badge is rewritten after every successful load, silently, and the output channel records each write as [FUCINI_BADGE] — off by default because it writes into the workspace on every load. Commit the SVG with the code and the picture on the repository page follows the number in the editor.

{
  "fuciniCoverage.badge.outputPath": "docs/coverage-badge.svg",
  "fuciniCoverage.badge.metric": "weighted",
  "fuciniCoverage.badge.autoUpdate": true
}

14. History & trends

Enable history.enabled to persist runs locally (keeping history.retention of them). You then get a trend arrow (▲/▼) in the status bar, the trend chart in the Coverage view, and two comparison commands: Compare with Last Run and Compare Two History Runs, each producing a per-file regression/improvement diff.

In Visual Studio. Every load is compared with the one before: a triangle in the margin on each line that started or stopped running (sinceLastRun.enabled), the trend beside the score in the status bar, and Compare with Last Run for the files whose numbers moved. With history.enabled the runs are kept under %LOCALAPPDATA%\Fucini\CoverageStudio\history, history.retention of them, so the comparison survives a restart, the trend chart has something to draw, and Compare Two History Runs… picks any two of them.

Compare with Last Run: the run moved from 83.89% to 83.05%, calc.c lost 4.54 points, and the status bar carries the trendScreenshot pending — add assets/img/history-compare.png (see SCREENSHOTS.md).
Since last run: a red mark on the lines that ran in the previous run and not in this one, a green one on the lines that are newly coveredScreenshot pending — add assets/img/since-last-run.png (see SCREENSHOTS.md).

The trend chart

Under the toolbar of the Coverage view, with two saved runs or more, the history's line coverage as a line, oldest to newest, the newest thirty: a dot per run that says its date and figure on hover, and the last figure beside it with an arrow for the direction since the first. The vertical scale is the runs' own range, so a team at 92–94% sees the movement rather than a flat line under 100. Both editions draw it from the same history.

The trend chart under the Coverage view's toolbar: a line over a dozen runs, a dot per run, the last figure and an arrow upScreenshot pending — add assets/img/trend-chart.png (see SCREENSHOTS.md).
The trend: a dot per saved run, the last figure beside it.
Visual Studio: the trend line under the Coverage window toolbar, the last figure 68.25%
In Visual Studio: the trend under the Coverage window’s toolbar, the last figure 68.25%.

Coverage sessions

One test run rarely covers everything a change touched: the unit tests ran here, the integration suite there, a walk through the UI with coverage on somewhere else. Start Coverage Session turns the loads that follow into one sum — each run is added to the one before it line by line as a union, a line any of them executed is covered and the counts add up — so the gutter, the tree and the score show what they all reached together. The run on screen, if there is one, is the session's first. A bar over the tree says how many runs since when and ends the session; End Coverage Session does the same, and the next load stands alone again. In Visual Studio one entry under Tools → Coverage Studio starts the session and, checked, ends it.

A coverage session: the unit test run loads, the session starts, the integration run loads on top, and the bar says two runs while the tree's numbers riseScreenshot pending — add assets/img/coverage-session.gif (see SCREENSHOTS.md).
A session of two runs: the second added to the first, the bar over the tree counting them.
Visual Studio: the unit run loaded, Start Coverage Session, the integration run added, the bar saying 2 runs and lines at 68.25%, then the session ended
In Visual Studio: Start Coverage Session, and a second run added to the first — the bar counts two runs, lines rise from 50.79% to 68.25%.

The CI baseline: where am I against main?

Compare with Last Run answers what your last change did; before a pull request the question is where you stand against main, and the answer is on the build server. baseline.report names the report the main branch's build publishes, and every load is held against it: the status bar's card carries the one-line delta — vs CI baseline: 84.20% → 85.10% (+0.90%), 3 file(s) moved — and Compare with CI Baseline lists the files that moved, file by file, in the same words as Compare with Last Run. In Visual Studio the command is under Tools → Coverage Studio and fetches or reads the report when you ask. Three ways to name it, in .vscode/settings.json:

  1. A URL the CI serves. GitLab keeps a branch's last job artifacts at a stable address; the token stays out of the settings file through ${env:…} in remote.headers. Jenkins: https://jenkins.example.com/job/app/job/main/lastSuccessfulBuild/artifact/coverage/lcov.info. TeamCity: https://tc.example.com/repository/download/App_Main/.lastSuccessful/coverage/lcov.info with Authorization: Bearer ${env:TC_TOKEN}. The URL is fetched and cached exactly as a coverageFile.paths URL is (ETag, remote.refreshMinutes).
  2. A file the pipeline copied onto a share — an absolute path such as \\build\drops\app\main\coverage.cobertura.xml.
  3. A downloaded artifact kept under the folder, say ci/main.lcov.info (put the folder in .gitignore) — a path relative to the folder.
{
  "fuciniCoverage.baseline.report": "https://gitlab.example.com/api/v4/projects/42/jobs/artifacts/main/raw/coverage/lcov.info?job=test",
  "fuciniCoverage.remote.headers": ["PRIVATE-TOKEN: ${env:GITLAB_TOKEN}"]
}

Any format the reader knows will do. A path the CI wrote relative to its checkout — src/Billing/Invoice.cs, as Coverlet writes it on the runner — is placed under this folder before the diff, so it meets the file the local run resolved; an absolute path from another machine matches nothing, so have the pipeline write relative paths. A baseline that cannot be fetched or read is a line in the Output pane, never a failed load.

Compare with CI Baseline: the status bar's card with the vs CI baseline line, then the command listing the files that moved against main, regressions firstScreenshot pending — add assets/img/ci-baseline.gif (see SCREENSHOTS.md).
The CI baseline: the delta on the card, and the files that moved against main.
Visual Studio: baseline.report set to the unit suite report, then Compare with CI Baseline showing statements 50.79% to 68.25% and branches 30.43% to 50.00%, one file changed
In Visual Studio: Compare with CI Baseline — statements and branches against the unit suite’s report, and the file that changed.

An artifact is a zip, and that is read too. GitHub and GitLab hand an artifact over as an archive, whatever was put in it. Name the report in it after a #: the member is found by its path or by the end of it; without a # it is the archive's only file, or its only file that looks like a report, and where there are several the output names them. The same goes for a zip you downloaded (ci/artifact.zip#lcov.info) and, in VS Code, for a URL in coverageFile.paths. The token goes to the server it was set for and no further: the redirect to the storage that holds the archive is followed without it.

{
  "fuciniCoverage.baseline.report": "https://api.github.com/repos/acme/app/actions/artifacts/1234567/zip#coverage/lcov.info",
  "fuciniCoverage.remote.headers": ["Authorization: Bearer ${env:GITHUB_TOKEN}"]
  }

14a. For AI agents: the coverage on screen

An agent that writes tests can run them and read a percentage. What it cannot do by itself is ask what the editor knows: which lines of this function never ran, which side of which branch, which tests reach a line, whether the diff it just wrote is covered. Six tools answer exactly that, in words an agent can act on, from the run that is loaded — the same exclusions, the same remapping, the same numbers as on screen. So an agent told to cover the gaps of a function, and a reviewer looking at the gutter, are talking about the same lines.

ToolWhat it answers
coverage_summaryThe run's totals per metric, and the files furthest from covered. The first thing to ask.
coverage_gapsWhat never ran in a file, a function or a range of lines: the uncovered lines, the branch arms not taken, the MC/DC conditions without their pair, the mutants that survived.
tests_for_lineWhich tests ran a line, where the report says — a per-test run.
patch_coverageThe coverage of a diff — the working tree against a ref, or a patch handed over — and its lines that never ran.
coverage_deltaWhat moved since the run before: the totals, and the files that gained or lost.
test_run_commandThe command that runs this workspace's tests with coverage on. The agent runs it; the editor reloads the report by itself.

VS Code's own agent has them as tools with nothing to set up. Every other agent — any client that speaks MCP, the Model Context Protocol — reaches them through a server the editor runs when mcp.enabled is on, in VS Code and in Visual Studio alike. Copy MCP Server Configuration puts the client's entry on the clipboard, as VS Code and Visual Studio read it in an mcp.json; a client that names the outer key mcpServers takes the same entry under that name.

Copy MCP Server Configuration and its message, the token painted overScreenshot pending — add assets/img/mcp-config.png (see SCREENSHOTS.md).
Visual Studio: Copy MCP Server Configuration and its message; the token painted overScreenshot pending — add assets/img/vs-mcp-config.png (see SCREENSHOTS.md).
In Visual Studio: Copy MCP Server Configuration and its message; the token painted over.
{
  "servers": {
    "fucini-coverage": {
      "type": "http",
      "url": "http://127.0.0.1:39217/mcp",
      "headers": { "Authorization": "Bearer …" }
    }
  }
  }
  • It is off unless you turn it on, and it listens on 127.0.0.1 only: nothing off this machine reaches it.
  • A call has to carry your token, made once and kept for you; without it the answer is 401. The copied configuration carries the token: keep it out of the repository.
  • A call a web page sent — it says so in its Origin — is refused, whatever it carries.
  • It reads the run that is loaded and writes nothing. The test run is named, not started: the agent runs the command in its own terminal.

The port is mcp.port, 39217 unless set. Where that is taken — a second window, the other edition beside this one — the next free one is used, and the copied configuration names the one that works. The output says where the server listens ([FUCINI_MCP]) and why it could not ([FUCINI_MCP_001]). What a plan does not include — the names of tests, MC/DC detail — the tools count without spelling it out, as the hover does.

15. Command reference

In Visual Studio. Every command is under Tools → Coverage Studio, named as in the table without the Fucini Coverage: prefix; the Coverage window's toolbar and the right-click menu on a row have the ones that belong there, and the code window's right-click menu has the three that act on the editor: Run This Test with Coverage, Show Tests That Ran This Line and Exclude Selection from Coverage. Those with keys are two-stroke chords after Ctrl+Shift+U: R reloads, N and P go to the next and the previous uncovered line, B to the next partly-tested decision, T lists the tests that ran the line, X excludes the selection — not VS Code's Alt+N, because in Visual Studio Alt and a letter opens a menu. Change them under Tools → Options → Keyboard, where they are listed as Coverage Studio: …. Not in this edition: the Test Coverage panel is a VS Code API — the run is in the Coverage window instead — and Solution Explorer cannot show badges. Only in this edition: Run Native Project with Coverage, for a C++ startup project.

In Visual Studio: where everything is. The Coverage window is under View → Other Windows → Coverage, and first in Tools → Coverage Studio, where every command of this edition sits, in groups: loading and reloading, watching the file, the two copies and the cards; Run Tests with Coverage, Run Native Project with Coverage and Collect Coverage in Test Explorer…; Next and Previous Uncovered and the partly-tested decisions; painting, hit counts and the gutter modes; the coverage source of a file, the tests that ran a line, one test with coverage, the two ways to exclude; Compare with Last Run, Compare Two History Runs…, Compare with CI Baseline, the coverage session and Check Coverage Thresholds; the Reports group — Show Annotated Source, Open HTML Report, Generate Full HTML Report, Export Coverage Report… and Generate Coverage Badge; then Getting Started, the compliance thresholds and Licence…. The window's own toolbar has the five you reach for most: Load Coverage, Reload, Toggle Coverage Painting, Copy Coverage Summary and the compliance thresholds; under them the perspective, the filter and the sort, and the search box; under those the trend. Rest the pointer on a row of the tree and press its ⋯ for the row's menu — open the file, open its folder, copy its path, absolute or relative, with either kind of slash, exclude it from coverage. At the right end of the status bar are the run's score and the open file's, with the trend since the last run; Show Coverage Card and Show Coverage Card for This File open the cards behind them, the same cards VS Code shows when the pointer rests on its status-bar item.

Visual Studio: Tools → Coverage Studio, open, with every command of the edition
In Visual Studio: Tools → Coverage Studio, with every command of this edition.
Visual Studio: View → Other Windows, where the Coverage window is
In Visual Studio: View → Other Windows, where the Coverage window is.
Visual Studio: the Coverage window's toolbar — Load Coverage, Reload, Toggle Coverage Painting, Copy Coverage Summary, compliance thresholds
In Visual Studio: the toolbar of the Coverage window — Load Coverage, Reload, Toggle Coverage Painting, Copy Coverage Summary and the compliance thresholds.
Visual Studio: a row's menu in the Coverage window — Open, Open Containing Folder, and the four Copy Path entries
In Visual Studio: the ⋯ menu of a row — open the file, open its folder, copy its path in four forms.
Visual Studio: the status bar's two items, the run's score and the open file's
In Visual Studio: the two status-bar items, the score of the run and of the open file.
Visual Studio: the run's coverage card, opened by Show Coverage Card
In Visual Studio: the coverage card of the run, from Show Coverage Card.
Visual Studio: the open file's coverage card, opened by Show Coverage Card for This File
In Visual Studio: the card of the open file, from Show Coverage Card for This File.
The status-bar hover cards for the run and the file, then the Coverage view toolbar: Pick Coverage File, Load Coverage, Export Coverage Report and Generate Full HTML Report, ending on the generated reportScreenshot pending — add assets/img/statusbar-and-toolbar.gif (see SCREENSHOTS.md).
In VS Code: the status-bar hover cards for the run and the file, then the toolbar of the Coverage view, ending on the generated report.
The status-bar menu: select a coverage file, run tests with coverage, reload, open the HTML report, choose the gutter modeScreenshot pending — add assets/img/statusbar-menu.png (see SCREENSHOTS.md).
In VS Code: the status-bar menu — select a coverage file, run tests with coverage, reload, open the report, choose the gutter mode.
Show Worst-Covered Functions: every function of the run, lowest coverage first, with its CRAP score where the report carries complexityScreenshot pending — add assets/img/worst-functions.png (see SCREENSHOTS.md).
In VS Code: Show Worst-Covered Functions, lowest coverage first, with the CRAP score where the report carries complexity.
CommandWhat it does
Load CoverageDiscover & load coverage for the workspace. Alt+Shift+R by default (Ctrl+Alt+R on macOS).
Pick Coverage FileChoose tracefiles — one, several, or a further one each time; picks add up, are merged, and are written to coverageFile.paths so they load by themselves from then on.
Show Loaded Coverage FilesList the tracefiles in the active run. The Coverage view lists them too, each with an unload button and a pick button beside them.
Toggle Tracefile WatchWatch the tracefile(s) for changes and reload automatically.
Run Tests with CoverageRecognise the test runner, run it with coverage on in a terminal task, load what it writes, and offer to add the path to the settings.
Run This Test with CoverageThe test under the caret — the method, the class or describe block, or the file — run by the recipe narrowed to it, then loaded like any run. Also on the editor's context menu.
Show Tests That Ran This LineWhere the report says which tests ran what, list the tests that ran the line under the caret, busiest first, and open the one you pick where it is written.
Run Tests Affected by My Changes…List the tests that ran a line the working tree changes against testImpact.baseRef, open the one you pick, or run only those where the reports came from a per-test run.
Show Minimal Test Set…The fewest tests that still run every line the suite runs, then the tests that add no line of their own.
Run App with Coverage…Start the folder's .NET app under dotnet-coverage, and load what you walked through when it closes.
Run Mutation Tests HereMutate the function the caret is in — or the selection, or the file — with Stryker.NET, StrykerJS or PIT, and load the report beside the coverage on screen.
Exclude This File from Coverage / Exclude from CoveragePut the open file — or, on a row of the Coverage view, the file or the folder's /** — into fuciniCoverage.ignore in the folder's settings, once.
Exclude Selection from CoverageWrite the exclusion where the code is: [ExcludeFromCodeCoverage] above a .NET member, LCOV_EXCL_LINE on one line, LCOV_EXCL_START/STOP around several, in the file's own comment sign. Also the light bulb and the editor's context menu.
Start Coverage Session / End Coverage SessionWhile a session is on, every load is added to the one before it as a union; a bar over the tree counts the runs and ends it.
Next / Previous UncoveredJump between uncovered regions. Alt+N / Alt+P by default (Ctrl+Alt+N / Ctrl+Alt+P on macOS).
Choose Editor Gutter Mode...Off, uncovered-only bars, red-amber-green bars, or a hit-count heatmap in the editor's gutter.
Cycle Editor Gutter ModeOne step on through off, uncovered, coverage and heatmap — Alt+G, or the mode button in the status bar.
Choose Coverage Source for This File...When more than one loaded report measures the open file, choose which one its numbers come from, for the file, its folder or a pattern — writes a coverageFile.sources rule.
Clear Coverage Source for This File...Take out the coverageFile.sources rules that apply to the open file.
Toggle Inline Hit CountsShow or hide the ×N execution counts after each line — flips hitCounts.inline.
Show in Test Coverage ViewPublish the active run to VS Code's own Test Coverage panel (even with testCoverage.publish off) and open it.
Suggest Path Remap RuleInfer the pathRemap rule that would match the active run's unmatched files to the workspace, and offer to add it.
What Community IncludesEvery cap and withheld feature of the free tier in one list, with how much of each cap is used.
Open HTML ReportOpen the rendered static report.
Generate Full HTML ReportBuild the multi-page report.
Open Annotated Source / …to the SideAnnotated coverage view for a file.
Toggle Annotated SourceSwap between source and annotated view. Alt+A by default (Ctrl+Alt+A on macOS).
Show Worst-Covered Files / Folders / FunctionsRanked lowest-first Quick Pick.
Copy Uncovered LinesMarkdown summary of every uncovered range.
Compare Two History Runs / with Last RunPer-file regression diff — two runs the history kept, or the run on screen against the one it replaced.
Compare with CI BaselineThe loaded run against the report baseline.report names — the main branch's from CI, a URL or a downloaded artifact — file by file.
Show Indirect Coverage Changes…The lines whose coverage moved though nobody edited them, against the CI baseline or the run before, per file.
Check Coverage ThresholdsEvaluate the compliance gates.
Export Fucini JSONExport the current run as Fucini JSON.
Export Coverage Report...Pick a format — CSV, Markdown, LCOV, Cobertura XML, SARIF or an SVG badge — and a destination.
Generate Coverage BadgeWrite the SVG badge for the active run to badge.outputPath, showing badge.metric, and offer to open it.
Copy MCP Server ConfigurationPut what an MCP client needs to ask about the coverage on screen — the server's address and your token — on the clipboard; with the server off, offer to turn it on.
Show Status Bar MenuOpen the quick-action menu.
Browse for External HTML Report / Full Report Output Dir…Set the report directories via a picker.

16. Settings reference

The complete, categorised settings table — every option with its default — lives on the Features & Settings page. All keys are prefixed fuciniCoverage..

Worth calling out: fuciniCoverage.language pins this extension's own runtime UI (status bar, notifications, tooltips, webviews) to a specific language, independent of VS Code's Display Language — it defaults to auto and ships bundles for all 18 supported languages. It does not change Command Palette entries or the Settings UI labels, which VS Code resolves from its own Display Language.

In Visual Studio. The same fuciniCoverage.* keys, read from up to four files, the later winning: VS Code's own user settings if VS Code is on the machine — read, never written, so your colours and thresholds come along; %APPDATA%\Fucini\CoverageStudio\settings.json, this edition's user settings; .vscode\settings.json in the folder or beside the solution, so a repository set up for VS Code is set up for Visual Studio; and fucini-coverage.json at the solution root, for a team that would rather not keep a .vscode folder in a .NET repository — the VS Code edition reads it too. The gear in the Coverage window's toolbar opens a settings window that writes the user file or the folder's file that exists, as its Write changes to selector says, and keeps the comments of a file it edits. fuciniCoverage.language works there in the same way; the menus follow Visual Studio's own language.

17. Error codes

Diagnostics go to the Fucini Coverage output channel (View → Output → Fucini Coverage), each with a stable FUCINI_* code.

In Visual Studio. The same codes go to the Fucini Coverage pane of the Output window (View → Output) and are kept in %LOCALAPPDATA%\Fucini\CoverageStudio\coverage-studio.log, for the question that arrives after the IDE is closed. Three that come up: nothing is marked although the pane says files were loaded — the gutter mode is off, choose Show Coverage in Editor; FUCINI_REMAP_001 and an information bar — the report names paths that do not exist here, and the pane suggests the pathRemap rule; the Coverage window says it needs WebView2 — install the Microsoft Edge WebView2 Runtime, the marks in the editor do not need it.

CodeMeaning
FUCINI_PARSE_001Unsupported/unrecognised coverage format — no parser matched the file.
FUCINI_PARSE_010lcov file had no SF records.
FUCINI_PARSE_020llvm-cov JSON invalid, missing data[], or contained no files.
FUCINI_PARSE_030Cobertura root <coverage> missing or XML invalid.
FUCINI_PARSE_040JaCoCo root <report> missing or no source files.
FUCINI_PARSE_050Istanbul/SimpleCov JSON invalid or contained no files.
FUCINI_PARSE_060SimpleCov JSON invalid or missing a top-level files array.
FUCINI_PARSE_070Go profile with no mode: header, or no coverage blocks in it.
FUCINI_PARSE_080Clover root <coverage> or <project> missing, or no files in it.
FUCINI_PARSE_090OpenCover root <CoverageSession> missing, or no files in it.
FUCINI_PARSE_100coverage.py JSON invalid or missing a top-level files object.
FUCINI_PARSE_110gcov/gcovr JSON invalid or missing a top-level files array.
FUCINI_PARSE_120GNATcoverage XML with no <source> element, or an index.xml whose xi:includes were never resolved — load the per-source *.xml files instead.
FUCINI_PARSE_130BullseyeCoverage root <BullseyeCoverage> missing, or no <src> elements in it.
FUCINI_PARSE_140Visual Studio coverage root <CoverageDSPriv> missing, no <SourceFileNames> table to resolve line rows against, or no line data in it.
FUCINI_PARSE_150Xcode coverage JSON invalid, or missing a top-level targets array.
FUCINI_PARSE_160SonarQube generic coverage root <coverage> missing, or no <file> elements in it.
FUCINI_PARSE_170Coveralls JSON invalid, or missing a top-level source_files array.
FUCINI_LOADA load was cancelled from its progress notification; the previous run, if any, stays loaded.
FUCINI_REMOTE_001A coverageFile.paths URL could not be fetched, with the reason; the last downloaded copy is loaded instead. Plain [FUCINI_REMOTE] lines record each download and each unchanged (304) check.
FUCINI_REMOTE_002A coverageFile.paths URL gave no complete answer within 30 seconds — most often a proxy or VPN that accepts the connection and then says nothing; the last downloaded copy is loaded instead.
FUCINI_REMOTE_003A coverageFile.paths URL answered with an HTML page rather than a tracefile — a sign-in gateway, most likely. The page is not cached and the last downloaded copy is loaded instead; check the token in remote.headers.
FUCINI_REMAP_002A pathRemap rule was suggested for the paths a load left unmatched, with how many of them it explains — or none could be inferred, or the inferred rule is already in the setting and did not resolve them.
FUCINI_REMAP_003The suggested rule was appended to fuciniCoverage.pathRemap by Apply Suggested Remap and the coverage is being reloaded.
FUCINI_GITDIFF_001The Git extension is unavailable, so diff coverage is skipped and the whole run is shown.
FUCINI_GITDIFF_002gitDiff.baseRef begins with -, which no git ref can (git would read it as an option); diff coverage is skipped and the whole run is shown.
FUCINI_IGNOREHow many files fuciniCoverage.ignore left out of the run, and which.
FUCINI_UNMEASURED_001The files of the run's kind that no test loaded, one per line.
FUCINI_UNMEASURED_002More than 5,000 workspace files matched one of the run's extensions; only the first 5,000 were considered for the Unmeasured list.
FUCINI_UNMEASURED_003In count mode, some unmeasured files are listed but not counted: the read cap (2,000 files or 50 MB per load) was reached.
FUCINI_UNMEASURED_004An unmeasured file could not be read; it is listed but not counted.
FUCINI_MISSING_001With missingSources.includeInTotals off: how many files the report names are not on disk and were left out, one per line.
FUCINI_TESTCOVERAGEHow many files were published to VS Code's Test Coverage view.
FUCINI_BADGEThe badge was written, with its path, label and value.
FUCINI_BADGE_001The badge could not be written, with the reason.
FUCINI_WORKSPACEA folder was added to or removed from the workspace; coverage is discovered again.
FUCINI_VARIABLESWhat each ${command:…} in the path settings answered, or why it was left as written: the command failed, answered with nothing usable, or the workspace is not trusted.
FUCINI_WATCHWhat the watcher is doing: the paths being watched, a configured file that has appeared, a task named in watch.reloadAfterTasks that ended (with its exit code) and triggered a reload, or a path under files.watcherExclude that is polled instead.

18. Privacy

Telemetry is controlled by the window-scoped telemetry.enabled setting. It defaults off. The daily summary and the removal notice also need VS Code's global telemetry.telemetryLevel to allow telemetry; the install ping and a few small lifecycle events are sent regardless, and so is the usage ledger entry of an install on the trial or the free Community tier. On Community, Unlock Full Features trades this telemetry for every Pro feature, MC/DC included, for 30 days, once per machine — turn it off again and the standard Community set applies; a paid licence is unaffected either way. See the privacy policy for what is sent.

Two things are worth knowing because you can act on them. The first is your usage ledger ID: on the trial and on Community, the extension shows it under Show License / Activation and at the bottom of What Community Includes, where selecting the row copies it and opens the policy. The ledger knows your machine by a hash and by nothing else, so that ID is the only way to ask what it holds for you, have it deleted, or object to it — quote it and we can find your row; without it we cannot. The second is the install record: one row written the first time an install reports and kept rather than deleted after 90 days, holding the install identifier, the day, the place its address resolved to, the versions and the operating system — not the address, and nothing about your code. It is what lets us say how many installs there have been over the years. Both are described in full in the privacy policy, and both are deleted if you ask.

The bottom of What Community Includes: the ways to lift the caps, and How these are counted — the row that copies your usage ledger ID and opens the privacy policy
The end of What Community Includes: how the caps are counted, and the row that hands you your ledger ID.

19. Evaluation & activation

Fucini Coverage Studio is distributed as an evaluation pre-release. On first run you're asked to agree to evaluate it, and the trial begins — every feature is available during a 14-day trial, counted from the first time you use it on that install. There is no fixed date after which anything stops.

From version 2.2026.2 the trial of a new install begins as soon as the extension has reached the licence server once; until then it runs on the Community tier and says so. In a development container or a Codespace no trial begins — a subscription code, a key or the 7-day pass unlocks the full set there.

When the trial ends nothing is locked out: the extension settles onto the free Community tier. To get the full set back, activate — activation connects to the license server and applies the returned key automatically, with no email and no key to copy by hand:

Show License / Activation: the trial state, and the buttons to enter a subscription code, see the plans or request a licenceScreenshot pending — add assets/img/licence-dialog.png (see SCREENSHOTS.md).
  1. Run Fucini Coverage: Show License / Activation (also reachable from the status bar once the trial/key has expired) and click Request License… (or Request Renewed Key… if you've activated before).
  2. Confirm the request. The key is issued automatically, and your contact details from any prior request are reused rather than asked for again.
  3. That's it. The activation key is generated and written to fuciniCoverage.license.key automatically. The status bar switches from the trial to an activated license within a moment.

The manual route in one picture: open the licence panel, choose Enter Key, paste the key from your email, and the banner turns to “Activated”.

Activating by hand: the licence panel, the activation dialog, Enter Key, the pasted key, and the banner turning to ActivatedScreenshot pending — add assets/img/activate-key.gif (see SCREENSHOTS.md).

If the automated request ever fails (no connection, server issue): run Fucini Coverage: Copy Activation Request Code, send it via the contact page or info@fucini.consulting, and paste the FCK1.… key you receive back with Fucini Coverage: Enter Activation Key (or directly into settings.json):

{
  "fuciniCoverage.license.key": "FCK1.…paste the whole key…"
}

The setting name is fuciniCoverage.license.key (user/global scope). The key is bound to your machine and OS user, may carry an expiry, and can enable or limit individual features and cap coverage loads per day. If it shows “invalid for this machine”, request a fresh key from this install — a key issued for a different machine will never validate here.

In Visual Studio. There is no free tier in that edition: without a subscription nothing is read. With one, the plan decides there what it decides in VS Code — a feature the plan leaves out is withheld, and its command says so instead of running. The oldest version the licence server still supports holds there as well: a build below it is told once a day, with the date it stops, and goes on working until then. Being offline never stops a build.

The free Community tier: a weekly allowance

Community never stops showing coverage. The gutters, the overview ruler, hovers, CodeLens, the Coverage view, watch mode, diff coverage and history are not counted at all, and loading a tracefile by command is capped only at 25 a day. What is metered is output: five a week each of opening the HTML report, exporting, comparing two runs, checking the thresholds and viewing the annotated source in place.

A week is yours, not the calendar's: it starts with the first use and ends seven days later. When an allowance is used up the message names the action and the day it comes back, and after that one message only the status bar mentions it. Fucini Coverage: What Community Includes lists every allowance with how much is used and when it resets, before you ever reach one.

The weekly allowance: five uses of Open HTML Report across three days, a sixth refused with the day the count resets, and the week ending seven days after the first use; gutters, hovers, CodeLens and the Coverage view are never countedScreenshot pending — add assets/img/weekly-allowance.png (see SCREENSHOTS.md).
The message at a Community limit: Checking coverage thresholds, all 5 used, the day it resets, and the buttons Subscribe, 7-Day Pass and What Community IncludesScreenshot pending — add assets/img/community-limit-prompt.png (see SCREENSHOTS.md).
What Community Includes: each allowance with how much is used and the day it resets, then the features that are not includedScreenshot pending — add assets/img/community-includes-weekly.png (see SCREENSHOTS.md).

Three details belong to the paid plans while their findings stay free: Community marks every line that has surviving mutants and says how many, but not what each mutant changed; it says how many tests ran a line, but not their names; and it shows a run's Max CRAP, but not the ranked Riskiest Methods list.

A mutant hover in Community: 2 mutants survived and 2 more detected on the line; what each mutant changed is part of the paid plansScreenshot pending — add assets/img/mutant-hover-community.png (see SCREENSHOTS.md).

If you were already using Community when the weekly allowance arrived (0.2026.83), your previous caps stay for 30 days; you are told once, with the date. The counters are kept on your machine — in VS Code's own storage and in ~/.fucini-coverage/, so a new VS Code profile continues the same week — and are never sent anywhere.

The 7-day pass

Not ready for a subscription? A 7-day pass is everything in Pro for one week, paid once: nothing renews and there is nothing to cancel. Buy it on the pricing page (the message at a Community limit has a button for it), and the activation code arrives by email.

The 7-day pass on the pricing page: everything in Pro for one week, paid once, with the Get a 7-day pass buttonScreenshot pending — add assets/img/pricing-week-pass.png (see SCREENSHOTS.md).
  1. Run Fucini Coverage: Enter Subscription Code — it exists in the Community edition and in Pro alike.
  2. Choose Pro and paste the FCB1-… code from the email.
  3. That's it. The key is issued and applied for you, and works offline. The week runs from the payment, so activate when you buy. When it is over the extension returns to Community by itself and keeps showing coverage.
Enter Subscription Code, step 1: choose Pro from the list of plansScreenshot pending — add assets/img/pass-step-plan.png (see SCREENSHOTS.md).
Enter Subscription Code, step 2: paste the FCB1 code from the purchase email and press EnterScreenshot pending — add assets/img/pass-step-code.png (see SCREENSHOTS.md).

In Visual Studio. The same code activates Fucini Coverage Studio for Visual Studio, 2022 and 2026: open Tools → Coverage Studio → Licence…, paste the code, choose the plan it is for and press Activate. The Coverage window then says Activated above the tree; opened with its caret, the row shows the date the key is valid until and a button to your account. One machine is one seat: activate VS Code or Visual Studio, and the other editor on the same machine follows by itself — Visual Studio reads VS Code's key and VS Code reads Visual Studio's — so nothing is entered twice and no second seat is taken. Both keep a key alive the same way: Pro Plus, Business and Enterprise check in twice a day, and a Pro key is renewed in the week before it runs out.

Visual Studio: the Coverage window says no subscription covers this machine, and the Licence dialog takes the subscription code
Visual Studio: the Coverage window after an activation — Activated, valid until a date, and a button to the account

Moving to a new computer, and managing seats

A key is bound to one machine, so a new computer needs a new one — and your subscription only pays for as many machines as it says. Free the old one yourself: sign in at manage your subscription, find the seat you no longer use and choose Free up, then activate the new machine with the same code. Buying Pro does not email you a password — your account exists, it simply has none yet, so the first time you go there use set or reset your password with the address you subscribed with.

On Business and Enterprise, invite each colleague by email from that same page. Everyone gets an activation code that is theirs alone, and once they use it their address appears against their seat — so when somebody leaves you can see which seat was theirs and free it for the next person. An invitation holds a seat from the moment you send it and expires after 14 days if it goes unused; withdraw one to get the seat back straight away.

Testing pre-release builds

New work reaches fucini.software before it reaches the Marketplace, and you can ask to be offered it. Open the Coverage view, expand the licence panel and press Test pre-release builds… — or set fuciniCoverage.update.preRelease. From then on the extension checks a separate pre-release feed here as well as the ordinary one, and offers whichever is newer.

The licence panel in the Coverage view, expanded: a Pro licence valid until 2027-03-19, and the button labelled Test pre-release buildsScreenshot pending — add assets/img/licence-prerelease.png (see SCREENSHOTS.md).

Pre-releases are tested, but they are the builds we are least sure of — you would be volunteering to find what we missed. Joining tells us that this installation is on the channel, so we know how many people are testing and can say what changed; leaving puts you back on the ordinary path at the next stable release. There is not always a pre-release to be had, and joining when there is none costs nothing: the extension finds an empty feed, says nothing about it, and goes on offering stable releases until one is published.

The same panel once the install has joined: an update bar offering 0.2026.84 while 0.2026.83 is running, the button now reading Leave the pre-release channel, and a line saying the install is on the channelScreenshot pending — add assets/img/licence-prerelease-joined.png (see SCREENSHOTS.md).

20. Contact & license

Questions, bug reports, or alternate licensing terms — see the contact page or email info@fucini.consulting. Licensed under MIT with an attribution-in-release-notes condition; see also the Notice.

21. On the command line

The reader runs without an editor as well: npm install -g fucini-coverage, free, on Windows, Linux, WSL and macOS. fucini-coverage check coverage/lcov.info --lines 80 is the gate a pipeline fails on; summary, export, report, badge and compare do what the editors' commands of those names do, and mcp serves the six tools of the section above to an agent on a server. It reads fucini-coverage.json, the settings file the Visual Studio edition reads, so the thresholds are set once. fucini-coverage help <command> explains each; the full page is fucini-coverage on npm.

The command line on the demo: --help, summary, check with two gates passing, export as Markdown, compare against a baseline, badge, report and the MCP server's helpScreenshot pending — add assets/img/cli-demo.gif (see SCREENSHOTS.md).