Make the test suite pass in every environment and run fully in CI

TUnit.CI.slnx

@@ -87,6 +87,7 @@
     <Project Path="tests/TUnit.Mocks.Tests/TUnit.Mocks.Tests.csproj" />
     <Project Path="tests/TUnit.PublicAPI/TUnit.PublicAPI.csproj" />
     <Project Path="tests/TUnit.RpcTests/TUnit.RpcTests.csproj" />
+    <Project Path="tests/TUnit.SourceGenerator.IncrementalTests/TUnit.SourceGenerator.IncrementalTests.csproj" />
     <Project Path="tests/TUnit.Templates.Tests/TUnit.Templates.Tests.csproj" />
     <Project Path="tests/TUnit.UnitTests/TUnit.UnitTests.csproj" />
     <Project Path="tests/TUnit.Aspire.Tests/TUnit.Aspire.Tests.csproj" />

TUnit.Dev.slnx

@@ -7,6 +7,7 @@
 
   <!-- Core framework packages -->
   <Folder Name="/Core/">
+    <Project Path="src/TUnit.Assertions.Should/TUnit.Assertions.Should.csproj" />
     <Project Path="src/TUnit/TUnit.csproj" />
     <Project Path="src/TUnit.Core/TUnit.Core.csproj" />
     <Project Path="src/TUnit.Engine/TUnit.Engine.csproj" />
@@ -18,6 +19,7 @@
   <Folder Name="/Libraries/">
     <Project Path="src/TUnit.Aspire/TUnit.Aspire.csproj" />
     <Project Path="src/TUnit.Aspire.Core/TUnit.Aspire.Core.csproj" />
+    <Project Path="src/TUnit.Mocks.InternalsAccess.Tasks/TUnit.Mocks.InternalsAccess.Tasks.csproj" />
     <Project Path="src/TUnit.OpenTelemetry/TUnit.OpenTelemetry.csproj" />
     <Project Path="src/TUnit.AspNetCore/TUnit.AspNetCore.csproj" />
     <Project Path="src/TUnit.AspNetCore.Core/TUnit.AspNetCore.Core.csproj" />
@@ -28,6 +30,7 @@
     <Project Path="src/TUnit.Mocks.Http/TUnit.Mocks.Http.csproj" />
     <Project Path="src/TUnit.Mocks.Logging/TUnit.Mocks.Logging.csproj" />
     <Project Path="src/TUnit.Playwright/TUnit.Playwright.csproj" />
+    <Project Path="src/TUnit.Templates/TUnit.Templates.csproj" />
   </Folder>
 
   <!-- Roslyn analyzers and code fixers (base projects only, no Roslyn version variants) -->
@@ -44,6 +47,7 @@
 
   <!-- Source generators (base projects only, no Roslyn version variants) -->
   <Folder Name="/SourceGenerators/">
+    <Project Path="src/TUnit.Assertions.Should.SourceGenerator/TUnit.Assertions.Should.SourceGenerator.csproj" />
     <Project Path="src/TUnit.Assertions.SourceGenerator/TUnit.Assertions.SourceGenerator.csproj" />
     <Project Path="src/TUnit.Core.SourceGenerator/TUnit.Core.SourceGenerator.csproj" />
     <Project Path="src/TUnit.Mocks.SourceGenerator/TUnit.Mocks.SourceGenerator.csproj" />
@@ -54,21 +58,30 @@
     <Project Path="tests/TUnit.Analyzers.Internal.Tests/TUnit.Analyzers.Internal.Tests.csproj" />
     <Project Path="tests/TUnit.Analyzers.Tests/TUnit.Analyzers.Tests.csproj" />
     <Project Path="tests/TUnit.AspNetCore.Analyzers.Tests/TUnit.AspNetCore.Analyzers.Tests.csproj" />
+    <Project Path="tests/TUnit.AspNetCore.Tests.MinimalApi/TUnit.AspNetCore.Tests.MinimalApi.csproj" />
+    <Project Path="tests/TUnit.AspNetCore.Tests.WebApp/TUnit.AspNetCore.Tests.WebApp.csproj" />
+    <Project Path="tests/TUnit.AspNetCore.Tests/TUnit.AspNetCore.Tests.csproj" />
     <Project Path="tests/TUnit.Assertions.Analyzers.CodeFixers.Tests/TUnit.Assertions.Analyzers.CodeFixers.Tests.csproj" />
     <Project Path="tests/TUnit.Assertions.Analyzers.Tests/TUnit.Assertions.Analyzers.Tests.csproj" />
