🚀 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.

Why TUnit?

Feature	Traditional Frameworks	TUnit
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

---

Documentation

New to TUnit? Start with the Getting Started Guide

Migrating? See the Migration Guides

Learn more: Data-Driven Testing, Test Dependencies, Parallelism Control

---

Quick Start

Using the Project Template (Recommended)

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("[email protected]");

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

    await Assert.That(user.Email)
        .IsEqualTo("[email protected]");
}

Data-Driven Testing

[Test]
[Arguments("[email protected]", "ValidPassword123")]
[Arguments("[email protected]", "AnotherPassword456")]
[Arguments("[email protected]", "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

Resources

• Official Documentation - Guides, tutorials, and API reference
• GitHub Discussions - Get help and share ideas
• Issue Tracking - Report bugs and request features
• Release Notes - Latest updates and changes

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

Package	Use Case
TUnit	Start here - Complete testing framework (includes Core + Engine + Assertions)
TUnit.Core	Test libraries and shared components (no execution engine)
TUnit.Engine	Test execution engine and adapter (for test projects)
TUnit.Assertions	Standalone assertions (works with any test framework)
TUnit.Playwright	Playwright 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.

Current Status

The API is mostly stable, but may have some changes based on feedback before the v1.0 release.

---

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.5, 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  

Method	Version	Mean	Error	StdDev	Median
Build_TUnit	0.90.19	1.823 s	0.0363 s	0.0356 s	1.826 s
Build_NUnit	4.4.0	1.620 s	0.0226 s	0.0212 s	1.623 s
Build_MSTest	4.0.1	1.691 s	0.0274 s	0.0243 s	1.689 s
Build_xUnit3	3.2.0	1.613 s	0.0133 s	0.0118 s	1.611 s

Scenario: Tests running asynchronous operations and async/await patterns

BenchmarkDotNet v0.15.5, Linux Ubuntu 24.04.3 LTS (Noble Numbat)
AMD EPYC 7763 2.82GHz, 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  

Method	Version	Mean	Error	StdDev	Median
TUnit	0.90.19	541.5 ms	4.81 ms	4.50 ms	541.3 ms
NUnit	4.4.0	687.5 ms	8.61 ms	7.63 ms	684.7 ms
MSTest	4.0.1	657.5 ms	8.44 ms	7.90 ms	655.6 ms
xUnit3	3.2.0	735.6 ms	4.49 ms	4.20 ms	736.3 ms
TUnit_AOT	0.90.19	123.4 ms	0.55 ms	0.51 ms	123.2 ms

Scenario: Parameterized tests with multiple test cases using data attributes

BenchmarkDotNet v0.15.5, Linux Ubuntu 24.04.3 LTS (Noble Numbat)
AMD EPYC 7763 2.81GHz, 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  

Method	Version	Mean	Error	StdDev	Median
TUnit	0.90.19	486.47 ms	7.887 ms	6.992 ms	484.16 ms
NUnit	4.4.0	572.89 ms	11.279 ms	13.426 ms	569.22 ms
MSTest	4.0.1	576.75 ms	11.125 ms	16.651 ms	571.55 ms
xUnit3	3.2.0	618.44 ms	11.620 ms	11.933 ms	617.54 ms
TUnit_AOT	0.90.19	25.88 ms	0.252 ms	0.236 ms	25.82 ms

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

BenchmarkDotNet v0.15.5, 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  

Method	Version	Mean	Error	StdDev	Median
TUnit	0.90.19	567.4 ms	2.77 ms	2.46 ms	568.0 ms
NUnit	4.4.0	1,172.5 ms	7.68 ms	6.81 ms	1,171.5 ms
MSTest	4.0.1	2,949.4 ms	6.61 ms	5.52 ms	2,951.0 ms
xUnit3	3.2.0	3,046.0 ms	7.95 ms	6.64 ms	3,045.4 ms
TUnit_AOT	0.90.19	129.9 ms	0.60 ms	0.53 ms	130.0 ms

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

BenchmarkDotNet v0.15.5, Linux Ubuntu 24.04.3 LTS (Noble Numbat)
AMD EPYC 7763 2.70GHz, 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  

Method	Version	Mean	Error	StdDev	Median
TUnit	0.90.19	530.94 ms	7.755 ms	7.254 ms	529.04 ms
NUnit	4.4.0	1,571.92 ms	8.920 ms	7.449 ms	1,570.08 ms
MSTest	4.0.1	1,529.03 ms	8.866 ms	7.404 ms	1,528.54 ms
xUnit3	3.2.0	1,618.01 ms	9.086 ms	8.055 ms	1,616.65 ms
TUnit_AOT	0.90.19	77.32 ms	0.317 ms	0.296 ms	77.31 ms

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

BenchmarkDotNet v0.15.5, 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  

Method	Version	Mean	Error	StdDev	Median
TUnit	0.90.19	493.37 ms	4.274 ms	3.789 ms	493.21 ms
NUnit	4.4.0	602.77 ms	11.701 ms	10.945 ms	601.53 ms
MSTest	4.0.1	612.38 ms	12.025 ms	17.999 ms	610.58 ms
xUnit3	3.2.0	610.93 ms	12.156 ms	16.228 ms	605.63 ms
TUnit_AOT	0.90.19	39.49 ms	0.864 ms	2.521 ms	39.36 ms