Skip to main content

TUnit by Tom Longhurst

NuGet / site data​

Nuget GitHub last commit GitHub Repo stars

Details​

Info​

info

Name: TUnit

Author: Tom Longhurst

NuGet: https://www.nuget.org/packages/TUnit/

You can find more details at https://github.com/thomhurst/TUnit

Source: https://github.com/thomhurst/TUnit

Author​

note

Tom Longhurst Alt text

Original Readme​

note

🚀 The Modern Testing Framework for .NET

TUnit is a modern testing framework for .NET that uses source-generated tests, parallel execution by default, and Native AOT support. Built on Microsoft.Testing.Platform, it's faster than traditional reflection-based frameworks and gives you more control over how your tests run.

thomhurst%2FTUnit | Trendshift

Codacy BadgeGitHub Repo stars GitHub Issues or Pull Requests GitHub Sponsors nuget NuGet Downloads GitHub Workflow Status (with event) GitHub last commit (branch) License

Why TUnit?​

FeatureTraditional FrameworksTUnit
Test Discovery❌ Runtime reflection✅ Compile-time generation
Execution Speed❌ Sequential by default✅ Parallel by default
Modern .NET⚠️ Limited AOT support✅ Native AOT & trimming
Test Dependencies❌ Not supported✅ [DependsOn] chains
Resource Management❌ Manual lifecycle✅ Automatic cleanup

Parallel by Default - Tests run concurrently with dependency management

Compile-Time Discovery - Test structure is known before runtime

Modern .NET Ready - Native AOT, trimming, and latest .NET features

Extensible - Customize data sources, attributes, and test behavior

Quick Start​

dotnet new install TUnit.Templates
dotnet new TUnit -n "MyTestProject"

Manual Installation​

dotnet add package TUnit --prerelease

📖 Complete Documentation & Guides

Key Features​

Performance

  • Source-generated tests (no reflection)
  • Parallel execution by default
  • Native AOT & trimming support
  • Optimized for speed

Test Control

  • Test dependencies with [DependsOn]
  • Parallel limits & custom scheduling
  • Built-in analyzers & compile-time checks
  • Custom attributes & extensible conditions

Data & Assertions

  • Multiple data sources ([Arguments], [Matrix], [ClassData])
  • Fluent async assertions
  • Retry logic & conditional execution
  • Test metadata & context

Developer Tools

  • Full dependency injection support
  • Lifecycle hooks
  • IDE integration (VS, Rider, VS Code)
  • Documentation & examples

Simple Test Example​

[Test]
public async Task User_Creation_Should_Set_Timestamp()
{
    // Arrange
    var userService = new UserService();

    // Act
    var user = await userService.CreateUserAsync("john.doe@example.com");

    // Assert - TUnit's fluent assertions
    await Assert.That(user.CreatedAt)
        .IsEqualTo(DateTime.Now)
        .Within(TimeSpan.FromMinutes(1));

    await Assert.That(user.Email)
        .IsEqualTo("john.doe@example.com");
}

Data-Driven Testing​

[Test]
[Arguments("user1@test.com", "ValidPassword123")]
[Arguments("user2@test.com", "AnotherPassword456")]
[Arguments("admin@test.com", "AdminPass789")]
public async Task User_Login_Should_Succeed(string email, string password)
{
    var result = await authService.LoginAsync(email, password);
    await Assert.That(result.IsSuccess).IsTrue();
}

// Matrix testing - tests all combinations
[Test]
[MatrixDataSource]
public async Task Database_Operations_Work(
    [Matrix("Create", "Update", "Delete")] string operation,
    [Matrix("User", "Product", "Order")] string entity)
{
    await Assert.That(await ExecuteOperation(operation, entity))
        .IsTrue();
}

Advanced Test Orchestration​

[Before(Class)]
public static async Task SetupDatabase(ClassHookContext context)
{
    await DatabaseHelper.InitializeAsync();
}

