Testing

dotnet new xunit -o Sample.Tests
dotnet add Sample.Tests/Sample.Tests.csproj reference Sample/Sample.csproj
dotnet test

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
    <PackageReference Include="xunit" Version="2.9.2" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
    <PackageReference Include="coverlet.collector" Version="6.0.2" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="../Sample/Sample.csproj" />
  </ItemGroup>

</Project>

// NUnit
using System.Collections.Generic;
using NUnit.Framework;

[TestFixture]
public sealed class NUnitExample
{
    private List<string> _basket = null!;

    [SetUp]
    public void SetUp() => _basket = [];

    [Test]
    public void Add_IncreasesCount()
    {
        _basket.Add("apple");
        Assert.That(_basket.Count, Is.EqualTo(1));
    }

    [TestCase(2, 4)]
    [TestCase(3, 9)]
    public void Square_ReturnsProduct(int input, int expected) =>
        Assert.That(input * input, Is.EqualTo(expected));
}

// MSTest
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.UnitTesting;

[TestClass]
public sealed class MsTestExample
{
    private List<string> _basket = null!;

    [TestInitialize]
    public void Initialize() => _basket = [];

    [TestMethod]
    public void Add_IncreasesCount()
    {
        _basket.Add("apple");
        Assert.AreEqual(1, _basket.Count);
    }

    [DataTestMethod]
    [DataRow(2, 4)]
    [DataRow(3, 9)]
    public void Square_ReturnsProduct(int input, int expected) =>
        Assert.AreEqual(expected, input * input);
}

using Xunit;

public sealed class AssertionExamples
{
    [Fact]
    public void Examples()
    {
        // Equality -- uses IEquatable/Equals, and structural equality for collections.
        Assert.Equal(4, 2 + 2);
        Assert.Equal(0.1 + 0.2, 0.3, precision: 10);         // floating point: always with a tolerance
        Assert.NotEqual("a", "b");
        Assert.Same(string.Empty, string.Empty);             // reference identity

        // Booleans and null.
        Assert.True(1 < 2);
        Assert.False(string.IsNullOrEmpty("x"));
        Assert.Null(null);
        Assert.NotNull("x");

        // Collections.
        int[] values = [1, 2, 3];
        Assert.Contains(2, values);
        Assert.DoesNotContain(9, values);
        Assert.Empty(Array.Empty<int>());
        Assert.Single(new[] { 1 });
        Assert.Equal([1, 2, 3], values);
        Assert.All(values, static v => Assert.True(v > 0));
        Assert.Collection(
            values,
            static first => Assert.Equal(1, first),
            static second => Assert.Equal(2, second),
            static third => Assert.Equal(3, third));

        // Strings.
        Assert.StartsWith("He", "Hello");
        Assert.Matches("^H.*o$", "Hello");

        // Ranges and types.
        Assert.InRange(5, 1, 10);
        object value = "text";
        string text = Assert.IsType<string>(value);
        Assert.NotEmpty(text);
    }

    [Fact]
    public async Task Exceptions()
    {
        // Synchronous. Pass a method group (or an Action): a throw-only lambda is
        // convertible to Func<Task> too, and xUnit makes that overload an error.
        InvalidOperationException sync = Assert.Throws<InvalidOperationException>(Boom);
        Assert.Equal("boom", sync.Message);

        // Asynchronous -- note ThrowsAsync, and that it must be awaited.
        await Assert.ThrowsAsync<InvalidOperationException>(BoomAsync);

        // Any derived type.
        Assert.ThrowsAny<ArgumentException>(BoomArgument);
    }

    private static void Boom() => throw new InvalidOperationException("boom");

    private static async Task BoomAsync()
    {
        await Task.Yield();
        throw new InvalidOperationException("async boom");
    }

    private static void BoomArgument() => throw new ArgumentNullException("p");
}

public sealed record Customer(string Name, string Email, int LoyaltyPoints, bool IsActive);

public sealed class CustomerBuilder
{
    private string _name = "Test Customer";
    private string _email = "test@example.com";
    private int _points;
    private bool _active = true;

    public CustomerBuilder WithName(string name)
    {
        _name = name;
        return this;
    }

    public CustomerBuilder WithPoints(int points)
    {
        _points = points;
        return this;
    }

    public CustomerBuilder Inactive()
    {
        _active = false;
        return this;
    }

    public Customer Build() => new(_name, _email, _points, _active);
}

using Xunit;

public sealed class LoyaltyTests
{
    [Fact]
    public void Inactive_CustomerEarnsNothing()
    {
        // Only the two things this test cares about are stated.
        Customer customer = new CustomerBuilder().WithPoints(500).Inactive().Build();

        Assert.False(customer.IsActive);
        Assert.Equal(500, customer.LoyaltyPoints);
    }
}

using Xunit;

public sealed class AsyncTests
{
    [Fact]
    public async Task LoadAsync_ReturnsValue()
    {
        var service = new Loader();

        string value = await service.LoadAsync("key", CancellationToken.None);

        Assert.Equal("KEY", value);
    }

    [Fact]
    public async Task LoadAsync_WhenCancelled_Throws()
    {
        var service = new Loader();
        using var cts = new CancellationTokenSource();
        await cts.CancelAsync();

        // The framework-standard exception for cancellation.
        await Assert.ThrowsAsync<TaskCanceledException>(() => service.LoadAsync("key", cts.Token));
    }

    [Fact]
    public async Task LoadAsync_RespectsATimeout()
    {
        var service = new Loader();

        // Never let a hanging test hang the suite: bound it.
        string value = await service.LoadAsync("key", CancellationToken.None)
                                    .WaitAsync(TimeSpan.FromSeconds(5));

        Assert.NotEmpty(value);
    }
}

public sealed class Loader
{
    public async Task<string> LoadAsync(string key, CancellationToken cancellationToken)
    {
        await Task.Delay(1, cancellationToken);
        return key.ToUpperInvariant();
    }
}

dotnet test --collect:"XPlat Code Coverage"
# writes TestResults/<guid>/coverage.cobertura.xml

dotnet tool install -g dotnet-reportgenerator-globaltool
reportgenerator -reports:"**/coverage.cobertura.xml" -targetdir:coveragereport -reporttypes:Html

dotnet test --collect:"XPlat Code Coverage" \
  -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=cobertura

<PropertyGroup>
  <CollectCoverage>true</CollectCoverage>
  <CoverletOutputFormat>cobertura</CoverletOutputFormat>
  <Threshold>80</Threshold>
  <ThresholdType>line,branch</ThresholdType>
</PropertyGroup>