### dotCover Installation Guide

Source: https://www.jetbrains.com/help/dotcover/Reference__Options__dotCover

A guide detailing the steps required to install dotCover. This covers the installation process for the tool.

```APIDOC
Installation Guide:
  Description: Step-by-step instructions for installing dotCover.
  Covers:
    - Download and installation procedures.
    - System requirements.
```

--------------------------------

### dotCover Installation Guide

Source: https://www.jetbrains.com/help/dotcover/Reference__Options__dotCover__Continuous_Testing

A guide detailing the installation process for dotCover.

```APIDOC
Installation Guide:
  - Description: Step-by-step instructions for installing dotCover.
```

--------------------------------

### dotCover Installation Guide

Source: https://www.jetbrains.com/help/dotcover/Reference__Options__Tools__Unit_Testing__Test_Runner

A guide outlining the steps required for installing dotCover.

```APIDOC
Installation_Guide.html:
  - Step-by-step instructions for installing dotCover.
  - System requirements and prerequisites.
```

--------------------------------

### dotCover Installation Guide

Source: https://www.jetbrains.com/help/dotcover/Reference__Options__Tools__Unit_Testing__VSTest

A guide to installing JetBrains dotCover on your system.

```APIDOC
Installation_Guide:
  Description: Step-by-step instructions for installing dotCover.
  Content:
    - Installation procedures.
```

--------------------------------

### dotCover Installation Guide

Source: https://www.jetbrains.com/help/dotcover/dotCover_Controller

A comprehensive guide to installing dotCover on various platforms and environments, including prerequisites and steps.

```APIDOC
Installation_Guide.html:
  - Provides step-by-step instructions for installing dotCover.
  - Includes system requirements and prerequisites.
  - Covers installation for Visual Studio integration and standalone usage.
```

--------------------------------

### dotCover Installation Guide

Source: https://www.jetbrains.com/help/dotcover/dotCover_Coverage_Configuration

Instructions and guidance for installing dotCover.

```APIDOC
Installation Guide:
  URL: https://www.jetbrains.com/help/dotcover/Installation_Guide.html
  Description: Step-by-step instructions for installing dotCover, including any prerequisites or system requirements.
```

--------------------------------

### Running dotCover Commands

Source: https://www.jetbrains.com/help/dotcover/Coverage-Analysis-with-Command-Line-Tool

Demonstrates how to execute the dotCover command-line tool after installation. This example shows how to access the help information.

```bash
dotCover help
```

--------------------------------

### dotCover Command Line Installation

Source: https://www.jetbrains.com/help/dotcover/Installation_Guide

This snippet demonstrates how to install and uninstall dotCover via the command line, useful for automated or silent installations. It references an external guide for detailed instructions.

```bash
msiexec /i <path_to_installer> /qn
msiexec /x <product_code> /qn
```

--------------------------------

### Launch Visual Studio in Experimental Instance

Source: https://www.jetbrains.com/help/dotcover/Installation_Guide

This command launches a specific instance of Visual Studio, identified by an instance name. This is useful for developing and debugging Visual Studio extensions with isolated configurations.

```bash
devenv.exe /rootSuffix <InstanceName>
```

--------------------------------

### dotCover Installation Guide

Source: https://www.jetbrains.com/help/dotcover/Reference__Options__dotCover__General

Provides instructions and guidance for installing the dotCover code coverage tool.

```APIDOC
Installation Guide:
  Purpose: Step-by-step instructions for installing dotCover.
  Reference: https://www.jetbrains.com/help/dotcover/Installation_Guide.html
```

--------------------------------

### Silent Installation Command Line Parameters

Source: https://www.jetbrains.com/help/dotcover/Installation_Guide

Provides a reference to command-line parameters for silent installation of JetBrains products, including dotCover. This is useful for automated or custom installation scenarios.

```bash
# Example command line parameters for silent installation (refer to the article for full list)
# .JetBrains.dotUltimate.<version>.exe /SILENT /VERYSILENT /SUPPRESSMSGBOXES /NORESTART /LOG="C:\Logs\JetBrains.dotUltimate.log" /INSTALLDIR="C:\Program Files\JetBrains" /ALLUSERS /NORESTART /CLOSEAPPLICATIONS /PASSWORD="<password>"
```

--------------------------------

### Silent Installation Command Line Parameters (PowerShell)

Source: https://www.jetbrains.com/help/dotcover/Installation_Guide

Provides a reference to command-line parameters for silent installation of JetBrains products, including dotCover, using PowerShell. This is useful for automated or custom installation scenarios.

```powershell
# Example PowerShell command for silent installation (refer to the article for full list)
# Start-Process -FilePath ".\JetBrains.dotUltimate.<version>.exe" -ArgumentList "/SILENT /VERYSILENT /SUPPRESSMSGBOXES /NORESTART /LOG='C:\Logs\JetBrains.dotUltimate.log' /INSTALLDIR='C:\Program Files\JetBrains' /ALLUSERS /NORESTART /CLOSEAPPLICATIONS /PASSWORD='<password>'" -Wait
```

--------------------------------

### dotCover How To Guides

Source: https://www.jetbrains.com/help/dotcover/dotCover_Coverage_Configuration

Guides on performing specific tasks with dotCover.

