Fucini Coverage Studio for Visual Studio

Reads the coverage file your build already wrote and paints it on the code. Visual Studio 2022 and 2026 — Community, Professional and Enterprise alike.

Your build, your CI job or your target already writes a coverage report: lcov, llvm-cov, gcov, Cobertura, JaCoCo, OpenCover, coverlet, TRACE32 — 25 formats. This extension opens it and shows you, in the editor, what your tests never ran. It does not use Visual Studio's own code coverage, which on Visual Studio 2022 is Enterprise-only: on Community and Professional it is the only coverage the IDE will show, and on Enterprise it reads the reports Visual Studio's own tool cannot.

It is the Visual Studio edition of Coverage Studio for VS Code: the same reader, so the same report gives the same numbers, to the digit, in both editors, and the same fuciniCoverage.* settings, read from .vscode/settings.json.

Every project of a folder in one window. Open a folder with several projects in it and the Coverage window holds them all: collapse the tree and you read every project's coverage on one screen, with the bar and the score beside each; open a folder and you are at its files, a file and you are on its lines.

On the command line too. The same reader as this extension, free, for the places an editor is not — a CI gate, a badge, an HTML report on a build server, an MCP server for an agent: npm install -g fucini-coverage, then fucini-coverage check coverage/lcov.info --lines 80. See fucini-coverage on npm.

New in 2.2026.2: the Microsoft Testing Platform, and an excluded line is grey

A test project on the Microsoft Testing Platform — xunit.v3 with UseMicrosoftTestingPlatformRunner, MSTest.Sdk, the NUnit and MSTest runners, TUnit — is a program of its own, and the .NET 10 SDK's dotnet test will not start one. Run Tests with Coverage now runs each such project as the program it is, with the platform's own flags, for one test at the caret and per test; a solution that mixes platform and VSTest projects runs each its own way. A line excluded from coverage is drawn grey in the margin, with how it was excluded and why in Quick Info, so it is never read as untested. Choose Diff Base… picks the git ref for diff coverage from the repository's own branches and tags. A tracefile named by a URL in coverageFile.paths is fetched as the CI baseline is. A solution kept in a folder of its own, with its projects beside it, has those folders searched and watched too. Files a report names that are not on disk can be left out with missingSources.includeInTotals.

2.2026.0: your AI agent can ask

An agent that writes tests could run them and read a percentage. It could not ask what this window knows. Now it can: turn on fuciniCoverage.mcp.enabled and Visual Studio runs an MCP server with six tools — the gaps of a file or a function, the tests that ran a line, the coverage of a diff, what moved since the last run, the run's totals, and the command that runs the tests with coverage. They answer from the run that is loaded, with the same exclusions and the same numbers as on screen. On 127.0.0.1 only, behind a token of your own, closed to web pages, off until you turn it on. Copy MCP Server Configuration puts the client's entry on the clipboard.

In the editor

• A margin bar per line — red never ran, amber partly, green ran in full, or a heatmap by visit count, in colours you choose with a live preview; teal where two combined reports disagree.
• Inline hit counts — ×12 after the line.
• A line above each function with its coverage, branches, complexity, CRAP score and MC/DC, beside Visual Studio's own CodeLens.
• Stripes on the scroll bar for every uncovered and partly covered line.
• A hover that says which branch was not taken and which condition was never shown to matter, in words.
• A dot on a line you have edited since the report was written.
• Next and Previous Uncovered, and the next partly-tested decision, as two-stroke chords under Ctrl+Shift+U.

The Coverage window

Under View → Other Windows → Coverage: every file with its lines, branches, functions, MC/DC and CRAP score, one score over all of them, sortable, the files no test loaded listed beneath as unmeasured. A menu on each row opens the file or its folder and copies its path. The status bar carries the run's score and the open file's, each opening the full card.

What it reads

lcov, llvm-cov, gcov and gcovr, Cobertura, JaCoCo, Istanbul, Clover, OpenCover and coverlet, coverage.py, SimpleCov, Go, GNATcoverage, BullseyeCoverage, Testwell CTC++, VectorCAST, TRACE32, xccov, Coveralls, SonarQube generic, EMMA, NCover, dotCover, UCIS and Visual Studio's own .coveragexml — gzipped or not, several at once, merged. Lines, branches, conditions, functions and MC/DC are counted; PIT and Stryker mutation reports are read mutant by mutant. GCC 14's condition coverage is shown line by line: which outcome of which condition is missing. And the .coverage file Visual Studio's own Analyze Code Coverage writes is converted with dotnet-coverage and loaded by itself.

