# Where Are the Tests for ASP.NET Core Located? A Complete Directory Guide

> Discover the exact location of ASP.NET Core tests within the dotnet/aspnetcore repository. Find xUnit test projects organized by component in their respective test subfolders.

- Repository: [.NET Platform/aspnetcore](https://github.com/dotnet/aspnetcore)
- Tags: how-to-guide
- Published: 2026-08-01

---

**The ASP.NET Core tests are co-located with source code under the `src` directory, where each framework component maintains its own `test` subfolder containing xUnit-based `.csproj` projects.**

All tests for the `dotnet/aspnetcore` repository live alongside the implementation code rather than in a separate top-level directory. This colocated structure enables isolated component testing while supporting full solution-wide test runs via standard .NET CLI commands.

## Test Directory Structure and Naming Conventions

The repository follows a consistent pattern where **test projects reside in `test` subfolders** within their respective component directories. The typical layout mirrors the source structure:

```

src/
├─ <Component>/
│   ├─ <Sub-module>/
│   │   ├─ test/
│   │   │   ├─ <Test Project>.csproj
│   │   │   └─ *.cs (test classes)
│   │   └─ src/ (implementation)
│   └─ ...
└─ ...

```

All test projects use standard **xUnit** frameworks and are discoverable by `dotnet test`. The build pipeline automatically compiles and executes these assemblies during CI runs.

## Component-Level ASP.NET Core Test Locations

Each major framework area maintains dedicated test projects following the `src/<Component>/test/` convention. Here are the specific locations for key components:

### Hosting Tests

Functional tests for the hosting layer reside in `src/Hosting/test/FunctionalTests/`. The project file `Microsoft.AspNetCore.Hosting.FunctionalTests.csproj` contains integration tests that validate web host initialization, configuration, and lifecycle management.

### SignalR Tests

Real-time communication tests are split across multiple locations:
- **Core SignalR tests**: `src/SignalR/server/SignalR/test/Microsoft.AspNetCore.SignalR.Tests.csproj`
- **StackExchangeRedis backplane tests**: `src/SignalR/server/StackExchangeRedis/test/Microsoft.AspNetCore.SignalR.StackExchangeRedis.Tests.csproj`

These projects contain both unit tests for hub routing and integration tests for scale-out providers.

### Routing Tests

The routing middleware maintains separate test assemblies for different testing levels:
- **Unit tests**: `src/Http/Routing/test/UnitTests/Microsoft.AspNetCore.Routing.Tests.csproj`
- **Functional tests**: `src/Http/Routing/test/FunctionalTests/Microsoft.AspNetCore.Routing.FunctionalTests.csproj`

This separation allows developers to run fast unit tests independently from slower integration scenarios.

### HTTP Abstractions and Middleware Tests

Core HTTP functionality tests live in `src/Http/Http/test/Microsoft.AspNetCore.Http.Tests.csproj`, validating `HttpContext`, `HttpRequest`, and `HttpResponse` implementations.

### Additional Component Test Locations

- **WebEncoders**: `src/WebEncoders/test/Microsoft.Extensions.WebEncoders.Tests.csproj`
- **Logging.AzureAppServices**: `src/Logging.AzureAppServices/test/Microsoft.Extensions.Logging.AzureAppServices.Tests.csproj`
- **DataProtection**: `src/DataProtection/DataProtection/test/Microsoft.AspNetCore.DataProtection.Tests/Microsoft.AspNetCore.DataProtection.Tests.csproj`
- **Components (Blazor WebAssembly)**: `src/Components/WebAssembly/WebAssembly/test/Microsoft.AspNetCore.Components.WebAssembly.Tests.csproj`

## Infrastructure and Shared Testing Framework

Beyond component-specific tests, the repository includes base testing utilities in `src/Testing/test/`. The project `Microsoft.AspNetCore.InternalTesting.Tests.csproj` provides custom xUnit attributes, test base classes, and helper utilities used across the entire test suite.

This infrastructure project contains the foundational `TestableAssembly` classes and shared assertions that component tests inherit.

## Practical Example: Routing Unit Test

Tests follow standard xUnit patterns with `[Fact]` attributes. Here is a representative example from the Routing component:

```csharp
using Microsoft.AspNetCore.Routing;
using Xunit;

public class SimpleRouteTests
{
    [Fact]
    public void RouteMatcher_IgnoresTrailingSlash()
    {
        var route = new RoutePatternParser().Parse("/home/");
        var matcher = new DefaultRouter();
        var result = matcher.Match("/home", route);
        Assert.True(result.IsMatch);
    }
}

```

This test file would reside at [`src/Http/Routing/test/UnitTests/SimpleRouteTests.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Http/Routing/test/UnitTests/SimpleRouteTests.cs) according to the repository structure.

## How to Run ASP.NET Core Tests Locally

Execute the entire test suite from the repository root:

```bash
dotnet test src/

```

Run tests for a specific component only:

```bash
dotnet test src/Hosting/test/FunctionalTests/

```

Filter by fully qualified test name:

```bash
dotnet test --filter "FullyQualifiedName~Microsoft.AspNetCore.Routing.Tests"

```

## Summary

- **ASP.NET Core tests** are located in `test` subfolders within each component directory under `src/`
- **Hosting tests** reside in `src/Hosting/test/FunctionalTests/`
- **SignalR tests** are found in `src/SignalR/server/SignalR/test/` and related subdirectories
- **Routing tests** split between `src/Http/Routing/test/UnitTests/` and `FunctionalTests/`
- **Infrastructure tests** for shared utilities live in `src/Testing/test/`
- All projects use **xUnit** and support standard `dotnet test` commands

## Frequently Asked Questions

### What testing framework does ASP.NET Core use?

ASP.NET Core uses **xUnit.net** as its primary testing framework. All test projects reference xUnit packages and use standard `[Fact]` and `[Theory]` attributes for test methods, as implemented in the `dotnet/aspnetcore` repository.

### How do I run only specific component tests?

Navigate to the specific test project directory or provide the path to `dotnet test`. For example, run `dotnet test src/SignalR/server/SignalR/test/` to execute only SignalR tests, or use the `--filter` option with namespace patterns to target specific areas without changing directories.

### Are there integration tests or only unit tests?

The repository contains **both unit and integration tests**. Components like Routing and Hosting maintain separate `UnitTests` and `FunctionalTests` directories. Functional tests validate end-to-end scenarios with actual HTTP requests, while unit tests isolate individual classes and methods.

### Where are the Blazor and WebAssembly tests located?

Blazor WebAssembly-specific tests are located in `src/Components/WebAssembly/WebAssembly/test/Microsoft.AspNetCore.Components.WebAssembly.Tests.csproj`. Additional Razor Components tests are spread throughout the `src/Components/` tree, following the same `test` subfolder convention as other ASP.NET Core components.