```APIDOC
How To dotCover:
  URL: https://www.jetbrains.com/help/dotcover/How_To_dotCover.html
  Description: Practical guides and tutorials on how to perform various operations and tasks using dotCover.
```

--------------------------------

### dotCover Installation and Licensing

Source: https://www.jetbrains.com/help/dotcover/Reference_Options_dotCover_Filtering

This section provides information on installing dotCover and specifying license information. It also includes links to the installation guide and the dotCover download page.

```APIDOC
dotCover Installation and Licensing:
  Get dotCover:
    - URL: https://www.jetbrains.com/dotcover/download/
  Specify license information:
    - Description: Instructions on how to specify license information for dotCover.
  Installation guide:
    - URL: https://www.jetbrains.com/help/dotcover/Installation_Guide.html
```

--------------------------------

### Start Coverage Analysis for Startup Project (Visual Studio)

Source: https://www.jetbrains.com/help/dotcover/Starting_Manual_Test_Session

Initiates code coverage analysis for the startup project of a Visual Studio solution using dotCover. This action rebuilds the solution and runs the startup project under dotCover's control.

```APIDOC
Command: ReSharper | Cover | Cover Startup Project
Shortcut: Ctrl+Alt+0K, 0P (ReSharper_CoverStartupProject)

Description: Starts a code coverage analysis session for the startup project of the current Visual Studio solution. dotCover rebuilds the solution and launches the startup project under its monitoring.

Usage:
1. Press the shortcut Ctrl+Alt+0K, 0P or navigate through the Visual Studio menu: ReSharper | Cover | Cover Startup Project.
2. Alternatively, use Ctrl+Shift+0A to open the 'Find Action' popup, type 'Cover Startup Project', and select it.
3. dotCover will then open the Coverage Controller dialog and execute the startup project.
4. After the application starts, you can record code coverage for the running process.

Prerequisites:
- PDB information must exist for all target assemblies. It is recommended to use the 'Debug' build configuration.

Related Commands:
- Cover Application... (Ctrl+Alt+0K, 0K): For running projects with custom configurations without changing the main debug/release configuration.
```

--------------------------------

### dotCover Usage Guides

Source: https://www.jetbrains.com/help/dotcover/Reference__Options__dotCover__Continuous_Testing

Links to various usage guides for dotCover, including introduction, how-to articles, unit testing, and code coverage during manual testing.

```APIDOC
dotCover Introduction:
  - Description: An overview of dotCover.
How To dotCover:
  - Description: Guides on performing various tasks with dotCover.
Unit Testing:
  - Index: Index of unit testing related topics for dotCover.
Code Coverage during Manual Testing:
  - Description: How to use dotCover for code coverage during manual testing.
```

--------------------------------

### dotCover Installation Log Locations

Source: https://www.jetbrains.com/help/dotcover/Installation_Guide

These paths indicate where to find the installation logs for dotCover, which are crucial for diagnosing any issues that may arise during the installation process. The log location varies slightly based on the dotCover version.

```text
For v. 2018.1 and above: %LOCALAPPDATA%\JetBrains\Shared\vAny\Installer
For older versions: %LOCALAPPDATA%\JetBrains\Shared\v{internal R# version}
```

--------------------------------

### dotCover Installation and Troubleshooting

Source: https://www.jetbrains.com/help/dotcover/dotCover__Color_Scheme

Information regarding the installation process for dotCover and guidance on troubleshooting common issues that may arise during its use.

```APIDOC
Installation and Troubleshooting:
  Installation Guide:
    - Description: Step-by-step instructions for installing dotCover.
  Troubleshooting:
    - Description: Common problems and their solutions for dotCover.
```

--------------------------------

### Start Coverage Analysis for Windows Services

Source: https://www.jetbrains.com/help/dotcover/Profiling_Guidelines__Windows_Services

Instructions on how to initiate coverage analysis for Windows Services using dotCover, either within Visual Studio or the standalone application. Requires the service to be installed and have PDB information.

```en
In Visual Studio: ReSharper | Cover | Cover Application… ReSharper_CoverApplication
In dotCover standalone application: File | Cover Application...
```

--------------------------------

### dotCover Command-Line Usage Examples

Source: https://www.jetbrains.com/help/dotcover/Coverage-Analysis-with-Command-Line-Tool

Demonstrates common dotCover command-line invocations for coverage analysis, including generating XML reports, running tests with snapshots, and specifying target executables and arguments.

```bash
dotCover cover --xml-report-output AppCoverageReport.xml -- test "C:\MyProject\MainTests.csproj"
```

```bash
dotCover cover --snapshot-output snapshot.dcvr -- test --no-build
```

```bash
dotCover cover --xml-report-output report.xml -- test
```

```bash
dotCover cover --target-executable "D:\Program Files\NUnit 2.6\bin\nunit-console.exe" --target-arguments "D:\Projects\TheApplication\bin\Debug\AppTests.dll" --snapshot-output snapshot.dcvr
```

```bash
dotCover cover --target-executable "D:\Program Files\NUnit 2.6\bin\nunit-console.exe" --target-arguments "D:\Projects\TheApplication\bin\Debug\AppTests.dll" --xml-report-output report.xml
```

--------------------------------

