dotCover: A Complete Guide to .NET Code CoveragedotCover is JetBrains’ code coverage tool for .NET that helps developers measure how much of their codebase is exercised by automated tests. This guide covers what dotCover does, why coverage matters, how to install and run it, interpret reports, integrate it into CI/CD pipelines, use advanced features, and apply best practices for effective test coverage.
What is Code Coverage and Why It Matters
Code coverage measures the percentage of source code executed while running a test suite. It’s a metric — not a goal in itself — that helps you:
- Identify untested code paths that may hide bugs.
- Prioritize test writing to cover critical logic.
- Validate refactors by ensuring tests still exercise intended behavior.
High coverage doesn’t guarantee correctness, but low coverage is a clear signal that parts of the system lack automated verification.
What is dotCover?
dotCover is a .NET-focused coverage tool from JetBrains that integrates with Visual Studio, JetBrains Rider, command-line workflows, and CI systems. Key capabilities include:
- Statement and branch coverage reporting.
- Merging and filtering coverage snapshots.
- Highlighting coverage in IDEs and generating HTML/XML reports.
- Support for .NET Framework, .NET Core, and .NET 5+ projects.
- Continuous integration support via console runner and dotCover tools.
dotCover is particularly valued for tight IDE integration (Rider and Visual Studio) and for being part of the JetBrains ecosystem.
Editions and Licensing
dotCover is available as part of JetBrains’ product suite; Rider includes dotCover out of the box, while Visual Studio users can add dotCover as a plugin. Licensing and edition details change, so check JetBrains’ site for current terms. dotCover also offers a command-line runner suited for CI usage.
Installing dotCover
- JetBrains Rider: dotCover is integrated — no separate install required.
- Visual Studio: install the dotCover extension/plugin via the JetBrains site or Visual Studio Marketplace.
- Command line: download the dotCover Command Line Tools package from JetBrains to run coverage in CI.
After installation, ensure your projects build and that test runners (NUnit, xUnit, MSTest) are available.
Running Coverage in the IDE
In Rider or Visual Studio with dotCover installed:
- Open the solution and run tests via the unit test runner.
- Use the “Cover Unit Tests” action (or right-click a test/project) to run tests under the dotCover profiler.
- View coverage results as color-highlighted code in the editor and in the Coverage Results window.
The IDE displays covered code in green and uncovered code in red (or similar color scheme), letting you navigate directly from report to source.
Command-Line Usage and CI Integration
For automation, use the dotCover console runner. A typical workflow:
- Use dotCover to run coverage while executing tests: it launches the test runner (e.g., dotnet test, NUnit Console) under the profiler.
- Save a coverage snapshot (.dcvr).
- Optionally, merge snapshots and generate reports in HTML, XML, or JSON for CI artifacts.
Example outline (simplified):
- Run tests under dotCover and collect snapshot.
- Convert snapshot to HTML report.
- Publish report as CI job artifact.
dotCover integrates with common CI systems (Azure Pipelines, GitHub Actions, TeamCity) using shell/script steps. Use the console runner on build agents and make sure test dependencies and .NET SDKs are installed on agents.
Interpreting Coverage Reports
dotCover reports provide multiple views:
- File- and assembly-level coverage percentages.
- Line-level and branch-level information.
- Coverage highlighting in source.
- Filters that exclude generated code, third-party libs, or specific namespaces.
When evaluating reports, focus on:
- Critical business logic and public APIs.
- Newly changed files in pull requests.
- Tests that exercise edge cases and error handling.
Avoid setting blind numeric thresholds; use coverage trends and focused per-area goals.
Filtering and Masking
dotCover allows excluding assemblies, classes, methods, and generated code via filters and attributes. Common exclusions:
- Auto-generated files.
- Third-party libraries.
- Code covered by integration tests not executed in unit test runs.
Use coverage filters to keep reports actionable and avoid inflation from irrelevant code.
Branch Coverage and Complex Flows
dotCover supports branch coverage, which reports whether each branch of conditional statements was executed. Branch coverage is especially useful for:
- Multi-conditional logic.
- Error paths and exception handling.
- Feature toggles and configuration-based flows.
Branch coverage will typically be lower than line coverage; treat both together to assess test completeness.
Merging Snapshots and Multi-Target Projects
For solutions that run tests across different environments (e.g., .NET Framework and .NET Core variants), run separate coverage sessions and merge the resulting snapshots. Merging yields a combined report reflecting all executed paths across runs.
Common Workflows & Examples
- Pull Request Validation: Run dotCover in CI to produce coverage reports and fail builds if coverage drops for modified files.
- Nightly Full Coverage: Schedule full test + coverage runs that generate detailed HTML reports for QA and developers.
- Local Development: Developers run “Cover Unit Tests” in Rider/Visual Studio to see immediate feedback on uncovered lines.
Tips and Best Practices
- Prioritize tests for public APIs and critical modules over chasing 100% coverage.
- Add coverage checks for changed files in PRs rather than enforcing global thresholds.
- Exclude generated and third-party code.
- Use branch coverage to assess conditional complexity.
- Keep CI agents’ environment similar to local dev to avoid “works locally but not in CI” coverage discrepancies.
- Regularly review and prune exclusions and filters to ensure they remain justified.
Limitations and Caveats
- Coverage measures execution, not correctness. Passing tests with high coverage can still miss logical bugs.
- UI and behavior may change with JetBrains’ updates; consult current dotCover docs for version-specific features.
- Some dynamic code paths (reflection, runtime code generation) may be harder to measure accurately.
Alternatives and When to Use Them
Other .NET coverage tools include Coverlet, NCover, and OpenCover. Consider alternatives if:
- You need an open-source solution deeply integrated into dotnet CLI workflows (Coverlet).
- You require existing tooling compatibility or specific report formats.
dotCover stands out for IDE integration, rich reporting, and JetBrains ecosystem compatibility.
Quick Reference — Commands (Conceptual)
- Cover unit tests in IDE: Use “Cover Unit Tests” action.
- Console runner: run dotCover to execute test runner, save snapshot, and generate reports.
- Merge snapshots: use dotCover’s merge utility in console tools.
- Export report: dotCover can emit HTML and XML for CI consumption.
Refer to your installed dotCover version’s docs for exact command-line flags and syntax.
Summary
dotCover is a mature, developer-friendly .NET code coverage tool that brings deep IDE integration, flexible reporting, branch coverage, and CI-friendly command-line utilities. Use it to focus testing effort, monitor coverage trends, and validate that critical code paths are exercised — but don’t mistake coverage percentage for correctness.
Leave a Reply