+    <Project Path="tests/TUnit.Assertions.Should.SourceGenerator.Tests/TUnit.Assertions.Should.SourceGenerator.Tests.csproj" />
+    <Project Path="tests/TUnit.Assertions.Should.Tests/TUnit.Assertions.Should.Tests.csproj" />
     <Project Path="tests/TUnit.Assertions.SourceGenerator.Tests/TUnit.Assertions.SourceGenerator.Tests.csproj" />
     <Project Path="tests/TUnit.Assertions.Tests/TUnit.Assertions.Tests.csproj" />
     <Project Path="tests/TUnit.Core.SourceGenerator.Tests/TUnit.Core.SourceGenerator.Tests.csproj" />
     <Project Path="tests/TUnit.Engine.Tests/TUnit.Engine.Tests.csproj" />
     <Project Path="tests/TUnit.Mocks.Analyzers.Tests/TUnit.Mocks.Analyzers.Tests.csproj" />
     <Project Path="tests/TUnit.Mocks.Aot.Tests/TUnit.Mocks.Aot.Tests.csproj" />
     <Project Path="tests/TUnit.Mocks.Http.Tests/TUnit.Mocks.Http.Tests.csproj" />
+    <Project Path="tests/TUnit.Mocks.InternalsAccess.TargetLib/TUnit.Mocks.InternalsAccess.TargetLib.csproj" />
+    <Project Path="tests/TUnit.Mocks.InternalsAccess.Tests/TUnit.Mocks.InternalsAccess.Tests.csproj" />
     <Project Path="tests/TUnit.Mocks.Logging.Tests/TUnit.Mocks.Logging.Tests.csproj" />
     <Project Path="tests/TUnit.Mocks.SourceGenerator.Tests/TUnit.Mocks.SourceGenerator.Tests.csproj" />
     <Project Path="tests/TUnit.Mocks.Tests/TUnit.Mocks.Tests.csproj" />
     <Project Path="tests/TUnit.OpenTelemetry.Tests/TUnit.OpenTelemetry.Tests.csproj" />
     <Project Path="tests/TUnit.PublicAPI/TUnit.PublicAPI.csproj" />
     <Project Path="tests/TUnit.RpcTests/TUnit.RpcTests.csproj" />
+    <Project Path="tests/TUnit.SourceGenerator.IncrementalTests/TUnit.SourceGenerator.IncrementalTests.csproj" />
+    <Project Path="tests/TUnit.Templates.Tests/TUnit.Templates.Tests.csproj" />
     <Project Path="tests/TUnit.TestProject.HtmlReportDefaults/TUnit.TestProject.HtmlReportDefaults.csproj" />
     <Project Path="tests/TUnit.TestProject.Library/TUnit.TestProject.Library.csproj" />
     <Project Path="tests/TUnit.UnitTests/TUnit.UnitTests.csproj" />

tests/SharedTestHelpers/DotNetCli.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace TUnit.Tests.Shared;
+
+/// <summary>
+/// Resolves the <c>dotnet</c> executable used to start child <c>dotnet build</c>/<c>dotnet run</c> processes.
+/// </summary>
+/// <remarks>
+/// A bare <c>dotnet</c> resolves through <c>PATH</c>, which an IDE does not necessarily share with the
+/// installation it builds and runs tests with (on macOS, apps started from the Dock or Finder get a different
+/// <c>PATH</c> than a terminal). That <c>dotnet</c> can lack an SDK satisfying <c>global.json</c> and exit with
+/// 155 (<c>SdkResolveFailure</c>). Prefer the installation that is running the current test process, as long as it
+/// resolves an SDK for this repository: a runtime-only installation, or one whose SDKs don't satisfy
+/// <c>global.json</c>, cannot run <c>dotnet build</c> here, so <c>PATH</c> is the better bet there.
+/// </remarks>
+internal static class DotNetCli
+{
+    // Resolved on first use rather than in the type initializer, so an unexpected failure surfaces as itself
+    // instead of a TypeInitializationException that also breaks every later use of the type
+    private static readonly Lazy<string> ResolvedPath = new(Resolve);
+
+    /// <summary>The <c>dotnet</c> executable to start child processes with: a full path, or <c>dotnet</c> to use <c>PATH</c>.</summary>
+    public static string Path => ResolvedPath.Value;
+
+    /// <summary>
+    /// Prefers <c>DOTNET_HOST_PATH</c>, then the muxer of the installation running this process when it resolves an
+    /// SDK for this repository, and otherwise falls back to <c>dotnet</c> on <c>PATH</c>.
+    /// </summary>
+    private static string Resolve()
+    {
+        // Set by the .NET CLI for processes it starts (e.g. under `dotnet test`), so it already resolved an SDK.
+        var hostPath = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH");
+        if (!string.IsNullOrEmpty(hostPath) && File.Exists(hostPath))
+        {
+            return hostPath;
+        }
+
+        // <root>/shared/Microsoft.NETCore.App/<version>/ -> <root>/dotnet
+        var runtimeDirectory = RuntimeEnvironment.GetRuntimeDirectory();
+        var root = System.IO.Path.GetFullPath(System.IO.Path.Combine(runtimeDirectory, "..", "..", ".."));
+        var muxer = System.IO.Path.Combine(root, RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "dotnet.exe" : "dotnet");
+
+        return File.Exists(muxer) && ResolvesSdk(muxer) ? muxer : "dotnet";
+    }
+
+    /// <summary>
+    /// Whether <paramref name="muxer"/> resolves an SDK from the test assembly's directory, which lies inside the
+    /// repository: <c>dotnet --version</c> applies <c>global.json</c> the same way the child builds do and fails, with
+    /// 155, exactly when they would.
+    /// </summary>
+    private static bool ResolvesSdk(string muxer)
+    {
+        try
+        {
+            using var process = Process.Start(new ProcessStartInfo(muxer, "--version")
+            {
+                WorkingDirectory = AppContext.BaseDirectory,
+                UseShellExecute = false,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                CreateNoWindow = true,
+            });
+
+            if (process is null)
+            {
+                return false;
+            }
+
+            // Drain and discard both streams so neither can fill up and block the process
+            process.OutputDataReceived += static (_, _) => { };
+            process.ErrorDataReceived += static (_, _) => { };
+            process.BeginOutputReadLine();
+            process.BeginErrorReadLine();
+
+            if (!process.WaitForExit(30_000))
+            {
+                process.Kill(entireProcessTree: true);
+                return false;
+            }
+
+            return process.ExitCode == 0;
+        }
+        catch (Exception exception) when (exception is InvalidOperationException or System.ComponentModel.Win32Exception or IOException)
+        {
+            return false;
+        }
+    }
+}