### Start Coverage Analysis for External Applications (dotCover Standalone)

Source: https://www.jetbrains.com/help/dotcover/Starting_Manual_Test_Session_for_External_Applications

This snippet details the process of starting coverage analysis for an external application using the standalone dotCover application. It specifies the menu option to use.

```APIDOC
dotCover Standalone Application:
  Menu Path: File | Cover Application...
```

--------------------------------

### Install dotCover as a Local .NET Tool

Source: https://www.jetbrains.com/help/dotcover/Coverage-Analysis-with-Command-Line-Tool

Installs the dotCover command-line tool locally within a specific directory. This is useful for project-specific installations or when global installation is not desired.

```bash
dotnet tool install JetBrains.dotCover.CommandLineTools --tool-path "some/path"
```

--------------------------------

### Install dotCover as a Global .NET Tool

Source: https://www.jetbrains.com/help/dotcover/Coverage-Analysis-with-Command-Line-Tool

Installs the dotCover command-line tool globally, making it accessible from any directory on your system. This is the recommended method for local development and CI/CD environments.

```bash
dotnet tool install --global JetBrains.dotCover.CommandLineTools
```

--------------------------------

### dotCover Manual Test Session Startup Project Coverage Analysis

Source: https://www.jetbrains.com/help/dotcover/Code_Coverage_during_Manual_Testing

This snippet details how to start a coverage analysis for the startup project within a solution using dotCover. It's a key procedure for manual testing scenarios.

```dotCover
Starting_Manual_Test_Session
```

--------------------------------

### dotCover CI Server Integration

Source: https://www.jetbrains.com/help/dotcover/How_To_dotCover

This documentation covers the setup process for integrating dotCover coverage analysis with both JetBrains TeamCity and third-party CI servers, enabling automated coverage reporting.

```APIDOC
CI Server Coverage Setup:
  Description: Details the configuration for running dotCover coverage analysis on CI servers.
  Integrations:
    - JetBrains TeamCity
    - Third-Party CI Servers
  Related Topics:
    - Server Test Coverage
```

--------------------------------

### dotCover Troubleshooting Guide

Source: https://www.jetbrains.com/help/dotcover/Saving_and_Loading_Coverage_Snapshot

This section provides guidance on troubleshooting common issues encountered while using dotCover. It addresses potential problems and solutions for effective usage.

```APIDOC
dotCover Troubleshooting:

Common Issues:
  - Coverage not being collected: Ensure dotCover is correctly configured and running with the target process.
  - Inaccurate coverage results: Check filters, ensure correct assemblies are profiled, and consider snapshot matching.
  - Performance issues: Optimize filters, avoid profiling unnecessary processes, and ensure sufficient system resources.
  - Command-line tool errors: Verify command syntax, paths, and permissions.

Troubleshooting Steps:
  1. Review dotCover logs for error messages.
  2. Verify configuration settings.
  3. Simplify the scenario to isolate the problem.
  4. Consult the official JetBrains dotCover documentation and support resources.

Related Topics:
  - Introduction: General overview of dotCover.
  - How To: Step-by-step guides for various tasks.
```

--------------------------------

### Start Coverage for IIS Service

Source: https://www.jetbrains.com/help/dotcover/Remotely_Cover_a_Web_Application

Starts code coverage for the IIS service using the dotCover command-line tool. This command is used for applications running directly under IIS. It specifies the output file, report type, and an instance ID.

```bash
dotCover cover-iis ^
--Output=coverageReport.xml ^
--ReportType=XML ^
--Instance=1
```

--------------------------------

### dotCover Server Coverage Analysis

Source: https://www.jetbrains.com/help/dotcover/How_To_dotCover

This guide explains how to set up and perform coverage analysis on a server environment using dotCover. It is relevant for understanding test coverage in server-side applications.

```APIDOC
Server Test Coverage:
  Description: Provides instructions for analyzing test coverage on a server using dotCover.
  Usage Scenarios:
    - Analyze Coverage on a Server
  Related Topics:
    - Setting up Coverage on JetBrains TeamCity
    - Setting up Coverage on a Third-Party CI Server
```

--------------------------------

### dotCover Response File Usage

Source: https://www.jetbrains.com/help/dotcover/Coverage-Analysis-with-Command-Line-Tool

Illustrates how to use response files to simplify complex dotCover command-line parameter sets, including examples of specifying response files directly or using them in conjunction with command-line arguments.

```bash
dotCover cover @args.txt
```

```bash
dotCover cover @"~/config/config.txt"
```

```bash
dotCover cover @"D:\Config\config.txt"
```

```bash
dotCover cover --exclude-assemblies "*.Tests" @filters.txt
```

```bash
--exclude-assemblies ThirdPartyLib
--exclude-attributes System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute
```

--------------------------------

### Start Coverage Analysis for External Applications (Visual Studio)

Source: https://www.jetbrains.com/help/dotcover/Starting_Manual_Test_Session_for_External_Applications

This snippet describes how to initiate coverage analysis for an external application using the dotCover plugin within Visual Studio. It outlines the menu path to access the feature.

```APIDOC
Visual Studio Integration:
  Menu Path: ReSharper | Cover | Cover Application…
  Shortcut: Ctrl+Alt+0K, 0K
```

--------------------------------

