Code Coverage | Unit Testing

Introduction

Code coverage is a measure used to describe the degree to which the source code of a program is executed when a particular test suite runs. In C#, code coverage helps to ensure that all parts of the code have been tested, which can highlight areas that might be prone to errors.

Why Code Coverage is Important

Code coverage is crucial for several reasons:

Identifies untested parts of a codebase.
Helps ensure that the most critical parts of the application are tested.
Improves code quality by revealing hidden bugs.
Gives a measure of how well your tests are performing.

Setting Up Code Coverage in C#

To set up code coverage in a C# project, you can use tools like Visual Studio, Coverlet, or dotCover. In this tutorial, we'll focus on using Coverlet, a popular open-source code coverage library for .NET Core.

Step 1: Install Coverlet

In your terminal, navigate to your project directory and run the following command:

dotnet add package coverlet.msbuild

Step 2: Add Coverlet to Your Unit Tests

Modify your *.csproj file to include Coverlet:

<ItemGroup>
  <PackageReference Include="coverlet.msbuild" Version="2.9.0" />
</ItemGroup>

Step 3: Run Tests with Code Coverage

Run the following command in your terminal:

dotnet test /p:CollectCoverage=true

This command will execute your tests and collect code coverage data.

Viewing Code Coverage Results

After running the tests, the coverage results are typically available in a coverage.json file in the TestResults directory. You can use tools like ReportGenerator to convert this JSON file into a human-readable report.

Step 1: Install ReportGenerator

dotnet tool install -g dotnet-reportgenerator-globaltool

Step 2: Generate the Report

reportgenerator -reports:coverage.cobertura.xml -targetdir:./coveragereport

This command generates the report in the ./coveragereport directory.

Example

Let's walk through a simple example to demonstrate code coverage in a C# project.

Step 1: Create a Simple C# Class

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public int Subtract(int a, int b)
    {
        return a - b;
    }
}

Step 2: Create Unit Tests

using Xunit;

public class CalculatorTests
{
    [Fact]
    public void Add_ShouldReturnSum()
    {
        var calculator = new Calculator();
        int result = calculator.Add(2, 3);
        Assert.Equal(5, result);
    }

    [Fact]
    public void Subtract_ShouldReturnDifference()
    {
        var calculator = new Calculator();
        int result = calculator.Subtract(5, 3);
        Assert.Equal(2, result);
    }
}

Step 3: Run Tests with Code Coverage

dotnet test /p:CollectCoverage=true

Calculating coverage result...
  Generating report '.../coverage.json'

+---------------------+--------+--------+
| Module              | Line   | Branch |
+---------------------+--------+--------+
| ExampleProject      | 100%   | 100%   |
+---------------------+--------+--------+

Total time: 1.3 seconds

Conclusion

Code coverage is an essential aspect of software testing that helps ensure your code is well-tested and reliable. By integrating tools like Coverlet and ReportGenerator with your C# projects, you can easily measure and analyze your code coverage, leading to higher quality software.