tests/SharedTestHelpers/TestHostReferences.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using Microsoft.CodeAnalysis;
+
+namespace TUnit.Tests.Shared;
+
+/// <summary>
+/// Paths of the assemblies that in-memory test compilations (generator and analyzer tests) reference.
+/// </summary>
+/// <remarks>
+/// <c>AppDomain.CurrentDomain.GetAssemblies()</c> only returns what the process has loaded so far, which depends on
+/// how the test host was launched: IDE and <c>dotnet test</c> server-mode hosts load assemblies (e.g. System.Net.*)
+/// that a plain run does not, so types such as <c>System.Net.HttpStatusCode</c> resolved or not and generator output
+/// differed between launches. On .NET, <c>TRUSTED_PLATFORM_ASSEMBLIES</c> lists the app's whole deployment
+/// (framework plus deps.json) up front. .NET Framework has no such list, so it keeps the loaded assemblies.
+/// <para>
+/// Neither source has a defined order (the TPA order differs between Linux and macOS hosts), and generators emit
+/// referenced assemblies in reference order, so the paths are sorted to keep snapshots identical on every host.
+/// </para>
+/// </remarks>
+internal static class TestHostReferences
+{
+    /// <summary>The assembly paths to reference, sorted by file name and then by path.</summary>
+    public static IReadOnlyList<string> AssemblyPaths { get; } = Resolve();
+
+    /// <summary>
+    /// Metadata references to <see cref="AssemblyPaths"/>, followed by <paramref name="additionalAssemblies"/>.
+    /// </summary>
+    public static List<PortableExecutableReference> CreateReferences(params Assembly[] additionalAssemblies) =>
+        CreateReferences(static _ => true, additionalAssemblies);
+
+    /// <summary>
+    /// Metadata references to the <see cref="AssemblyPaths"/> that <paramref name="includeHostAssembly"/> accepts,
+    /// followed by <paramref name="additionalAssemblies"/>.
+    /// </summary>
+    public static List<PortableExecutableReference> CreateReferences(Func<string, bool> includeHostAssembly, params Assembly[] additionalAssemblies) =>
+        AssemblyPaths
+            .Where(includeHostAssembly)
+            .Concat(additionalAssemblies.Select(assembly => assembly.Location))
+            .Select(path => MetadataReference.CreateFromFile(path))
+            .ToList();
+
+    /// <summary>
+    /// Reads <c>TRUSTED_PLATFORM_ASSEMBLIES</c> on .NET, or the loaded assemblies on .NET Framework, and sorts them.
+    /// </summary>
+    private static string[] Resolve()
+    {
+        var paths = AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES") is string trustedPlatformAssemblies
+            ? trustedPlatformAssemblies.Split(new[] { Path.PathSeparator }, StringSplitOptions.RemoveEmptyEntries)
+            : AppDomain.CurrentDomain.GetAssemblies()
+                .Where(assembly => !assembly.IsDynamic && !string.IsNullOrWhiteSpace(assembly.Location))
+                .Select(assembly => assembly.Location);
+
+        // Ordinal on purpose: reference order shows up in generator output, so a culture-aware sort, or no sort, would
+        // reorder snapshots between hosts. A snapshot that reorders after a change here is this sort, not the generator.
+        return paths
+            .OrderBy(Path.GetFileName, StringComparer.Ordinal)
+            .ThenBy(path => path, StringComparer.Ordinal)
+            .ToArray();
+    }
+}