### Installing dotCover Console Runner as .NET Global Tool

Source: https://www.jetbrains.com/help/dotcover/Whats_New

Shows the command to install the dotCover console runner as a .NET global tool, enabling its use for analyzing coverage in .NET Core projects and unit tests.

```bash
dotnet tool install --global JetBrains.dotCover.GlobalTools --version 2021.1.0
```

--------------------------------

### dotCover .NET Tool Command Execution

Source: https://www.jetbrains.com/help/dotcover/Whats_New

Demonstrates how to execute dotCover commands when installed as a .NET tool. It highlights the change from requiring the `dotnet` prefix to direct command execution.

```APIDOC
Previous execution:
`dotnet dotcover <command>`

New execution:
`dotcover <command>`
```

--------------------------------

### Start Coverage for Test-Driven Application

Source: https://www.jetbrains.com/help/dotcover/Remotely_Cover_a_Web_Application

Initiates code coverage for an application when it's executed by tests (e.g., NUnit). It specifies the test runner executable, the test assembly, output file, report type, and an instance ID.

```bash
dotcover cover --TargetExecutable="C:\Program Files\NUnit 2.6\bin\nunit-console.exe" ^
--TargetArguments=C:\MyWebApp\bin\Debug\AppTests.dll ^
--Output=coverageReport.xml ^
--ReportType=XML ^
--Instance=1
```

--------------------------------

### dotCover Console Runner Per-Test Coverage Example

Source: https://www.jetbrains.com/help/dotcover/Whats_New

Demonstrates how to use the dotCover console runner to collect and report per-test coverage information for .NET projects. It specifies the output file, report type, and the test command to execute.

```bash
dotCover.exe dotnet --output=AppCoverageReport.xml --reportType=XML --IncludePerTestInfo=Method -- test "C:\MyProject\MainTests.csproj"
```

--------------------------------

### Start Coverage for IIS Express Application

Source: https://www.jetbrains.com/help/dotcover/Remotely_Cover_a_Web_Application

Initiates code coverage for an application hosted in IIS Express using the dotCover command-line tool. It specifies the target executable, arguments for IIS Express, output file, report type, and an instance ID for managing the dotCover process.

```bash
dotCover cover --TargetExecutable="C:\Program Files (x86)\IIS Express\iisexpress.exe" ^
--TargetArguments=/site:MyWebApp /systray:false ^
--Output=coverageReport.xml ^
--ReportType=XML ^
--Instance=1
```

--------------------------------

### Cover Startup Project

Source: https://www.jetbrains.com/help/dotcover/Getting_Started_with_dotCover

Launches the solution's startup project under dotCover control to calculate code coverage for a specific use-case scenario. This allows for detailed analysis of application behavior.

```C#
Ctrl+Alt+0K, 0P or ReSharper | Cover | Cover Startup Project
```

--------------------------------

### dotCover Command Line Tool Usage

Source: https://www.jetbrains.com/help/dotcover/dotCover__Coverage_Analysis_on_Third-Party_Server

Demonstrates how to use the dotCover command-line tool for coverage analysis on a CI server. This includes downloading the tool, configuring build scripts, and running the 'cover' command with a configuration file.

```bash
dotCover cover config.xml
```

--------------------------------

### dotCover Introduction and Navigation

Source: https://www.jetbrains.com/help/dotcover/dotCover_Coverage_Configuration

Overview of dotCover and navigation within its documentation, including links to related topics.

```APIDOC
dotCover Introduction:
  URL: https://www.jetbrains.com/help/dotcover/dotCover_Introduction.html
  Description: General introduction to dotCover, its capabilities, and links to key documentation sections like How To, Unit Testing, and Coverage Analysis.
```

--------------------------------

### Custom NUnit Installation Configuration

Source: https://www.jetbrains.com/help/dotcover/Reference__Options__Tools__Unit_Testing__NUnit

Allows specifying a custom NUnit installation path. dotCover bundles test runners for specific NUnit versions, but this option enables support for other versions via NuGet packages or a specified local installation.

```APIDOC
Custom NUnit Installation:
  Use specified custom NUnit: Checkbox to enable specifying a custom NUnit path.
  Path field: Enter the path to the local NUnit installation.
```

--------------------------------

### dotCover Command-Line Tool Usage

Source: https://www.jetbrains.com/help/dotcover/Remotely_Cover_a_Web_Application

Demonstrates how to use the dotCover command-line tool for web application coverage analysis, including instance management for snapshot generation and process control.

```APIDOC
dotCover Command-Line Tool:

Usage:
  dotCover.exe <command> [options]

Commands:
  analyze      Analyzes coverage data.
  get          Gets coverage snapshots.
  merge        Merges coverage data.
  delete       Deletes coverage data.
  help         Displays help information.

Options:
  /Instance=<ID>       Specifies the ID of a running dotCover instance to send commands to.
  /Snapshot=<Path>     Specifies the path to a coverage snapshot file.
  /Process=<PID>       Specifies the process ID to attach to.
  /Output=<Path>       Specifies the output path for results.
  /Filters=<Filters>   Specifies coverage filters.
  /NoLogo              Suppresses the display of the command-line tool logo.

Scenarios:
1. Get coverage of a web application (IIS Express or IIS):
   - Start dotCover with a unique instance ID: dotCover.exe get /Instance=MyWebApp
   - Run your web application.
   - When the application finishes, send a 'get snapshot' command:
     dotCover.exe get /Instance=MyWebApp /Snapshot=WebApp.dc覆盖

2. Get coverage of tests when the application is started from tests:
   - Configure your tests to use dotCover.
   - Run your tests.
   - dotCover will automatically collect coverage data.
```