[Test, DisplayName("Register a new account")]
[MethodDataSource(nameof(GetTestUsers))]
public async Task Register_User(string username, string password)
{
    // Test implementation
}

[Test, DependsOn(nameof(Register_User))]
[Retry(3)] // Retry on failure
public async Task Login_With_Registered_User(string username, string password)
{
    // This test runs after Register_User completes
}

[Test]
[ParallelLimit<LoadTestParallelLimit>] // Custom parallel control
[Repeat(100)] // Run 100 times
public async Task Load_Test_Homepage()
{
    // Performance testing
}

// Custom attributes
[Test, WindowsOnly, RetryOnHttpError(5)]
public async Task Windows_Specific_Feature()
{
    // Platform-specific test with custom retry logic
}

public class LoadTestParallelLimit : IParallelLimit
{
    public int Limit => 10; // Limit to 10 concurrent executions
}

Custom Test Control​

// Custom conditional execution
public class WindowsOnlyAttribute : SkipAttribute
{
    public WindowsOnlyAttribute() : base("Windows only test") \{ }

    public override Task<bool> ShouldSkip(TestContext testContext)
        => Task.FromResult(!OperatingSystem.IsWindows());
}

// Custom retry logic
public class RetryOnHttpErrorAttribute : RetryAttribute
{
    public RetryOnHttpErrorAttribute(int times) : base(times) \{ }

    public override Task<bool> ShouldRetry(TestInformation testInformation,
        Exception exception, int currentRetryCount)
        => Task.FromResult(exception is HttpRequestException \{ StatusCode: HttpStatusCode.ServiceUnavailable });
}

Common Use Cases​

Unit Testing​

[Test]
[Arguments(1, 2, 3)]
[Arguments(5, 10, 15)]
public async Task Calculate_Sum(int a, int b, int expected)
{
    await Assert.That(Calculator.Add(a, b))
        .IsEqualTo(expected);
}

Integration Testing​

[Test, DependsOn(nameof(CreateUser))]
public async Task Login_After_Registration()
{
    // Runs after CreateUser completes
    var result = await authService.Login(user);
    await Assert.That(result.IsSuccess).IsTrue();
}

Load Testing​

[Test]
[ParallelLimit<LoadTestLimit>]
[Repeat(1000)]
public async Task API_Handles_Concurrent_Requests()
{
    await Assert.That(await httpClient.GetAsync("/api/health"))
        .HasStatusCode(HttpStatusCode.OK);
}

What Makes TUnit Different?​

Compile-Time Test Discovery​

Tests are discovered at build time, not runtime. This means faster discovery, better IDE integration, and more predictable resource management.

Parallel by Default​

Tests run in parallel by default. Use [DependsOn] to chain tests together, and [ParallelLimit] to control resource usage.

Extensible​

The DataSourceGenerator<T> pattern and custom attribute system let you extend TUnit without modifying the framework.

Community & Ecosystem​

Downloads Contributors Discussions

Resources​

IDE Support​

TUnit works with all major .NET IDEs:

Visual Studio (2022 17.13+)​

✅ Fully supported - No additional configuration needed for latest versions

⚙️ Earlier versions: Enable "Use testing platform server mode" in Tools > Manage Preview Features

JetBrains Rider​

✅ Fully supported

⚙️ Setup: Enable "Testing Platform support" in Settings > Build, Execution, Deployment > Unit Testing > Testing Platform

Visual Studio Code​

✅ Fully supported

⚙️ Setup: Install C# Dev Kit and enable "Use Testing Platform Protocol"

Command Line​

✅ Full CLI support - Works with dotnet test, dotnet run, and direct executable execution

Package Options​

PackageUse Case
TUnitStart here - Complete testing framework (includes Core + Engine + Assertions)
TUnit.CoreTest libraries and shared components (no execution engine)
TUnit.EngineTest execution engine and adapter (for test projects)
TUnit.AssertionsStandalone assertions (works with any test framework)
TUnit.PlaywrightPlaywright integration with automatic lifecycle management