Whatever wrote the file: C, C++, C#, Visual Basic, Java, Python, Go, Rust, Swift, Objective-C, Ada, PHP, Ruby, JavaScript and TypeScript.

Settings, in 18 languages

The gear in the Coverage window's toolbar opens every setting, grouped and explained, written to this edition's user settings or the folder's .vscode/settings.json — the file VS Code reads too. Getting Started under Tools → Coverage Studio walks the six steps from a report to the lines nobody tests, and opens by itself the first time.

Licence

Included with every paid Coverage Studio plan — Pro, Pro Plus, Business and Enterprise — and covered by a 7-day pass for its week. A machine where Coverage Studio for VS Code is activated needs nothing more: the key is found by itself. Anywhere else, Tools → Coverage Studio → Licence… takes the subscription code from your activation e-mail. There is no free tier in Visual Studio; without a subscription no coverage is read. What a plan includes is the same in both editors: a feature the plan leaves out is left out here as in VS Code.

Plans and prices: https://fucini.software/coverage-studio/pricing.html

Two reports, one answer

When two reports measure the same code on purpose — the same sources built by clang and by GCC, or the unit and the integration tests of one build — the newest no longer has to win. Right-click a file in the Coverage window and pick Choose Coverage Source..., or use Tools → Coverage Studio → Choose Coverage Source for This File...: each report with its own figures, then Combine them — agree (covered only where every report ran a line) or — union (covered where any did), for the file, its folder or a pattern. The lines the reports disagree on are teal, with what each report said; the row, the status bar and the cards say where the numbers come from.

Coverage after every test run

Run your tests as you always do. Tools → Coverage Studio → Collect Coverage in Test Explorer… puts one .runsettings beside the solution — picked up by itself with Tools → Options → Test → Auto detect runsettings files on, or selected once under Test → Configure Run Settings — and from then on every Test Explorer run writes a Cobertura report under the test project, which is loaded the moment it appears, merged with whatever the settings name. No hook into Test Explorer, so nothing to break with the next testing platform. 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. Run Native Project with Coverage does it for a C++ startup project — under clang-cl instrumentation and llvm-cov on the ClangCL toolset, or under OpenCppCoverage where it is installed — the run the Enterprise edition kept to itself and the retired plugin used to give.

Since the last run, and against the gates

Every load is compared with the one before it: a triangle in the margin on each line that started or stopped running, the trend beside the score, and Compare with Last Run for the files whose numbers moved. Turn on history.enabled and the runs are kept, so the comparison survives a restart; turn on gitDiff.enabled and the run is cut down to the lines your branch changed. Check Coverage Thresholds judges the run against your gates, and with compliance.diagnostics, problems.enabled or problems.perLine the findings sit in the Error List beside the compiler's own.

A gate on new code. threshold.newCode asks that the lines changed against a ref — a branch, a commit, a tag — are tested, whatever the project's total is; gitDiff.author and gitDiff.since make it the lines one person wrote, or the lines written since a day. Show Indirect Coverage Changes… lists what a review of the diff cannot see: the lines nobody edited that stopped running.

Where the next test goes

Under the tree, Risk hotspots: the functions where complex code meets little coverage, worst first by CRAP score, each opening its file at the function. And a second dropdown beside the sort: all files, files with gaps, untested files, or the files changed since the last run. For a .NET report a third one shows the run by namespace, class and method instead of by folder, each with its own numbers, every method opening where it is written. And a search box: a name, or a comparison such as lines < 80%, and the tree keeps only the rows that answer it, as you type. A coverage session adds every load up until you end it — unit tests, integration suite, a walk through the program — and the trend under the toolbar draws the saved runs' line coverage, one dot per run; Compare Two History Runs… puts any two of them side by side, and Compare with CI Baseline holds the run against the report the main branch's build published, from a URL or a downloaded artifact — a GitHub or GitLab artifact's zip is opened, and the report in it found — the status bar's card says where you stand against it after every load.