--------------------------------

### NUnit Ignore Attribute Example

Source: https://www.jetbrains.com/help/dotcover/Analyze_test_results

An example demonstrating how to use the `Ignore` attribute from the NUnit framework to mark a unit test to be skipped during execution.

```csharp
[NUnit.Framework.Ignore("Test is temporarily ignored")]
public void IgnoredTest()
{
    // Test logic here
}
```

--------------------------------

### dotCover Response File Configuration

Source: https://www.jetbrains.com/help/dotcover/Coverage-Analysis-with-Command-Line-Tool

Defines the execution parameters for a specific test project when using different test frameworks. Includes target executable, arguments, working directory, and snapshot output.

```bash
--target-executable "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\Common7\IDE\MSTest.exe"
--target-arguments "TestProject1.dll"
--target-working-directory "D:\Projects\MyApp\bin\Debug"
--snapshot-output Snapshot1.dcvr
```

```bash
--target-executable "C:\Tools\NUnit\nunit3-console.exe"
--target-arguments "TestProject2.dll"
--target-working-directory "D:\Projects\MyApp\bin\Debug"
--snapshot-output Snapshot2.dcvr
```

--------------------------------

### Run dotCover for Different Test Frameworks

Source: https://www.jetbrains.com/help/dotcover/Coverage-Analysis-with-Command-Line-Tool

Executes dotCover coverage analysis for individual test projects using their respective response files. Generates separate snapshot files for each project.

```bash
dotCover cover @args1.txt
```

```bash
dotCover cover @args2.txt
```

--------------------------------

### Build Solution with dotnet CLI

Source: https://www.jetbrains.com/help/dotcover/Coverage-Analysis-with-Command-Line-Tool

Builds the entire solution using the .NET CLI. This is a prerequisite for running tests and collecting coverage.

```bash
dotnet build
```

--------------------------------

### dotCover Extension Management Overview

Source: https://www.jetbrains.com/help/dotcover/Managing_Extensions

This section provides an overview of how JetBrains dotCover manages extensions. Extensions add new features such as context actions, code analyzers, and support for various programming languages. The dotCover manager automates the installation, updating, and uninstallation of these extensions, allowing users to browse and install them easily.

```APIDOC
dotCover Extension Manager:
  Purpose: Manages the installation, updating, and uninstallation of extensions.
  Functionality:
    - Browse available extensions.
    - Install extensions with a few clicks.
    - Update existing extensions.
    - Uninstall extensions.
  Benefits:
    - Adds extra functionality (context actions, code analyzers, language support).
    - Simplifies extension lifecycle management.
```

--------------------------------

### dotCover Troubleshooting

Source: https://www.jetbrains.com/help/dotcover/Reference__Options__dotCover__Continuous_Testing

Troubleshooting guide for common issues encountered with dotCover.

```APIDOC
Troubleshooting:
  - Description: Information and solutions for common dotCover issues.
```

--------------------------------

### dotCover Troubleshooting

Source: https://www.jetbrains.com/help/dotcover/dotCover_Controller

Common issues encountered while using dotCover and their solutions, including setup, analysis, and reporting problems.

```APIDOC
Introduction__Troubleshooting.html:
  - Addresses common problems related to dotCover installation and configuration.
  - Provides solutions for coverage analysis failures and performance issues.
  - Offers guidance on diagnosing and resolving reporting errors.
```

--------------------------------

### Getting Help for dotCover Commands

Source: https://www.jetbrains.com/help/dotcover/dotCover__Console_Runner_Commands

Demonstrates how to retrieve help information for specific dotCover commands directly from the console.

```bash
dotCover help cover
```

--------------------------------

### Handling xUnit Tests in TeamCity with dotCover

Source: https://www.jetbrains.com/help/dotcover/dotCover__Setting_up_Coverage_Analysis_JetBrains_TeamCity

Provides guidance on setting up code coverage for xUnit tests in TeamCity, addressing the out-of-the-box limitations. It details the necessary steps for restoring xUnit packages and manually running the xUnit test runner, which generates TeamCity service messages for results.

```APIDOC
Setup for xUnit Tests:

1. Restore xUnit Packages:
   - Ensure xUnit packages are restored as a separate build step before compilation.
   - This is typically done by committing NuGet package references to the solution.

2. Run xUnit Test Runner Manually:
   - The xUnit runner is available as a NuGet package.
   - Reference the runner package in your solution and restore it during the build.
   - The runner automatically provides results in TeamCity service message format.
```

--------------------------------

### dotCover Troubleshooting

Source: https://www.jetbrains.com/help/dotcover/dotCover__Detecting_Hot_Spots

Common issues and solutions encountered while using dotCover, including problems with installation, coverage collection, analysis, and reporting.

