Update documentation to clarify TUnit's support for Microsoft.Testing.Platform and adjust related content across multiple files

Author: thomhurst

docs/core/testing/microsoft-testing-platform-intro.md

@@ -41,7 +41,7 @@ The main driving factors for the evolution of the new testing platform are detai
 * MSTest. In MSTest, the support of `Microsoft.Testing.Platform` is done via [MSTest runner](unit-testing-mstest-runner-intro.md).
 * NUnit. In NUnit, the support of `Microsoft.Testing.Platform` is done via [NUnit runner](unit-testing-nunit-runner-intro.md).
 * xUnit.net: In xUnit.net, the support of `Microsoft.Testing.Platform` is done via [xUnit.net runner](https://xunit.net/docs/getting-started/v3/microsoft-testing-platform).
-* TUnit: Built entirely on Microsoft.Testing.Platform and doesn't support VSTest. Unlike MSTest, NUnit, and xUnit which support both VSTest and MTP, TUnit only supports MTP. For more information, see [TUnit documentation](https://tunit.dev/) and [Getting started with TUnit](unit-testing-csharp-with-tunit.md).
+* TUnit: Built entirely on Microsoft.Testing.Platform and doesn't support VSTest. For more information, see [TUnit documentation](https://tunit.dev/) and [Getting started with TUnit](unit-testing-csharp-with-tunit.md).
 
 ## Run and debug tests
 

docs/core/testing/selective-unit-tests.md

@@ -30,9 +30,8 @@ dotnet test --filter <Expression>
   | Test framework | Supported properties |
   | -------------- | -------------------- |
   | MSTest         | `FullyQualifiedName`<br>`Name`<br>`ClassName`<br>`Priority`<br>`TestCategory` |
-  | xUnit          | `FullyQualifiedName`<br>`DisplayName`<br>`Traits` |
   | NUnit          | `FullyQualifiedName`<br>`Name`<br>`Priority`<br>`TestCategory` |
-  | TUnit          | `FullyQualifiedName`<br>`Name`<br>`Category`<br>`Property` |
+  | xUnit          | `FullyQualifiedName`<br>`DisplayName`<br>`Traits` |
 
 * **Operators**
 

docs/core/testing/unit-testing-code-coverage.md

@@ -165,14 +165,25 @@ There are two types of code coverage tools:
 
 In this section, the focus is on data collector tools.
 
-.NET includes a built-in code coverage data collector, which is also available in Visual Studio. This data collector generates a binary *.coverage* file that can be used to generate reports in Visual Studio. The binary file isn't human-readable, and it must be converted to a human-readable format before it can be used to generate reports outside of Visual Studio.
+### Code coverage approaches
+
+.NET provides two different testing platforms, each with its own code coverage approach:
+
+- **VSTest-based frameworks** (MSTest, NUnit, xUnit) - Can use either the built-in .NET code coverage collector or [Coverlet](https://github.com/coverlet-coverage/coverlet), an open-source alternative.
+- **Microsoft.Testing.Platform-based frameworks** (TUnit, MSTest runner, NUnit runner, xUnit runner) - Use [Microsoft.Testing.Extensions.CodeCoverage](microsoft-testing-platform-extensions-code-coverage.md).
+
+The built-in .NET code coverage data collector generates a binary *.coverage* file that can be used to generate reports in Visual Studio. The binary file isn't human-readable, and it must be converted to a human-readable format before it can be used to generate reports outside of Visual Studio.
 
 > [!TIP]
 > The `dotnet-coverage` tool is a cross-platform tool that can be used to convert the binary coverage test results file to a human-readable format. For more information, see [dotnet-coverage](../additional-tools/dotnet-coverage.md).
 
-[Coverlet](https://github.com/coverlet-coverage/coverlet) is an open-source alternative to the built-in collector. It generates test results as human-readable Cobertura XML files, which can then be used to generate HTML reports. To use Coverlet for code coverage, an existing unit test project must have the appropriate package dependencies, or alternatively rely on [.NET global tooling](../tools/global-tools.md) and the corresponding [coverlet.console](https://www.nuget.org/packages/coverlet.console) NuGet package.
+Coverlet generates test results as human-readable Cobertura XML files, which can then be used to generate HTML reports. To use Coverlet for code coverage, an existing unit test project must have the appropriate package dependencies, or alternatively rely on [.NET global tooling](../tools/global-tools.md) and the corresponding [coverlet.console](https://www.nuget.org/packages/coverlet.console) NuGet package.
+
+## Code coverage with VSTest
+
+VSTest is the traditional testing platform used by MSTest, NUnit, and xUnit. For VSTest-based projects, you can use either Coverlet or the built-in .NET code coverage collector.
 
-## Integrate with .NET test
+### Using Coverlet with VSTest
 
 The xUnit test project template already integrates with [coverlet.collector](https://www.nuget.org/packages/coverlet.collector) by default.
 From the command prompt, change directories to the *XUnit.Coverlet.Collector* project, and run the [`dotnet test`](../tools/dotnet-test.md) command:
@@ -295,70 +306,27 @@ After running this command, an HTML file represents the generated report.
 
 :::image type="content" source="media/test-report.png" lightbox="media/test-report.png" alt-text="Unit test-generated report":::
 
-## Using code coverage with TUnit
+## Code coverage with Microsoft.Testing.Platform
 
-TUnit is built on Microsoft.Testing.Platform and uses Microsoft.Testing.Extensions.CodeCoverage for code coverage.
-
-### Creating a TUnit test project with code coverage
-
-To create a TUnit test project with code coverage support:
-
-```dotnetcli
-dotnet new install TUnit.Templates
-dotnet new tunit -n TUnit.CodeCoverage.Test
-```
+[Microsoft.Testing.Platform](microsoft-testing-platform-intro.md) is the modern testing platform for .NET. Frameworks built on this platform use [Microsoft.Testing.Extensions.CodeCoverage](microsoft-testing-platform-extensions-code-coverage.md) for code coverage.
 
-Add the project reference to your class library:
+The following frameworks support Microsoft.Testing.Platform:
+- **MSTest** (via MSTest runner)
+- **NUnit** (via NUnit runner)
+- **xUnit** (via xUnit runner)
+- **TUnit**
 
-```dotnetcli
-dotnet add TUnit.CodeCoverage.Test\TUnit.CodeCoverage.Test.csproj reference Numbers\Numbers.csproj
-```
+### Setting up code coverage with Microsoft.Testing.Platform
 
-Add the Microsoft.Testing.Extensions.CodeCoverage package:
+The setup process is consistent across all Microsoft.Testing.Platform-based frameworks. Add the code coverage package to your test project:
 
 ```dotnetcli
-dotnet add TUnit.CodeCoverage.Test package Microsoft.Testing.Extensions.CodeCoverage
+dotnet add package Microsoft.Testing.Extensions.CodeCoverage
 ```
 
-### TUnit test example
-
-```csharp
-using TUnit.Assertions;
-using TUnit.Assertions.Extensions;
-using TUnit.Core;
-using System.Numbers;
-
-public class PrimeServiceTests
-{
-    [Test]
-    public async Task IsPrime_InputIs1_ReturnFalse()
-    {
-        var primeService = new PrimeService();
+### Configuring Microsoft.Testing.Platform mode
 
-        bool result = primeService.IsPrime(1);
-
-        await Assert.That(result).IsFalse();
-    }
-
-    [Test]
-    [Arguments(2)]
-    [Arguments(3)]
-    [Arguments(5)]
-    [Arguments(7)]
-    public async Task IsPrime_PrimesLessThan10_ReturnTrue(int value)
-    {
-        var primeService = new PrimeService();
-
-        bool result = primeService.IsPrime(value);
-
-        await Assert.That(result).IsTrue();
-    }
-}
-```
-
-### Running code coverage with TUnit
-
-Since TUnit requires Microsoft.Testing.Platform mode, ensure your `global.json` includes:
+Some frameworks require Microsoft.Testing.Platform mode to be explicitly configured. Add this configuration to your `global.json` file in the solution root:
 
 ```json
 {
@@ -368,19 +336,36 @@ Since TUnit requires Microsoft.Testing.Platform mode, ensure your `global.json`
 }
 ```
 
-Run tests with code coverage:
+> [!NOTE]
+> This configuration requires .NET 10 SDK or later. Frameworks like MSTest runner, NUnit runner, and xUnit runner support both VSTest and Microsoft.Testing.Platform, so this configuration is optional for those frameworks. TUnit only supports Microsoft.Testing.Platform, so this configuration is required.
+
+### Running code coverage
+
+Run tests with code coverage using the `--coverage` flag:
 
 ```dotnetcli
 dotnet test --coverage
 ```
 
-This generates a `.coverage` file in the `TestResults` directory. To generate reports in other formats:
+This generates a `.coverage` file in the `TestResults` directory. The `--coverage` flag is specific to Microsoft.Testing.Platform and provides a unified code coverage experience across all supported frameworks.
+
+To generate reports in other formats, use the `--coverage-output-format` option:
 
 ```dotnetcli
 dotnet test --coverage --coverage-output-format cobertura
 ```
 
-For more information about TUnit, see [Unit testing C# with TUnit](unit-testing-csharp-with-tunit.md).
+Supported output formats include:
+- `coverage` (binary format, default)
+- `cobertura` (XML format)
+- `xml` (XML format)
+
+### Framework-specific documentation
+
+For detailed information about using Microsoft.Testing.Platform with specific frameworks, see:
+- [Unit testing with MSTest runner](unit-testing-mstest-runner-intro.md)
+- [Unit testing with NUnit runner](unit-testing-nunit-runner-intro.md)
+- [Unit testing C# with TUnit](unit-testing-csharp-with-tunit.md)
 
 ## See also
 

docs/core/testing/unit-testing-csharp-with-tunit.md

@@ -8,11 +8,11 @@ ai-usage: ai-assisted
 ---
 # Unit testing C# in .NET using dotnet test and TUnit
 
-This tutorial shows how to build a solution containing a unit test project and source code project. To follow the tutorial using a prebuilt solution, [view or download the sample code](https://github.com/dotnet/samples/tree/main/core/getting-started/unit-testing-using-dotnet-test/). For download instructions, see [Samples and Tutorials](../../samples-and-tutorials/index.md#view-and-download-samples).
+This tutorial shows how to build a solution containing a unit test project and source code project step-by-step.
 
 ## Prerequisites
 
-TUnit is built entirely on [Microsoft.Testing.Platform](microsoft-testing-platform-intro.md). Unlike frameworks that support both VSTest and Microsoft.Testing.Platform, TUnit only supports Microsoft.Testing.Platform.
+TUnit is built entirely on [Microsoft.Testing.Platform](microsoft-testing-platform-intro.md) and does not support VSTest.
 
 ## Create the solution
 
@@ -125,6 +125,9 @@ Follow the instructions for "Replace the code in *PrimeService.cs* with the foll
 
 TUnit only supports Microsoft.Testing.Platform and doesn't support VSTest. To use `dotnet test` with TUnit, add the following configuration to your `global.json` file in the solution root:
 
+> [!NOTE]
+> This configuration requires .NET 10 SDK or later.
+
 ```json
 {
     "test": {

docs/core/testing/unit-testing-fsharp-with-tunit.md

@@ -8,13 +8,13 @@ ai-usage: ai-assisted
 ---
 # Unit testing F# libraries in .NET Core using dotnet test and TUnit
 
-This tutorial takes you through an interactive experience building a sample solution step-by-step to learn unit testing concepts. If you prefer to follow the tutorial using a pre-built solution, [view or download the sample code](https://github.com/dotnet/samples/tree/main/core/getting-started/unit-testing-with-fsharp/) before you begin. For download instructions, see [Samples and Tutorials](../../samples-and-tutorials/index.md#view-and-download-samples).
+This tutorial takes you through an interactive experience building a sample solution step-by-step to learn unit testing concepts.
 
 [!INCLUDE [testing an ASP.NET Core project from .NET Core](../../../includes/core-testing-note-aspnet.md)]
 
 ## Prerequisites
 
-TUnit is built entirely on [Microsoft.Testing.Platform](microsoft-testing-platform-intro.md). Unlike frameworks that support both VSTest and Microsoft.Testing.Platform, TUnit only supports Microsoft.Testing.Platform.
+TUnit is built entirely on [Microsoft.Testing.Platform](microsoft-testing-platform-intro.md) and does not support VSTest.
 
 ## Creating the source project
 

docs/core/testing/unit-testing-visual-basic-with-tunit.md

@@ -8,11 +8,11 @@ ai-usage: ai-assisted
 ---
 # Unit testing Visual Basic .NET Core libraries using dotnet test and TUnit
 
-This tutorial shows how to build a solution containing a unit test project and library project. To follow the tutorial using a pre-built solution, [view or download the sample code](https://github.com/dotnet/samples/tree/main/core/getting-started/unit-testing-using-dotnet-test/). For download instructions, see [Samples and Tutorials](../../samples-and-tutorials/index.md#view-and-download-samples).
+This tutorial shows how to build a solution containing a unit test project and library project step-by-step.
 
 ## Prerequisites
 
-TUnit is built entirely on [Microsoft.Testing.Platform](microsoft-testing-platform-intro.md). Unlike frameworks that support both VSTest and Microsoft.Testing.Platform, TUnit only supports Microsoft.Testing.Platform.
+TUnit is built entirely on [Microsoft.Testing.Platform](microsoft-testing-platform-intro.md) and does not support VSTest.
 
 ## Create the solution
 
@@ -102,8 +102,6 @@ The following instructions provide the steps to create the test solution. See [C
   dotnet add ./PrimeService.Tests/PrimeService.Tests.vbproj reference ./PrimeService/PrimeService.vbproj
   ```
 
-<a name="create-test-cmd"></a>
-
 ### Commands to create the solution
 
 This section summarizes all the commands in the previous section. Skip this section if you've completed the steps in the previous section.
@@ -152,21 +150,20 @@ Update the *PrimeService.Tests* project:
 Imports TUnit.Assertions
 Imports TUnit.Assertions.Extensions
 Imports TUnit.Core
+Imports Prime.Services
 
 Namespace PrimeService.Tests
     Public Class PrimeService_IsPrimeShould
-        Private ReadOnly _primeService As Prime.Services.PrimeService
+        Private ReadOnly _primeService As PrimeService
 
         Public Sub New()
-            _primeService = New Prime.Services.PrimeService()
+            _primeService = New PrimeService()
         End Sub
 
         <Test>
-        Function IsPrime_InputIs1_ReturnFalse() As Task
-            Return Task.Run(Async Function()
-                Dim result As Boolean = _primeService.IsPrime(1)
-                Await Assert.That(result).IsFalse()
-            End Function)
+        Public Async Function IsPrime_InputIs1_ReturnFalse() As Task
+            Dim result As Boolean = _primeService.IsPrime(1)
+            Await Assert.That(result).IsFalse()
         End Function
 
     End Class
@@ -206,11 +203,9 @@ Rather than creating new tests, apply the `[Arguments]` attribute to create para
 
 ```vb
 <Test>
-Function IsPrime_InputIs1_ReturnFalse() As Task
-    Return Task.Run(Async Function()
-        Dim result As Boolean = _primeService.IsPrime(1)
-        Await Assert.That(result).IsFalse()
-    End Function)
+Public Async Function IsPrime_InputIs1_ReturnFalse() As Task
+    Dim result As Boolean = _primeService.IsPrime(1)
+    Await Assert.That(result).IsFalse()
 End Function
 ```
 
@@ -221,11 +216,9 @@ with the following code:
 <Arguments(-1)>
 <Arguments(0)>
 <Arguments(1)>
-Function IsPrime_ValuesLessThan2_ReturnFalse(ByVal value As Integer) As Task
-    Return Task.Run(Async Function()
-        Dim result As Boolean = _primeService.IsPrime(value)
-        Await Assert.That(result).IsFalse()
-    End Function)
+Public Async Function IsPrime_ValuesLessThan2_ReturnFalse(ByVal value As Integer) As Task
+    Dim result As Boolean = _primeService.IsPrime(value)
+    Await Assert.That(result).IsFalse()
 End Function
 ```
 

docs/zone-pivot-groups.yml

@@ -34,10 +34,12 @@ groups:
   pivots:
     - id: mstest
       title: MSTest
-    - id: xunit
-      title: xUnit
     - id: nunit
       title: NUnit
+    - id: tunit
+      title: TUnit
+    - id: xunit
+      title: xUnit
 - id: ide-set-one
   title: IDE
   prompt: Choose an IDE