tests/TUnit.Aspire.Tests/TUnit.Aspire.Tests.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <Import Project="..\..\src\TUnit.Engine\TUnit.Engine.props" />
+  <Import Project="..\..\eng\TestProject.props" />
 
   <PropertyGroup>
     <TargetFrameworks>net10.0</TargetFrameworks>
@@ -11,17 +11,14 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\TUnit.Aspire\TUnit.Aspire.csproj" />
-    <ProjectReference Include="..\..\src\TUnit.Engine\TUnit.Engine.csproj" />
-    <ProjectReference Include="..\..\src\TUnit.Assertions\TUnit.Assertions.csproj" />
     <ProjectReference Include="..\TUnit.Aspire.Tests.AppHost\TUnit.Aspire.Tests.AppHost.csproj" />
-    <ProjectReference Include="..\..\src\TUnit.Core.SourceGenerator\TUnit.Core.SourceGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
-    <ProjectReference Include="..\..\src\TUnit.Analyzers\TUnit.Analyzers.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
   </ItemGroup>
 
   <ItemGroup>
     <PackageReference Include="Aspire.Hosting.Testing" />
     <PackageReference Include="Microsoft.Testing.Extensions.HangDump" />
-    <PackageReference Include="Microsoft.Testing.Platform.MSBuild" />
   </ItemGroup>
 
+  <Import Project="..\..\eng\TestProject.targets" />
+
 </Project>

tests/TUnit.Assertions.Should.SourceGenerator.Tests/ShouldExtensionGeneratorTests.cs

@@ -3,6 +3,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using TUnit.Assertions.Core;
+using TUnit.Tests.Shared;
 
 namespace TUnit.Assertions.Should.SourceGenerator.Tests;
 
@@ -448,7 +449,7 @@ public sealed class OverloadResolutionPriorityAttribute : System.Attribute
         var compilation = CSharpCompilation.Create(
             assemblyName: "GeneratorTest",
             syntaxTrees: inputTrees,
-            references: GetReferences(),
+            references: References,
             options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
 
         var driver = CSharpGeneratorDriver.Create(new ShouldExtensionGenerator());
@@ -471,25 +472,11 @@ await Verify(combined)
         return combined;
     }
 
-    private static IEnumerable<MetadataReference> GetReferences()
-    {
-        // Mirror the loaded assemblies of the test process. Works on both .NET Core
-        // (where TRUSTED_PLATFORM_ASSEMBLIES populates this set) and .NET Framework,
-        // unlike <c>AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")</c> which returns
-        // null on .NET Framework and would leave the in-memory compilation without BCL
-        // references — making symbol resolution silently fail in the generator.
-        foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
-        {
-            if (asm.IsDynamic || string.IsNullOrWhiteSpace(asm.Location))
-            {
-                continue;
-            }
-            yield return MetadataReference.CreateFromFile(asm.Location);
-        }
-
-        yield return MetadataReference.CreateFromFile(typeof(Assertion<>).Assembly.Location);
-        yield return MetadataReference.CreateFromFile(typeof(TUnit.Assertions.Should.Core.IShouldSource).Assembly.Location);
-    }
+    // Built once: every test compiles against the same references, and each one reads its file from disk
+    private static readonly List<PortableExecutableReference> References =
+        TestHostReferences.CreateReferences(
+            typeof(Assertion<>).Assembly,
+            typeof(TUnit.Assertions.Should.Core.IShouldSource).Assembly);
 
     private static int CountOccurrences(string value, string search)
     {

tests/TUnit.Assertions.Should.SourceGenerator.Tests/TUnit.Assertions.Should.SourceGenerator.Tests.csproj

@@ -17,6 +17,10 @@
     <NoWarn>$(NoWarn);MSB3277</NoWarn>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Include="..\SharedTestHelpers\TestHostReferences.cs" Link="Shared\TestHostReferences.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\..\src\TUnit.Assertions.Should.SourceGenerator\TUnit.Assertions.Should.SourceGenerator.csproj" />
     <ProjectReference Include="..\..\src\TUnit.Assertions.Should\TUnit.Assertions.Should.csproj" />