What's New in dotCover

Multiple minor improvements and bug fixes.

Reworked Continuous Testing

We've reworked Continuous Testing in Visual Studio and JetBrains Rider to improve usability:

• Before: Any unit test session could be converted into a Continuous Testing session, which could lead to confusion with multiple sessions.

• Now: There is a single, separate Continuous Testing Session. This change makes it easier to manage and understand your testing workflow.

Continuous Testing indicator

JetBrains Rider and ReSharper get a new icon/indicator for Continuous Testing. The icon shows the current testing state, including whether there are any failed tests. In addition, it provides several quick actions: enabling/disabling Continous Testing, viewing coverage results, toggling code highlighting, and more.

Adjustable highlighting colors

Now, you can adjust the colors used to highlight code coverage in the editor. The colors are applied to coverage makers in the gutter and line background. The feature is currently available only in JetBrains Rider.

Minor stability improvements and bug fixes.

Support for MAUI applications

Now, you can perform coverage analysis of unit tests and applications based on the MAUI framework. Currently, dotCover supports only WinUI desktop applications targeting .NET 7.0+ on Windows. This applies to dotCover standalone and dotCover in ReSharper and Rider.

Improved coverage highlighting

dotCover in Rider and ReSharper gets improved code highlighting: new background colors, a new gutter icon for partially covered code lines, and other minor changes.

Improved command-line tools

dotCover command-line tools are now provided as a cross-platform framework-dependent .NET tool: https://www.nuget.org/packages/JetBrains.dotCover.CommandLineTools/2023.3.0

This tool acts as a default solution for CI/CD scenarios and replaces the previous https://www.nuget.org/packages/JetBrains.dotCover.GlobalTool

Bug fixes and stability improvements.

Enabling Continuous Testing with a shortcut

Now, you can trigger Continuous Testing directly by applying a shortcut. Previously, you could do this only indirectly by building or saving your project. This feature works in both Visual Studio with ReSharper and JetBrains Rider.

.NET 7 support

dotCover now lets you perform coverage analysis in .NET 7 applications on Windows, macOS, and Linux.

Improved ARM CPUs support

• Linux arm32  – Now, you can run the dotCover console runner on arm32 CPUs on Linux. Supported frameworks: .NET Core 3.1, .NET 5.0-7.0.

• Windows arm64  – Now, you can use dotCover on arm64 CPUs on Windows. This applies to all versions: dotCover standalone, dotCover in Rider, dotCover in Visual Studio, and the dotCover console runner.

Improved Unity support in dotCover for JetBrains Rider

Previously, to analyze the coverage of Unity tests, you had to restart Unity with enabled coverage support. Beginning with this release, restarting Unity is no longer required, and test coverage is supported out of the box.

Various improvements

• Easier navigation to tests in JetBrains Rider: We've added the Show Covering Tests action to the dotCover context menus in the code editor and the Unit Test Coverage window. The action shows the popup with all covering tests right in place. The popup also lets you create a new coverage session.

• Faster shadow copying in both Visual Studio and JetBrains Rider: Now, dotCover copies only assemblies and symbol files required for Continuous Testing. This improves the overall performance, especially on large projects, as dotCover no longer needs to copy the entire working directory. If required, you can adjust the shadow-copy file filter in dotCover settings.

Quick view of coverage results in JetBrains Rider

Now, you can quickly view coverage results for the currently opened file by looking at the "shield" icon. Clicking the icon navigates you through the uncovered statements.

Support for musl-based Linux distributions

Excluding code from coverage analysis using comments

You can now use comments to exclude certain lines or blocks of code from coverage analysis.

New coverage report types

We're adding new report types that include per-test coverage information: FileCoverageXml, DetailedFileCoverageXml, FileCoverageJson, and DetailedFileCoverageJson.

New reports include three sections:

• Files, which includes information about covered source code files. Detailed reports also provide information about covered ranges per file.

• TestLists, which offers information about tests aggregated by test set.

• Tests, which contains detailed information about each test.

Performance improvements

We've improved the post-processing of coverage data. For example, the console runner (with IncludePerTest=true) takes significantly less time to generate reports.

.NET 6 support

dotCover lets you perform coverage analysis of applications targeting .NET 6.

Support for Apple M1

Now, the dotCover command-line runner can work on computers with Apple M1 processors. The tool supports coverage analysis of .NET 6 applications (native mode) and .NET 5 applications (Rosetta 2 mode).