```APIDOC
Troubleshooting dotCover:

Common Issues:

1. Coverage not collected:
   - Ensure dotCover is correctly installed and licensed.
   - Verify that the application being profiled is started correctly by dotCover (e.g., using the `cover` command).
   - Check for conflicts with other profiling or monitoring tools.
   - Ensure the target application's bitness (x86/x64) matches the dotCover installation.

2. Inaccurate coverage results:
   - Make sure coverage snapshots are merged correctly if multiple runs were involved.
   - Verify that the snapshot is matched with the correct project version (rebuild if necessary).
   - Check filters applied during coverage collection or analysis to ensure they are not excluding relevant code.

3. Reporting errors:
   - Ensure the output directory for reports exists and is writable.
   - Check for sufficient disk space.
   - Verify the specified report format is supported.

4. Performance issues:
   - Profiling can introduce overhead. Try excluding non-essential code paths from coverage collection using filters.
   - Ensure your system meets the recommended hardware specifications.

5. Integration problems (e.g., with IDEs, CI/CD):
   - Consult the specific integration documentation for dotCover and the tool you are using.
   - Ensure correct versions and configurations are used.

General Tips:
  - Always check the dotCover log files for detailed error messages.
  - Refer to the official JetBrains dotCover documentation for the most up-to-date troubleshooting steps.
```

--------------------------------

### dotCover General Settings Explanation

Source: https://www.jetbrains.com/help/dotcover/Reference__Options__dotCover__General

Explains various general settings for dotCover's code coverage analysis, including their impact on performance and behavior. Covers NGen images, test runner preloading, parallel execution, snapshot handling, and tool window behavior.

```text
Use NGen native images: Allows the .NET Framework runtime to load application's native images during coverage analysis for potential speed improvements. Disabling is recommended if NGen images cause application exceptions or inconclusive tests.

Preload test runners: Speeds up unit test coverage analysis startup by preloading test runners into memory. Generally should not be disabled unless advised by dotCover support.

Run test classes in parallel: Enables parallel execution of test classes within an assembly to accelerate coverage analysis. The maximum number of parallel processes is configurable in dotCover options.

Close unsaved snapshots without confirmation: Controls whether a dialog appears to save unsaved coverage snapshots when closing Visual Studio or related windows. Clearing this checkbox prompts for saving.

Open Unit Test Coverage tool window automatically: Configures the automatic opening behavior of the Unit Test Coverage window.
```

--------------------------------

### JetBrains dotCover Extension Management

Source: https://www.jetbrains.com/help/dotcover/Managing_Extensions

This section details the process of managing extensions within JetBrains dotCover, including installation from the Extension Manager and adding new package sources.

```APIDOC
APIDOC:
  Install Extension:
    - Navigate to ReSharper | Extension Manager.
    - Browse available extensions.
    - Click 'Install' next to the desired extension.
    - Accept the privacy note and click 'Install'.

  Add Package Source:
    - Navigate to ReSharper | Options.
    - Select Environment | Extension Manager.
    - Click 'Add'.
    - Provide a display name and a path to the package source (local or remote).
    - Click 'OK' to add the source.
    - Click 'Save' in the Options dialog.

  Install from Local .nupkg:
    - Navigate to ReSharper | Options.
    - Select Environment | Extension Manager.
    - Click 'Add'.
    - Provide a display name and the directory containing the .nupkg file.
    - Click 'OK'.
    - Optionally, disable the default package source.
    - Navigate to ReSharper | Extension Manager.
    - Find the extension and click 'Install'.
```

--------------------------------

### JetBrains dotCover Test Execution Control

Source: https://www.jetbrains.com/help/dotcover/Executing_Analyzing_Tests

Describes actions for controlling test execution, including starting, stopping, and repeating previous runs within a unit test session.

```APIDOC
Start Test Execution:
  - Via Unit Test Sessions window: Select tests and click Run Unit Tests or Debug Unit Tests.
  - Run all tests in session: Click Run Current Session.
  - Cover tests in session: Right-click node and choose Cover Unit Tests.
  - Run until fail: Expand Run Unit Tests selector and choose Run Unit Tests Until Fail.

Stop Test Execution:
  - Click Stop Execution. The runner may finish the current test before stopping.

Repeat Previous Run:
  - Click Repeat Previous Run or choose ReSharper | Unit Tests | Repeat Previous Run.
```

--------------------------------

### dotCover Configuration Options

Source: https://www.jetbrains.com/help/dotcover/Reference__Options__Tools__Unit_Testing__VSTest

Overview of dotCover's configuration settings, including general options, tool integrations, and UI elements.

```APIDOC
Reference__Options:
  Description: Main entry point for dotCover configuration settings.
  Sections:
    - Tools: Configuration for integrated tools like unit testing frameworks.
    - dotCover: Specific settings for the dotCover application.
    - Dialog Boxes: Settings related to various dialog boxes.
    - Windows: Configuration for different windows and panels.
  Related:
    - Reference__Options__Tools
    - Reference__Options__dotCover
    - Reference__Dialog_Boxes
    - Reference__Windows
```

--------------------------------

### dotCover Test Framework Support Configuration

Source: https://www.jetbrains.com/help/dotcover/Unit_Testing__Index

dotCover's support for various unit testing frameworks can be enabled or disabled through its options. This allows users to tailor dotCover to their specific testing setup.