Migration from Other Frameworks​

Coming from NUnit or xUnit? TUnit uses familiar syntax with some additions:

// TUnit test with dependency management and retries
[Test]
[Arguments("value1")]
[Arguments("value2")]
[Retry(3)]
[ParallelLimit<CustomLimit>]
public async Task Modern_TUnit_Test(string value) \{ }

📖 Need help migrating? Check our Migration Guides for xUnit, NUnit, and MSTest.

Getting Started​

# Create a new test project
dotnet new install TUnit.Templates && dotnet new TUnit -n "MyTestProject"

# Or add to existing project
dotnet add package TUnit --prerelease

Learn More: tunit.dev | Get Help: GitHub Discussions | Star on GitHub: github.com/thomhurst/TUnit

Performance Benchmark​

Scenario: Building the test project​


BenchmarkDotNet v0.15.6, Linux Ubuntu 24.04.3 LTS (Noble Numbat)
AMD EPYC 7763 2.45GHz, 1 CPU, 4 logical and 2 physical cores
.NET SDK 10.0.100-rc.2.25502.107
  [Host]     : .NET 10.0.0 (10.0.0-rc.2.25502.107, 10.0.25.50307), X64 RyuJIT x86-64-v3
  Job-GVKUBM : .NET 10.0.0 (10.0.0-rc.2.25502.107, 10.0.25.50307), X64 RyuJIT x86-64-v3

Runtime=.NET 10.0

MethodVersionMeanErrorStdDevMedian
Build_TUnit1.0.481.798 s0.0345 s0.0424 s1.785 s
Build_NUnit4.4.01.575 s0.0169 s0.0158 s1.573 s
Build_MSTest4.0.11.659 s0.0150 s0.0140 s1.658 s
Build_xUnit33.2.01.579 s0.0182 s0.0170 s1.575 s

Scenario: Tests running asynchronous operations and async/await patterns​


BenchmarkDotNet v0.15.6, Linux Ubuntu 24.04.3 LTS (Noble Numbat)
AMD EPYC 7763 2.45GHz, 1 CPU, 4 logical and 2 physical cores
.NET SDK 10.0.100-rc.2.25502.107
  [Host]     : .NET 10.0.0 (10.0.0-rc.2.25502.107, 10.0.25.50307), X64 RyuJIT x86-64-v3
  Job-GVKUBM : .NET 10.0.0 (10.0.0-rc.2.25502.107, 10.0.25.50307), X64 RyuJIT x86-64-v3

Runtime=.NET 10.0

MethodVersionMeanErrorStdDevMedian
TUnit1.0.48562.4 ms4.18 ms3.91 ms561.0 ms
NUnit4.4.0679.2 ms7.24 ms6.41 ms679.6 ms
MSTest4.0.1647.7 ms8.63 ms7.65 ms647.8 ms
xUnit33.2.0744.4 ms11.90 ms10.55 ms741.5 ms
TUnit_AOT1.0.48127.6 ms0.45 ms0.42 ms127.6 ms

Scenario: Parameterized tests with multiple test cases using data attributes​


BenchmarkDotNet v0.15.6, Linux Ubuntu 24.04.3 LTS (Noble Numbat)
AMD EPYC 7763 2.45GHz, 1 CPU, 4 logical and 2 physical cores
.NET SDK 10.0.100-rc.2.25502.107
  [Host]     : .NET 10.0.0 (10.0.0-rc.2.25502.107, 10.0.25.50307), X64 RyuJIT x86-64-v3
  Job-GVKUBM : .NET 10.0.0 (10.0.0-rc.2.25502.107, 10.0.25.50307), X64 RyuJIT x86-64-v3

Runtime=.NET 10.0