Code Vision metric for code coverage

dotCover in Rider adds a new Code Vision metric. For each type member covered with tests, dotCover shows the number of successful and failed tests. You can also use a Code Vision notification to run, cover, and debug the tests.

Improved dotCover .NET global tool

The dotCover .NET global tool gets support for merge and report commands.

Performance improvements

We improved performance of the dotCover command-line runner resulting in faster coverage analysis.

Per-test coverage info in the console runner

The dotCover console runner is able to collect coverage information for individual tests and show it in the generated reports. Currently, only the following test runners are supported: dotnet test, dotnet vstest, vstest.console.exe. For example: dotCover.exe dotnet --output=AppCoverageReport.xml --reportType=XML --IncludePerTestInfo=Method -- test "C:\MyProject\MainTests.csproj"

Improved coverage performance

• Now, dotCover can run coverage analysis of test classes in parallel within one assembly. In particular cases this may result in faster coverage analysis. You can enable this feature with the Run test classes in parallel checkbox in dotCover settings.

• Preloading of unit test runners is now available for .NET Core and .NET projects (this lets coverage analysis start faster as unit test runners are already loaded in memory). You can enable this feature with the Preload test runners checkbox in dotCover settings.

Various improvements

• Improved support for C# 8.0 and C# 9.0 in the coverage tree (showing default interface implementations, and more).

• Now, dotCover offers to restart Unity Editor in case coverage filters are changed.

• Various bug fixes.

Updated filtering settings in ReSharper

Now, you can configure coverage filters in Visual Studio in the same way as in Rider.

dotCover console runner as a .NET global tool

Now, you can install the dotCover console runner as a dotnet global tool: dotnet tool install --global JetBrains.dotCover.GlobalTools --version 2021.1.0 Use it to analyze coverage in your .NET Core projects and unit tests.

Improved UI in the Coverage Configuration window.

With the new UI, it's easier to configure and run coverage analysis sessions.

.NET 5 support

dotCover lets you perform coverage analysis of applications targeting .NET 5.

Improved continuous testing.

Now, you can refine what projects should be built when a continuous testing session is triggered. This lets you speed up continuous testing sessions. The feature works in both Visual Studio and Rider.

Improved support for projects targeting multiple frameworks.

Now, the Unit Tests Coverage window in both Visual Studio and Rider lets you filter coverage results by target framework.

Methods with outdated coverage info are shown in the coverage tree.

Before 2020.3, methods with outdated coverage info were highlighted only with a marker in the gutter. Now, in Visual Studio, methods with outdated coverage info are also highlighted in the Unit Tests Coverage window.

Code coverage in solution highlight level options.

Now, you can use the Rider’s solution highlight level options to turn code coverage highlighting on and off.

Improvements in the Unit Tests Coverage window in Rider:

• You can export coverage reports from this window.

• You can perform quick search in this window.

• You can navigate from a symbol in code to this symbol in the coverage tree.

Improvements in the dotCover console runner:

• The --reportype=SummaryXml parameter lets you create a new Summary report type which includes data on how many classes, methods, and statements are covered in total.

• Now, the runner can generate reports of several types at once: --reporttype=HTML,SummaryXml --output=report.html;summary.xml

• The runner for Linux (any distribution with GLIBC_2.23 or later) is now able to perform analysis on ARM64 systems.

Coverage filters in JetBrains Rider

Now, you can apply both runtime and coverage results filters in JetBrains Rider.

Access to source code files from the command line

In the console runner, all coverage commands get two additional parameters: --SourcesSearchPaths and --AllowSourceServersAccess. They let you specify the custom path to source code and download source code from source servers correspondingly.

Support for Unity on Windows, macOS, and Linux.

dotCover in JetBrains Rider supports coverage analysis of tests in Unity projects.

Support for Microsoft Fakes

dotCover is able to analyse coverage of tests using Microsoft Fakes. Note that Microsoft Fakes is supported not only by dotCover in Visual Studio (2017 or later) but also by the dotCover command-line tool. In the latter case, you should run tests using vstest.console.exe (from Visual Studio 2017 or later).

Grouping coverage results by namespaces

dotCover is able to group coverage results by nested namespaces in Rider, Visual Studio, and in reports generated by the dotCover console tool.

Support for Mono on Windows, macOS, and Linux.