```APIDOC
Tools | Unit Testing | Test Frameworks | VSTest (Alt+R, O)

- NUnit
- MSTest
- xUnit
- Custom test frameworks (VSTest, Microsoft.Testing.Platform)
- bUnit
- Machine.Specifications (requires extension)
```

--------------------------------

### dotCover Execution Methods

Source: https://www.jetbrains.com/help/dotcover/dotCover_Introduction

This section outlines various ways to execute dotCover for code coverage analysis, catering to different development and deployment needs.

```APIDOC
dotCover Execution:

1. IDE Integration:
   - Visual Studio
   - JetBrains Rider
   - Continuous Testing (for TDD and instant feedback)

2. Standalone Application:
   - For local application coverage analysis.

3. Command Line Tool:
   - For running coverage analysis on remote servers.

4. CI/CD Integration:
   - JetBrains TeamCity
   - Other CI servers
```

--------------------------------

### dotCover Configuration Options

Source: https://www.jetbrains.com/help/dotcover/dotCover__Color_Scheme

This section details various configuration options for dotCover, including general settings, continuous testing, editor preferences, and filtering. It guides users on how to manage and share dotCover settings effectively.

```APIDOC
dotCover Options:
  General:
    - Description: General configuration settings for dotCover.
  Continuous Testing:
    - Description: Settings related to continuous testing features.
  Editor:
    - Description: Editor-specific settings, potentially including color schemes.
  Filtering:
    - Description: Options for configuring code coverage filtering.
```

--------------------------------

### dotCover Profiler Core GUID and Paths

Source: https://www.jetbrains.com/help/dotcover/Profiling_Guidelines__Transparent_Integration

Variables required to load the JetBrains profiler core into a profiled process. These values are retrieved from specific file paths, environment variables, or the Windows registry.

```APIDOC
Variable | Description
--|--
JETBRAINS_PROFILER_CORE_GUID | (Required) The profiler core GUID.
JETBRAINS_PROFILER_CORE_PATH32 | (Required on Windows ARM64/x64/x86) An absolute path to the x86 profiler core shared library.
JETBRAINS_PROFILER_CORE_PATH64 | (Required on Linux x64, macOS ARM64/x64, Windows ARM64/x64) An absolute path to the x64 profiler core shared library.
JETBRAINS_PROFILER_CORE_PATH_ARM32 | (Required on Linux ARM) An absolute path to the ARM profiler core shared library.
JETBRAINS_PROFILER_CORE_PATH_ARM64 | (Required on Linux ARM64, macOS ARM64, Windows ARM64) An absolute path to the ARM64 profiler core shared library.
```

--------------------------------

### dotCover Options Reference

Source: https://www.jetbrains.com/help/dotcover/Reference__Options__Tools__Unit_Testing__General

Provides reference for dotCover's configuration options, including settings for tools, unit testing, and general preferences.

```APIDOC
dotCover Options:
  General:
    - Description: Configure general settings for dotCover.
    - Related: Tools, Unit Testing

  Tools:
    - Description: Configure settings related to integrated tools.
    - Related: General, Unit Testing

  Unit Testing:
    - Description: Configure settings for unit testing integration.
    - Sub-options:
      - General: Settings for general unit testing behavior.
      - Test Runner: Settings specific to the test runner.
    - Related: General, Tools
```

--------------------------------

### dotCover Settings Migration Example

Source: https://www.jetbrains.com/help/dotcover/Sharing_Configuration_Options

This XML snippet demonstrates how dotCover marks a settings migration entry. It indicates that a specific migration (identified by migration_ID) has been applied, setting a boolean value to True.

```xml
<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/[migration_ID]/@EntryIndexedValue">True</s:Boolean>
```

--------------------------------

### Running xUnit tests in TeamCity

Source: https://www.jetbrains.com/help/dotcover/dotCover__Setting_up_Coverage_Analysis_JetBrains_TeamCity

This snippet shows how to configure a TeamCity build step to execute xUnit tests using the xunit.console.exe runner. It specifies the path to the runner and the command-line parameters for the test assembly.

```TeamCity
Runner type: .NET
Command: <custom>
Path to runner: %system.teamcity.build.workingDir%\SimpleTestsProject\packages\xunit.runner.console.2.3.1\tools\net452\xunit.console.exe
Command line parameters: path/to/your/test/assembly.dll
```

--------------------------------

### dotCover General Options Reference

Source: https://www.jetbrains.com/help/dotcover/Reference__Options__dotCover__General

Provides reference information for the general options within dotCover, including settings related to website interaction and product configuration.

```APIDOC
dotCover Options - General:
  Purpose: Configure general settings for dotCover.
  Sections:
    - Cookie Settings: Manages website cookies and IP address recording for accessibility, security, and network access.
    - License Information: Specifies how to provide license details for dotCover.
    - Continuous Testing: Settings related to continuous testing features.
    - Filtering: Options for code coverage filtering.
    - Visual Studio Integration: Settings for dotCover's integration within the Visual Studio environment.
  Related Links:
    - [dotCover Options](https://www.jetbrains.com/help/dotcover/Reference__Options.html)
    - [dotCover Continuous Testing Options](https://www.jetbrains.com/help/dotcover/Reference__Options__dotCover__Continuous_Testing.html)
    - [dotCover Filtering Options](https://www.jetbrains.com/help/dotcover/Reference_Options_dotCover_Filtering.html)
    - [dotCover Visual Studio Options Page](https://www.jetbrains.com/help/dotcover/Reference__VS_Options_Page.html)
```