MethodVersionMeanErrorStdDevMedian
TUnit1.0.48476.97 ms5.430 ms5.080 ms478.26 ms
NUnit4.4.0537.80 ms6.692 ms6.260 ms537.55 ms
MSTest4.0.1496.84 ms9.188 ms8.145 ms496.37 ms
xUnit33.2.0584.15 ms10.733 ms10.039 ms582.13 ms
TUnit_AOT1.0.4824.65 ms0.177 ms0.157 ms24.68 ms

Scenario: Tests executing massively parallel workloads with CPU-bound, I/O-bound, and mixed operations​


BenchmarkDotNet v0.15.6, Linux Ubuntu 24.04.3 LTS (Noble Numbat)
AMD EPYC 7763 2.45GHz, 1 CPU, 4 logical and 2 physical cores
.NET SDK 10.0.100-rc.2.25502.107
  [Host]     : .NET 10.0.0 (10.0.0-rc.2.25502.107, 10.0.25.50307), X64 RyuJIT x86-64-v3
  Job-GVKUBM : .NET 10.0.0 (10.0.0-rc.2.25502.107, 10.0.25.50307), X64 RyuJIT x86-64-v3

Runtime=.NET 10.0

MethodVersionMeanErrorStdDevMedian
TUnit1.0.48578.1 ms5.79 ms5.13 ms577.3 ms
NUnit4.4.01,220.5 ms7.43 ms6.20 ms1,220.9 ms
MSTest4.0.13,005.3 ms13.91 ms12.33 ms3,003.4 ms
xUnit33.2.03,096.0 ms11.11 ms10.40 ms3,094.6 ms
TUnit_AOT1.0.48130.6 ms0.39 ms0.36 ms130.7 ms

Scenario: Tests with complex parameter combinations creating 25-125 test variations​


BenchmarkDotNet v0.15.6, Linux Ubuntu 24.04.3 LTS (Noble Numbat)
AMD EPYC 7763 2.45GHz, 1 CPU, 4 logical and 2 physical cores
.NET SDK 10.0.100-rc.2.25502.107
  [Host]     : .NET 10.0.0 (10.0.0-rc.2.25502.107, 10.0.25.50307), X64 RyuJIT x86-64-v3
  Job-GVKUBM : .NET 10.0.0 (10.0.0-rc.2.25502.107, 10.0.25.50307), X64 RyuJIT x86-64-v3

Runtime=.NET 10.0

MethodVersionMeanErrorStdDevMedian
TUnit1.0.48544.97 ms5.561 ms4.930 ms544.99 ms
NUnit4.4.01,540.60 ms5.644 ms4.713 ms1,540.91 ms
MSTest4.0.11,499.17 ms4.590 ms3.833 ms1,499.42 ms
xUnit33.2.01,591.72 ms6.560 ms6.136 ms1,592.55 ms
TUnit_AOT1.0.4879.41 ms0.252 ms0.236 ms79.48 ms

Scenario: Large-scale parameterized tests with 100+ test cases testing framework scalability​


BenchmarkDotNet v0.15.6, Linux Ubuntu 24.04.3 LTS (Noble Numbat)
AMD EPYC 7763 2.45GHz, 1 CPU, 4 logical and 2 physical cores
.NET SDK 10.0.100-rc.2.25502.107
  [Host]     : .NET 10.0.0 (10.0.0-rc.2.25502.107, 10.0.25.50307), X64 RyuJIT x86-64-v3
  Job-GVKUBM : .NET 10.0.0 (10.0.0-rc.2.25502.107, 10.0.25.50307), X64 RyuJIT x86-64-v3

Runtime=.NET 10.0

MethodVersionMeanErrorStdDevMedian
TUnit1.0.48498.22 ms7.188 ms6.723 ms496.45 ms
NUnit4.4.0584.65 ms11.669 ms11.461 ms582.38 ms
MSTest4.0.1580.53 ms11.233 ms15.747 ms583.58 ms
xUnit33.2.0587.89 ms8.750 ms7.757 ms586.15 ms
TUnit_AOT1.0.4846.75 ms1.442 ms4.253 ms47.33 ms