Which tests ran this line

Where the report says — coverage.py contexts, OpenCover, an lcov tracefile written per test, or a per-test run of Run Tests with Coverage — the hover names the tests that ran a line, the function's lens counts them, and Show Tests That Ran This Line… opens the one you pick where it is written.

With the runner's results file beside the report — TRX or JUnit XML — a line that a failing test ran gets a red bar, and the hover names the failing tests. Run Tests Affected by My Changes… lists the tests that went through the code you just edited, and runs only those. Show Minimal Test Set… finds the fewest tests that still run every line the suite runs, and the tests that add no line of their own.

Leaving code out

Exclude from Coverage on a row of the Coverage window, or on the file in front, writes the ignore rule for you and the numbers move at once. For .NET, ignore.attributes honours [ExcludeFromCodeCoverage] — and any attribute you name — whatever tool wrote the report, and ignore.namespaces leaves whole namespaces out. Select lines and take Exclude Selection from Coverage from the light bulb: [ExcludeFromCodeCoverage] above a member, or lcov's LCOV_EXCL markers in the file's own comment sign, written for you.

An exclusion can say why — the text after the marker, or the attribute's Justification — and Export Coverage Report… lists every exclusion with its reason, for the review a certificate asks for; exclusions.requireReason makes one without a reason a finding. LCOV_EXCL_BR_LINE takes a line's branches out and leaves the line in, and gcovr's GCOVR_EXCL_ markers are read as lcov's are.

One test, with coverage

Caret in a test, Run This Test with Coverage: that method, class or file runs with coverage and nothing else does — C#, VB, F#, JavaScript, TypeScript, Python, Go and Rust, read off the text, no language service needed.

Would a test notice?

Run Mutation Tests Here mutates the function the caret is in — Stryker.NET for C#, StrykerJS for JavaScript and TypeScript, PIT for Java — and loads the report beside the coverage on screen: a minute for one function, where a project's mutation run takes an hour.

The app itself, with coverage

Run App with Coverage… starts the solution's .NET app under Microsoft's dotnet-coverage and runs until you close it. What you walked through — the screens before a release, a customer's steps — is loaded like any run, and in a coverage session added to what the tests ran.

Coverage after every save

Turn on testRun.onSave and saving a source runs the tests that cover it — for a .NET solution only the test projects that reach the saved file's project — and the gutter follows a moment later. Nothing hooks Test Explorer; the tests run as Run Tests with Coverage runs them.

Reports, exports and a badge

Show Annotated Source opens the file as a page — every line in its colour, every finding beside it — that scrolls with the editor. Open HTML Report is the run on one page in your browser; Generate Full HTML Report an index per folder and a page per file, for the wiki or the build server. Export Coverage Report… writes CSV per file or per function, Markdown, LCOV, Cobertura, SARIF for the uncovered lines, an SVG badge or Fucini's own JSON. Generate Coverage Badge keeps the badge in the repository, by itself after every load with badge.autoUpdate.

.NET, without ceremony

Designer files, *.g.cs, *.generated.cs, AssemblyInfo, global usings, obj\ and EF migrations are left out of every total unless ignore.generated is turned off. A test project without coverlet.collector is run with the collector the test SDK already ships. A run whose tests failed leaves the last good coverage on screen when testRun.skipWhenTestsFail says so. And a fucini-coverage.json beside the solution holds the team's settings for both editions and every teammate.

Nothing hooks Test Explorer, so Visual Studio 2026 and Microsoft.Testing.Platform work as they are: the collector writes the report, the extension reads it.

Not in this edition

The Test Coverage panel is a VS Code API, and Solution Explorer cannot show badges.

Links

• Getting started: https://fucini.software/coverage-studio/getting-started.html
• User guide, with the In Visual Studio boxes: https://fucini.software/coverage-studio/userguide.html
• Changelog: https://fucini.software/coverage-studio/changelog.html
• Download and checksums: https://fucini.software/coverage-studio/download.html
• Privacy: the licence check, and the pings Coverage Studio for VS Code sends too — one at the first start, one short licence message a day, and a day's usage summary only when fuciniCoverage.telemetry.enabled is on. Never source code, file paths or project names: https://fucini.software/coverage-studio/privacy.html#telemetry