--------------------------------

### dotCover IIS Coverage Run Configuration

Source: https://www.jetbrains.com/help/dotcover/Profiling_Guidelines__IIS

Configuration steps for starting a code coverage run on an IIS server using JetBrains dotCover. This includes specifying the application URL, browser, and environment variables.

```APIDOC
APIDOC:
  Run Configuration for IIS:
    - Add run configuration: Choose 'IIS' in the New Run Configuration wizard.
    - Open URL: Specify the URL of the profiled IIS application.
      - If not specified, dotCover profiles the first available application pool.
    - In browser (Optional): Specify the browser for dotCover to open the URL.
    - Set environment variables (Optional): Define required environment variables, each on a new line.
    - Save the configuration.

  Starting the Coverage Run:
    - Select the created run configuration.
    - Optionally, edit the Symbol Search Policy to define PDB search locations.
    - Click 'Start' under 'Run analysis'.
    - dotCover opens the Coverage Controller dialog and runs the application.
    - If 'Collect coverage data from start' is selected, the run starts immediately.
    - Otherwise, click 'Start' in the Coverage Controller dialog.

  Warning:
    - Starting a coverage run for another web application while IIS is running interrupts the previous run and begins a new one.
```

--------------------------------

### dotCover Execution Methods

Source: https://www.jetbrains.com/help/dotcover/index

This section outlines various ways to execute dotCover for code coverage analysis, catering to different development and deployment needs.

```APIDOC
dotCover Execution:

1. IDE Integration:
   - Visual Studio
   - JetBrains Rider
   - Continuous Testing (for TDD and instant feedback)

2. Standalone Application:
   - For local application coverage analysis.

3. Command Line Tool:
   - For running coverage analysis on remote servers.

4. CI/CD Integration:
   - JetBrains TeamCity
   - Other CI servers
```

--------------------------------

### dotCover Options Reference

Source: https://www.jetbrains.com/help/dotcover/dotCover_Coverage_Configuration

Reference for the various options available in dotCover.

```APIDOC
dotCover Options Reference:
  URL: https://www.jetbrains.com/help/dotcover/Reference__Options.html
  Description: A detailed reference of all available configuration options within dotCover, explaining their purpose and impact on coverage analysis.
```

--------------------------------

### dotCover Control Flow for Application Coverage

Source: https://www.jetbrains.com/help/dotcover/Running_Applications_under_dotCover_Control

Describes the sequence of actions to perform when running an application under dotCover control to record coverage. This includes starting the collection, interacting with the application, dropping incorrect data, and obtaining snapshots.

```dotCover
1. Run the target application under dotCover control.
2. Start collecting coverage data (automatically or manually).
3. Execute the desired scenarios in the application.
4. Optionally, drop incorrect coverage data and restart.
5. Get a snapshot when finished.
6. Kill all processes or close the controller when done.
```

--------------------------------

### dotCover Feedback and Integration

Source: https://www.jetbrains.com/help/dotcover/Reference__Options__dotCover__General

Information on how to share feedback with the dotCover team and integrate dotCover with third-party tools.

```APIDOC
Feedback and Integration:
  Share Feedback: Instructions on how to provide feedback to the dotCover development team.
    Reference: https://www.jetbrains.com/help/dotcover/Providing_Feedback.html
  Third-Party Tool Integration: Guidelines for integrating dotCover with other tools for profiling and analysis.
    Reference: https://www.jetbrains.com/help/dotcover/Profiling_Guidelines__Transparent_Integration.html
```

--------------------------------

### dotCover Integration with dotMemory Unit Framework

Source: https://www.jetbrains.com/help/dotcover/Reference__Windows__Unit_Test_Sessions

Describes the process of installing the dotMemory Unit Testing Framework NuGet package and referencing it within a unit test project. This functionality is available when dotMemory is integrated with Visual Studio.

```en
Reference dotMemory Unit Framework:
Installs the JetBrains.DotMemoryUnit NuGet package and adds a reference to the unit test project.
Requires JetBrains dotMemory integration with Visual Studio.
```

--------------------------------

### Run dotCover with Same Test Framework

Source: https://www.jetbrains.com/help/dotcover/Coverage-Analysis-with-Command-Line-Tool

Collects code coverage for all tests in a solution when they share the same test framework. It can save a coverage snapshot or generate an XML report.

```bash
dotCover cover --snapshot-output snapshot.dcvr -- test --no-build
```

```bash
dotCover cover --xml-report-output report.xml -- test --no-build
```

--------------------------------

### dotCover Save and Open Coverage Snapshot

Source: https://www.jetbrains.com/help/dotcover/Navigation_to_Covering_Tests

Demonstrates the process of saving and opening coverage snapshots using dotCover. This is crucial for preserving and analyzing coverage data across different sessions.

```bash
dotCover.exe /SaveCoverage:"path/to/snapshot.dc"
dotCover.exe /OpenCoverage:"path/to/snapshot.dc"
```