dotCover 2019.2 gets support for Mono 5.10 and later on Windows, macOS, and Linux. To perform coverage analysis on these operating systems, you must use JetBrains Rider or dotCover console runner. Note that on macOS and Linux only 64-bit processes are supported.

Console runner on Linux and macOS.

Now, you can use dotCover console runner not only on Windows but on macOS and Linux as well. To be more convenient on new platforms, the tool accepts command arguments in Unix-style syntax. For example, now, both /TargetExecutable=MyApp.exe and --targetexecutable:MyApp.exe are valid.

Console runner improvements.

The console runner gets two new commands to simplify coverage analysis of .NET Core and Mono applications and unit tests: cover-dotnet and cover-mono.

The issue with 0% coverage and .NET Core unit tests was fixed. The dotnet dotCover test workaround is no longer needed, but you can still use it if you find this way of running coverage analysis more convenient.

Support for .NET Core unit tests on macOS and Linux. To perform code coverage analysis on these operating systems, you must use JetBrains Rider.

Remote coverage from Visual Studio is no longer available. The feature is removed from dotCover.

Improved coverage filters. Now, there are two groups of filters in the dotCover options: runtime filters (the ones that are applied during a coverage session) and results filters (the ones that are applied to coverage results). The latter are extended with a filter by filename.

Support for multiple target frameworks. Now, if a project targets multiple frameworks, the Coverage Tree will show results separately for each framework (each framework will be shown as a separate node in the tree). Code highlighting also depends on context selected in the editor.

JetBrains Rider integration. In addition to Visual Studio, now dotCover is a part of the JetBrains Rider IDE. In this release, there are two main features supported: code coverage analysis of unit tests and continuous testing.

Support for the dotnet console tool. Now, dotCover command-line runner can be used as an extension to .NET command-line tools (dotnet.exe). For example, you can run coverage analysis of unit tests by running: dotnet dotCover test

Now, when using the dotCover.exe console runner, you should always prefer the cover command over the analyze command. The coverage result depends only on the --ReportType argument: if it is specified, you'll get a report of a certain type; if not, a regular coverage snapshot will be saved.

No more separate continuous testing session - the continuous testing mode can be turned ON for any unit test session.

New continuous testing autostart modes.

Coverage information is now shown in a separate Unit Test Coverage window instead of a per-session Coverage tab. See the aggregated coverage data for all unit test sessions in one place.

dotCover console runner gets the ability to cover arbitrary managed processes and services analyze-everything, analyze-service and send the get coverage snapshot command to the running instance of the console tool. This dramatically eases getting coverage of web apps running on IIS/IIS Express.

.NET Core tests coverage support in the continuous testing mode for NUnit and xUnit.

Quick evaluation of coverage results .The "shield" icon in the gutter of the Visual Studio editor allows you to quickly view total coverage percentage and the number of failed tests. Clicking on the icon navigates you through the uncovered statements.

Improved 'Show Covering Statements'. Now, after you use Show Covering Tests in the editor, the popup window tells you what exact part of your code is covered by these tests: a class, a method, or a particular statement.

.NET Core tests coverage support for MSTest.

Improved performance. Before 2017.2, working with continuous testing on large solutions was a real headache: while tests were executed really fast, it could take several minutes until the subsequent coverage session was finished. The problem no longer exists in dotCover 2017.2: due to the new snapshot format, dotCover provides much faster processing of coverage results.

Coverage results are now shown not only for specific tests, but also for test groups, projects, categories, and so on.

Color-blind markers. Now, markers are able to indicate coverage and test results not only with color but also with their shape.

Add coverage data from snapshots. Now, when viewing coverage results of a particular unit test session ,you can merge them with coverage data from a snapshot.

Highlighting using colored background. Since the new highlighting style (using markers) may not be a good fit for all use cases, we've added an option to switch between markers and colored background or to display both. The old highlighting style also supports the updated logic and displays both tests coverage and test results.

New code coverage highlighting. You can see test results right in the code editor.

More flexible coverage filters.

Ability to filter processes from console runner to reduce unnecessary overhead by excluding child processes that are irrelevant to the coverage analysis.

More convenient debugging of failed tests. You can set a breakpoint and run debugging.

Execution log in the Unit Test Sessions window and in the Continuous Testing Session window.

Ability to exclude auto-properties from coverage analysis with Hide auto-properties option.

Ability to filter processes from console runner to reduce unnecessary overhead by excluding child processes that are irrelevant to the coverage analysis.

Coverage filters are supported in continuous testing.