About​

note

Writing unit tests

How to use​

Example (source csproj, source files)​

This is the CSharp Project that references TUnit

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

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="TUnit" Version="1.2.11" />
  </ItemGroup>

	<PropertyGroup>
		<EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
		<CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)\GX</CompilerGeneratedFilesOutputPath>
	</PropertyGroup>
</Project>

Generated Files​

Those are taken from $(BaseIntermediateOutputPath)\GX

// <auto-generated/>
#pragma warning disable

[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "1.0.0.0")]
file static class AssemblyLoader0fc44d9acf154c74aee2a9e062a8edcd
{
    [global::System.Runtime.CompilerServices.ModuleInitializer]
    public static void Initialize()
    {
        global::TUnit.Core.SourceRegistrar.RegisterAssembly(() => global::System.Reflection.Assembly.Load("EnumerableAsyncProcessor, Version=3.8.4.0, Culture=neutral, PublicKeyToken=7a7adb9c614908c9"));
        global::TUnit.Core.SourceRegistrar.RegisterAssembly(() => global::System.Reflection.Assembly.Load("Microsoft.Extensions.DependencyModel, Version=6.0.0.2, Culture=neutral, PublicKeyToken=adb9793829ddae60"));
        global::TUnit.Core.SourceRegistrar.RegisterAssembly(() => global::System.Reflection.Assembly.Load("Mono.Cecil, Version=0.11.5.0, Culture=neutral, PublicKeyToken=50cebf1cceb9d05e"));
        global::TUnit.Core.SourceRegistrar.RegisterAssembly(() => global::System.Reflection.Assembly.Load("Mono.Cecil.Mdb, Version=0.11.5.0, Culture=neutral, PublicKeyToken=50cebf1cceb9d05e"));
        global::TUnit.Core.SourceRegistrar.RegisterAssembly(() => global::System.Reflection.Assembly.Load("Mono.Cecil.Pdb, Version=0.11.5.0, Culture=neutral, PublicKeyToken=50cebf1cceb9d05e"));
        global::TUnit.Core.SourceRegistrar.RegisterAssembly(() => global::System.Reflection.Assembly.Load("Mono.Cecil.Rocks, Version=0.11.5.0, Culture=neutral, PublicKeyToken=50cebf1cceb9d05e"));
        global::TUnit.Core.SourceRegistrar.RegisterAssembly(() => global::System.Reflection.Assembly.Load("TUnit.Assertions, Version=1.2.11.0, Culture=neutral, PublicKeyToken=b8d4030011dbd70c"));
        global::TUnit.Core.SourceRegistrar.RegisterAssembly(() => global::System.Reflection.Assembly.Load("TUnit.Core, Version=1.2.11.0, Culture=neutral, PublicKeyToken=b8d4030011dbd70c"));
        global::TUnit.Core.SourceRegistrar.RegisterAssembly(() => global::System.Reflection.Assembly.Load("TUnit, Version=1.2.11.0, Culture=neutral, PublicKeyToken=b8d4030011dbd70c"));
        global::TUnit.Core.SourceRegistrar.RegisterAssembly(() => global::System.Reflection.Assembly.Load("TUnit.Engine, Version=1.2.11.0, Culture=neutral, PublicKeyToken=b8d4030011dbd70c"));
    }
}

Useful​

Download Example (.NET C#)​

tip

Download Example project TUnit

Share TUnit​

https://ignatandrei.github.io/RSCG_Examples/v2/docs/TUnit

Category "Tests" has the following generators:​

1 mocklis Nuget GitHub Repo stars 2024-01-03

2 MockMe Nuget GitHub Repo stars 2025-02-10

3 MSTest Nuget GitHub Repo stars 2024-04-04

4 Ridge Nuget GitHub Repo stars 2023-08-20

5 Rocks Nuget GitHub Repo stars 2023-04-16

6 TUnit Nuget GitHub Repo stars 2025-11-08

See category​

Tests