From 76971eb03d7e68928ebc0433dd3f3df4a8188f22 Mon Sep 17 00:00:00 2001
From: Garrett Beatty <gcbeatty@amazon.com>
Date: Wed, 8 Jul 2026 10:47:39 -0400
Subject: [PATCH 1/7] Auto-discover unit-test projects in CI instead of
 hardcoded list

The run-unit-tests target only ran 4 hardcoded projects, so test
projects such as Amazon.Lambda.AspNetCoreServer.Test, Core.Tests,
EventsTests.NET8 and others were never executed in CI. Replace the
hardcoded list with run-unit-tests.ps1, which discovers any project
referencing the test SDK (excluding *.IntegrationTests.csproj, which
run in a separate phase), mirroring run-integ-tests-parallel.ps1.
---
 buildtools/build.proj         |  8 ++--
 buildtools/run-unit-tests.ps1 | 69 +++++++++++++++++++++++++++++++++++
 2 files changed, 73 insertions(+), 4 deletions(-)
 create mode 100644 buildtools/run-unit-tests.ps1

diff --git a/buildtools/build.proj b/buildtools/build.proj
index e160116aa..54d6728d3 100644
--- a/buildtools/build.proj
+++ b/buildtools/build.proj
@@ -214,10 +214,10 @@
         IgnoreStandardErrorWarningFormat="true"/>
     </Target>
     <Target Name="run-unit-tests">
-        <Exec Command="dotnet test -c $(Configuration)" WorkingDirectory="..\Libraries\test\SnapshotRestore.Registry.Tests"/>
-        <Exec Command="dotnet test -c $(Configuration)" WorkingDirectory="..\Libraries\test\Amazon.Lambda.RuntimeSupport.Tests\Amazon.Lambda.RuntimeSupport.UnitTests"/>
-        <Exec Command="dotnet test -c $(Configuration)" WorkingDirectory="..\Libraries\test\Amazon.Lambda.Annotations.SourceGenerators.Tests"/>
-        <Exec Command="dotnet test -c $(Configuration)" WorkingDirectory="..\Libraries\test\Amazon.Lambda.DurableExecution.Tests"/>
+        <!-- Unit-test projects are discovered by convention (any *.csproj referencing the test SDK,
+             excluding *.IntegrationTests.csproj) so newly added test projects are picked up
+             automatically instead of having to be appended to a hardcoded list here. -->
+        <Exec Command="pwsh -NoProfile -File &quot;$(MSBuildThisFileDirectory)run-unit-tests.ps1&quot; -Configuration $(Configuration)"/>
     </Target>
     <Target Name="run-integ-tests">
         <!-- Each *.IntegrationTests.csproj deploys its own isolated CloudFormation stack, so the
diff --git a/buildtools/run-unit-tests.ps1 b/buildtools/run-unit-tests.ps1
new file mode 100644
index 000000000..6b793221b
--- /dev/null
+++ b/buildtools/run-unit-tests.ps1
@@ -0,0 +1,69 @@
+#!/usr/bin/env pwsh
+# Discovers and runs every unit-test project under Libraries/test, so new test projects are picked up
+# automatically instead of having to be added to a hardcoded list in build.proj (which is how projects
+# such as Amazon.Lambda.AspNetCoreServer.Test, Amazon.Lambda.Core.Tests and EventsTests.NET8 silently
+# stopped being run in CI).
+#
+# A project is treated as a unit-test project when its .csproj references Microsoft.NET.Test.Sdk (or
+# sets <IsTestProject>true</IsTestProject>). Naming is NOT used because the test projects in this repo
+# follow no single convention (*.Test, *.Tests, EventsTests.NET8, PowerShellTests, ...). Non-test
+# fixture projects (TestServerlessApp, TestWebApp, HandlerTest, ...) don't reference the test SDK, so
+# this content-based filter cleanly excludes them.
+#
+# Integration test projects (*.IntegrationTests.csproj) are excluded here because they run in a
+# separate phase via run-integ-tests-parallel.ps1 (they deploy real AWS resources).
+#
+# The script exits non-zero if any project fails, listing which ones.
+
+param(
+    [string]$Configuration = "Release",
+    # Directory to search for unit-test projects (defaults to the Libraries/test tree).
+    [string]$TestRoot = (Join-Path $PSScriptRoot ".." "Libraries" "test")
+)
+
+$ErrorActionPreference = 'Stop'
+
+# Discover unit-test projects: reference the test SDK / IsTestProject, but are not integration tests.
+$projects = Get-ChildItem -Path $TestRoot -Recurse -Filter "*.csproj" |
+    Where-Object { $_.Name -notlike "*.IntegrationTests.csproj" } |
+    Where-Object {
+        $content = Get-Content -Raw -LiteralPath $_.FullName
+        ($content -match 'Microsoft\.NET\.Test\.Sdk') -or
+        ($content -match '<IsTestProject>\s*true\s*</IsTestProject>')
+    } |
+    Select-Object -ExpandProperty FullName |
+    Sort-Object
+
+if (-not $projects)
+{
+    Write-Host "No unit-test projects found under '$TestRoot'."
+    exit 0
+}
+
+Write-Host "Running $($projects.Count) unit-test project(s):"
+$projects | ForEach-Object { Write-Host "  - $_" }
+
+$failed = @()
+foreach ($project in $projects)
+{
+    $name = [System.IO.Path]::GetFileNameWithoutExtension($project)
+    Write-Host ""
+    Write-Host "==================== $name ===================="
+    dotnet test -c $Configuration $project
+    if ($LASTEXITCODE -ne 0)
+    {
+        Write-Host "Tests failed for $name (exit $LASTEXITCODE)."
+        $failed += $name
+    }
+}
+
+if ($failed)
+{
+    Write-Host ""
+    Write-Host "The following unit-test project(s) failed:"
+    $failed | ForEach-Object { Write-Host "  - $_" }
+    exit 1
+}
+
+Write-Host ""
+Write-Host "All unit-test projects passed."

From e11f4ac62ce458ee8f8ba7bd3cd3d3984b5c75c9 Mon Sep 17 00:00:00 2001
From: Garrett Beatty <gcbeatty@amazon.com>
Date: Wed, 8 Jul 2026 11:15:19 -0400
Subject: [PATCH 2/7] Fix AspNetCoreServer tests surfaced by unit-test
 auto-discovery

These test projects were never run in CI before the discovery change, so
pre-existing failures went unnoticed. Fixes by category:

Real test bugs (failed deterministically, incl. locally):
- BuildStreamingPreludeTests / ResponseStreamingPropertyTests: the
  StandalonePreludeBuilder subclassed the HTTP API v2 function (whose
  BuildStreamingPrelude override collapses headers into single-value
  Headers), but the tests assert on the multi-value MultiValueHeaders
  collection. Derive from the REST v1 APIGatewayProxyFunction instead,
  matching the assertions and the section comments.

CI-environment robustness (passed locally, failed in CI):
- ci.buildspec.yml: raise fs.inotify.max_user_instances (container
  default 128 was exhausted once all ASP.NET-host-starting unit tests
  run, surfacing as inotify IOExceptions across ~90 tests).
- TestMinimalAPI: capture child-process stdout/stderr and handle the
  WaitForExit timeout so the out-of-process 'dotnet run' failure
  (exit 129) is diagnosable and the process cannot leak.
- AddAWSLambdaBeforeSnapshotRequestTests: poll for the before-snapshot
  callback instead of racing a fixed 500 ms delay that was flaky under
  CI load.
---
 .../AddAWSLambdaBeforeSnapshotRequestTests.cs | 14 +++++++++----
 .../BuildStreamingPreludeTests.cs             |  5 ++++-
 .../ResponseStreamingPropertyTests.cs         |  5 ++++-
 .../TestMinimalAPI.cs                         | 20 +++++++++++++++++--
 buildtools/ci.buildspec.yml                   |  6 ++++++
 5 files changed, 42 insertions(+), 8 deletions(-)

diff --git a/Libraries/test/Amazon.Lambda.AspNetCoreServer.Hosting.Tests/AddAWSLambdaBeforeSnapshotRequestTests.cs b/Libraries/test/Amazon.Lambda.AspNetCoreServer.Hosting.Tests/AddAWSLambdaBeforeSnapshotRequestTests.cs
index 3505d8bb3..f8de6ce9f 100644
--- a/Libraries/test/Amazon.Lambda.AspNetCoreServer.Hosting.Tests/AddAWSLambdaBeforeSnapshotRequestTests.cs
+++ b/Libraries/test/Amazon.Lambda.AspNetCoreServer.Hosting.Tests/AddAWSLambdaBeforeSnapshotRequestTests.cs
@@ -44,10 +44,16 @@ public async Task VerifyCallbackIsInvoked(LambdaEventSource hostingType)
             
         var serverTask = app.RunAsync();
 
-        // let the server run for a max of 500 ms
-        await Task.WhenAny(
-            serverTask,
-            Task.Delay(TimeSpan.FromMilliseconds(500)));
+        // Poll for the before-snapshot callback to fire rather than racing a single fixed delay.
+        // A fixed 500 ms window is flaky under load (observed intermittently in CI): the
+        // before-snapshot request may not have completed yet, leaving the callback unset. Wait up
+        // to 10 seconds, checking frequently, and stop as soon as the callback has run.
+        var timeout = TimeSpan.FromSeconds(10);
+        var sw = System.Diagnostics.Stopwatch.StartNew();
+        while (!callbackDidTheCallback && sw.Elapsed < timeout && !serverTask.IsCompleted)
+        {
+            await Task.Delay(TimeSpan.FromMilliseconds(50));
+        }
 
         // shut down server
         await app.StopAsync();
diff --git a/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/BuildStreamingPreludeTests.cs b/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/BuildStreamingPreludeTests.cs
index c2971d0ab..b2c4a08ad 100644
--- a/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/BuildStreamingPreludeTests.cs
+++ b/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/BuildStreamingPreludeTests.cs
@@ -14,7 +14,10 @@ public class BuildStreamingPreludeTests
     {
         // Subclass that skips host startup entirely and
         // just exposes BuildStreamingPrelude directly without needing a running host.
-        private class StandalonePreludeBuilder : APIGatewayHttpApiV2ProxyFunction
+        // Derives from the REST (v1) APIGatewayProxyFunction because these tests assert on the
+        // multi-value MultiValueHeaders collection; the HTTP API v2 function instead collapses
+        // headers into the single-value Headers collection (see APIGatewayHttpApiV2ProxyFunction).
+        private class StandalonePreludeBuilder : APIGatewayProxyFunction
         {
             // Use the StartupMode.FirstRequest constructor so no host is started eagerly.
             public StandalonePreludeBuilder()
diff --git a/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/ResponseStreamingPropertyTests.cs b/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/ResponseStreamingPropertyTests.cs
index 05c6bed87..1e55ea5c7 100644
--- a/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/ResponseStreamingPropertyTests.cs
+++ b/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/ResponseStreamingPropertyTests.cs
@@ -71,7 +71,10 @@ protected override APIGatewayHttpApiV2ProxyResponse MarshallResponse(
             }
         }
 
-        private class StandalonePreludeBuilder : APIGatewayHttpApiV2ProxyFunction
+        // Derives from the REST (v1) APIGatewayProxyFunction because the prelude property tests
+        // (Property3/Property4) assert on the multi-value MultiValueHeaders collection; the HTTP
+        // API v2 function instead collapses headers into the single-value Headers collection.
+        private class StandalonePreludeBuilder : APIGatewayProxyFunction
         {
             public StandalonePreludeBuilder() : base(StartupMode.FirstRequest) { }
 
diff --git a/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/TestMinimalAPI.cs b/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/TestMinimalAPI.cs
index 22709a1e3..e363a7d16 100644
--- a/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/TestMinimalAPI.cs
+++ b/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/TestMinimalAPI.cs
@@ -54,16 +54,32 @@ public T ExecuteRequest<T>(string eventFilePath)
                 processStartInfo.FileName = GetSystemShell();
                 processStartInfo.Arguments = $"{comamndArgument} dotnet run \"{requestFilePath}\" \"{responseFilePath}\"";
                 processStartInfo.WorkingDirectory = GetTestAppDirectory();
+                // Capture the child process output so a launch/build failure (e.g. the exit code 129
+                // seen intermittently in CI) surfaces a diagnosable message instead of a bare exit code.
+                processStartInfo.RedirectStandardOutput = true;
+                processStartInfo.RedirectStandardError = true;
+                processStartInfo.UseShellExecute = false;
 
 
                 lock (lock_process)
                 {
                     using var process = Process.Start(processStartInfo);
-                    process.WaitForExit(15000);
+                    var stdout = process.StandardOutput.ReadToEndAsync();
+                    var stderr = process.StandardError.ReadToEndAsync();
+
+                    // WaitForExit(timeout) returns false when the process is still running at the
+                    // timeout; kill it so it does not leak, then fail with the captured output.
+                    if (!process.WaitForExit(60000))
+                    {
+                        process.Kill(entireProcessTree: true);
+                        throw new Exception(
+                            $"Process timed out after 60s.{Environment.NewLine}STDOUT:{Environment.NewLine}{stdout.Result}{Environment.NewLine}STDERR:{Environment.NewLine}{stderr.Result}");
+                    }
 
                     if (process.ExitCode != 0)
                     {
-                        throw new Exception("Process failed with exit code: " + process.ExitCode);
+                        throw new Exception(
+                            $"Process failed with exit code: {process.ExitCode}.{Environment.NewLine}STDOUT:{Environment.NewLine}{stdout.Result}{Environment.NewLine}STDERR:{Environment.NewLine}{stderr.Result}");
                     }
 
                     if(!File.Exists(responseFilePath))
diff --git a/buildtools/ci.buildspec.yml b/buildtools/ci.buildspec.yml
index 23a30d366..3081f8bb0 100644
--- a/buildtools/ci.buildspec.yml
+++ b/buildtools/ci.buildspec.yml
@@ -5,6 +5,12 @@ phases:
     runtime-versions:
       dotnet: 8.x
     commands:
+      # Raise the inotify limits. The AspNetCoreServer tests each start an ASP.NET Core host, and the
+      # file-watching config providers allocate inotify instances; the container default (128) is
+      # exhausted once all unit-test projects run, surfacing as
+      # "The configured user limit (128) on the number of inotify instances has been reached".
+      - sysctl -w fs.inotify.max_user_instances=1024 || true
+      - sysctl -w fs.inotify.max_user_watches=524288 || true
       # Find and delete the global.json files that were added by CodeBuild. This causes issues when multiple SDKs are installed.
       - find / -type f -name 'global.json' -delete
       # The tests need .NET 3.1, 6, 8, 9 and 10. .NET6 is installed by default. .NET8 is added in the runtime-versions. .NET 3.1, 9 and 10 are installed manually.

From 1ec336b3f89dd0d317b32c7a90b35b4c8b32b338 Mon Sep 17 00:00:00 2001
From: Garrett Beatty <gcbeatty@amazon.com>
Date: Wed, 8 Jul 2026 12:29:42 -0400
Subject: [PATCH 3/7] Fail fast in run-unit-tests: stop at first failing
 project

Previously the script ran every unit-test project and only reported the
aggregate failures at the end. Exit immediately on the first failing
project for quicker feedback and to avoid spending CI time on later
projects once the build is already red.
---
 buildtools/run-unit-tests.ps1 | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/buildtools/run-unit-tests.ps1 b/buildtools/run-unit-tests.ps1
index 6b793221b..d30150e82 100644
--- a/buildtools/run-unit-tests.ps1
+++ b/buildtools/run-unit-tests.ps1
@@ -43,7 +43,6 @@ if (-not $projects)
 Write-Host "Running $($projects.Count) unit-test project(s):"
 $projects | ForEach-Object { Write-Host "  - $_" }
 
-$failed = @()
 foreach ($project in $projects)
 {
     $name = [System.IO.Path]::GetFileNameWithoutExtension($project)
@@ -52,18 +51,13 @@ foreach ($project in $projects)
     dotnet test -c $Configuration $project
     if ($LASTEXITCODE -ne 0)
     {
-        Write-Host "Tests failed for $name (exit $LASTEXITCODE)."
-        $failed += $name
+        # Fail fast: stop at the first failing project rather than running the rest. This gives
+        # quicker feedback and avoids spending CI time on later projects once the build is red.
+        Write-Host ""
+        Write-Host "Tests failed for $name (exit $LASTEXITCODE). Stopping without running the remaining project(s)."
+        exit 1
     }
 }
 
-if ($failed)
-{
-    Write-Host ""
-    Write-Host "The following unit-test project(s) failed:"
-    $failed | ForEach-Object { Write-Host "  - $_" }
-    exit 1
-}
-
 Write-Host ""
 Write-Host "All unit-test projects passed."

From 01dcd4d7434ecaa4b0129b9c990cec2dda524af4 Mon Sep 17 00:00:00 2001
From: Garrett Beatty <gcbeatty@amazon.com>
Date: Wed, 8 Jul 2026 12:46:49 -0400
Subject: [PATCH 4/7] Run unit tests in parallel; fix env-var test pollution it
 exposed

Rework run-unit-tests.ps1 to mirror run-integ-tests-parallel.ps1: build
all discovered projects once serially (avoids the shared ProjectReference
build-output race), then run 'dotnet test --no-build' in parallel with
streamed, project-prefixed output. All projects run (no short-circuit) so
every failure is surfaced in one pass, and failed projects' output is
reprinted as a clean block before exiting non-zero.

Running the projects concurrently exposed a pre-existing intra-assembly
flake in Amazon.Lambda.AspNetCoreServer.Hosting.Tests: many tests mutate
the process-global AWS_LAMBDA_FUNCTION_NAME env var, and xUnit parallelizes
collections within an assembly by default, so one test's value leaked into
AddAWSLambdaHosting_NotInLambda_DoesNotRegisterHostingOptions (which needs
it unset). Add AssemblyInfo.cs disabling in-assembly parallelization for
that project so the env-var-dependent tests run serially.
---
 .../AssemblyInfo.cs                           | 12 +++
 buildtools/run-unit-tests.ps1                 | 73 +++++++++++++++----
 2 files changed, 70 insertions(+), 15 deletions(-)
 create mode 100644 Libraries/test/Amazon.Lambda.AspNetCoreServer.Hosting.Tests/AssemblyInfo.cs

diff --git a/Libraries/test/Amazon.Lambda.AspNetCoreServer.Hosting.Tests/AssemblyInfo.cs b/Libraries/test/Amazon.Lambda.AspNetCoreServer.Hosting.Tests/AssemblyInfo.cs
new file mode 100644
index 000000000..5bc9f6b24
--- /dev/null
+++ b/Libraries/test/Amazon.Lambda.AspNetCoreServer.Hosting.Tests/AssemblyInfo.cs
@@ -0,0 +1,12 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+using Xunit;
+
+// Many tests in this assembly mutate the process-global AWS_LAMBDA_FUNCTION_NAME (and related)
+// environment variables via EnvironmentVariableHelper to simulate running inside/outside Lambda.
+// That state is shared across the whole process, so running test collections in parallel lets one
+// test's env var leak into another (e.g. AddAWSLambdaHosting_NotInLambda_DoesNotRegisterHostingOptions
+// intermittently sees a value set by a concurrently-running test and fails). Disable in-assembly
+// parallelization so these env-var-dependent tests run one at a time.
+[assembly: CollectionBehavior(DisableTestParallelization = true)]
diff --git a/buildtools/run-unit-tests.ps1 b/buildtools/run-unit-tests.ps1
index d30150e82..ee3450dd2 100644
--- a/buildtools/run-unit-tests.ps1
+++ b/buildtools/run-unit-tests.ps1
@@ -1,8 +1,8 @@
 #!/usr/bin/env pwsh
-# Discovers and runs every unit-test project under Libraries/test, so new test projects are picked up
-# automatically instead of having to be added to a hardcoded list in build.proj (which is how projects
-# such as Amazon.Lambda.AspNetCoreServer.Test, Amazon.Lambda.Core.Tests and EventsTests.NET8 silently
-# stopped being run in CI).
+# Discovers and runs every unit-test project under Libraries/test in parallel, so new test projects
+# are picked up automatically instead of having to be added to a hardcoded list in build.proj (which
+# is how projects such as Amazon.Lambda.AspNetCoreServer.Test, Amazon.Lambda.Core.Tests and
+# EventsTests.NET8 silently stopped being run in CI).
 #
 # A project is treated as a unit-test project when its .csproj references Microsoft.NET.Test.Sdk (or
 # sets <IsTestProject>true</IsTestProject>). Naming is NOT used because the test projects in this repo
@@ -13,12 +13,17 @@
 # Integration test projects (*.IntegrationTests.csproj) are excluded here because they run in a
 # separate phase via run-integ-tests-parallel.ps1 (they deploy real AWS resources).
 #
-# The script exits non-zero if any project fails, listing which ones.
+# Mirrors run-integ-tests-parallel.ps1: each project's output is streamed live, prefixed with the
+# project name so interleaved logs stay attributable, and failed projects get their full output
+# reprinted as one clean block at the end. The script runs all projects (it does not short-circuit)
+# so every failure is surfaced in a single pass, then exits non-zero listing which projects failed.
 
 param(
     [string]$Configuration = "Release",
     # Directory to search for unit-test projects (defaults to the Libraries/test tree).
-    [string]$TestRoot = (Join-Path $PSScriptRoot ".." "Libraries" "test")
+    [string]$TestRoot = (Join-Path $PSScriptRoot ".." "Libraries" "test"),
+    # Upper bound on how many projects run at once.
+    [int]$ThrottleLimit = 5
 )
 
 $ErrorActionPreference = 'Stop'
@@ -40,24 +45,62 @@ if (-not $projects)
     exit 0
 }
 
-Write-Host "Running $($projects.Count) unit-test project(s):"
+Write-Host "Running $($projects.Count) unit-test project(s) in parallel (throttle limit $ThrottleLimit):"
 $projects | ForEach-Object { Write-Host "  - $_" }
 
+# Build all projects ONCE, up front, before the parallel phase. The test projects share
+# ProjectReferences (e.g. TestWebApp, TestUtilities); running `dotnet test` on them concurrently
+# each rebuilt those shared projects, racing on their build output (e.g. a .deps.json "being used by
+# another process" / GenerateDepsFile failure). Building once here lets the parallel runs use
+# --no-build so they only execute tests, never rebuild shared output.
+Write-Host "Building all unit-test projects once before running in parallel..."
 foreach ($project in $projects)
 {
-    $name = [System.IO.Path]::GetFileNameWithoutExtension($project)
-    Write-Host ""
-    Write-Host "==================== $name ===================="
-    dotnet test -c $Configuration $project
+    dotnet build -c $Configuration $project
     if ($LASTEXITCODE -ne 0)
     {
-        # Fail fast: stop at the first failing project rather than running the rest. This gives
-        # quicker feedback and avoids spending CI time on later projects once the build is red.
-        Write-Host ""
-        Write-Host "Tests failed for $name (exit $LASTEXITCODE). Stopping without running the remaining project(s)."
+        Write-Host "Build failed for $project (exit $LASTEXITCODE)."
         exit 1
     }
 }
 
+$results = $projects | ForEach-Object -ThrottleLimit $ThrottleLimit -Parallel {
+    $project = $_
+    $name = [System.IO.Path]::GetFileNameWithoutExtension($project)
+    $lines = [System.Collections.Generic.List[string]]::new()
+    # --no-build: everything was built serially above, so the parallel runs only execute tests and
+    # never rebuild shared project output. 2>&1 folds stderr into the stream; each line is emitted as
+    # it arrives, prefixed with the project name, so progress is visible.
+    dotnet test -c $using:Configuration --no-build --logger "console;verbosity=detailed" $project 2>&1 |
+        ForEach-Object {
+            $line = $_.ToString()
+            $lines.Add($line)
+            Write-Host "[$name] $line"
+        }
+    [PSCustomObject]@{
+        Name     = $name
+        Project  = $project
+        ExitCode = $LASTEXITCODE
+        Output   = ($lines -join [System.Environment]::NewLine)
+    }
+}
+
+# Reprint each failed project's output as one clean, un-interleaved block for easier diagnosis.
+$failed = $results | Where-Object { $_.ExitCode -ne 0 }
+foreach ($result in $failed)
+{
+    Write-Host ""
+    Write-Host "==================== FAILED: $($result.Name) (exit $($result.ExitCode)) ===================="
+    Write-Host $result.Output
+}
+
+if ($failed)
+{
+    Write-Host ""
+    Write-Host "The following unit-test project(s) failed:"
+    $failed | ForEach-Object { Write-Host "  - $($_.Name)" }
+    exit 1
+}
+
 Write-Host ""
 Write-Host "All unit-test projects passed."

From d63b7e9b4315a777c33f674bfbdb49c4b69bc2e8 Mon Sep 17 00:00:00 2001
From: Garrett Beatty <gcbeatty@amazon.com>
Date: Wed, 8 Jul 2026 13:14:08 -0400
Subject: [PATCH 5/7] Fix RuntimeSupport HandlerTests flake exposed by parallel
 unit-test runs

PositiveHandlerTestsAsync intermittently failed (~1 in 5 under load) with
'Can't find method name in console text'. Two pre-existing issues, both
aggravated by concurrency:

- ExecHandlerAsync/TestHandlerFailAsync point a static logger action on
  the shared Amazon.Lambda.Core assembly at a per-invocation StringWriter,
  and LambdaBootstrap's background RunAsync writes through it. When xUnit
  runs collections in parallel, one test's logging can land in another's
  writer. Add AssemblyInfo.cs disabling in-assembly parallelization (same
  approach as Hosting.Tests); some classes already shared a [Collection]
  but that did not cover the whole assembly.
- The InvokeAsync/exception waiter loops busy-spun on a field with no
  yield, pinning a core and starving the bootstrap thread under load.
  Replace the tight spins with await Task.Delay(1).

Verified stable across 6 consecutive full-suite runs (was ~1 in 5).
---
 .../AssemblyInfo.cs                                 | 13 +++++++++++++
 .../HandlerTests.cs                                 | 10 +++++++++-
 2 files changed, 22 insertions(+), 1 deletion(-)
 create mode 100644 Libraries/test/Amazon.Lambda.RuntimeSupport.Tests/Amazon.Lambda.RuntimeSupport.UnitTests/AssemblyInfo.cs

diff --git a/Libraries/test/Amazon.Lambda.RuntimeSupport.Tests/Amazon.Lambda.RuntimeSupport.UnitTests/AssemblyInfo.cs b/Libraries/test/Amazon.Lambda.RuntimeSupport.Tests/Amazon.Lambda.RuntimeSupport.UnitTests/AssemblyInfo.cs
new file mode 100644
index 000000000..4b6f50b5b
--- /dev/null
+++ b/Libraries/test/Amazon.Lambda.RuntimeSupport.Tests/Amazon.Lambda.RuntimeSupport.UnitTests/AssemblyInfo.cs
@@ -0,0 +1,13 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+using Xunit;
+
+// Tests in this assembly share process-global state: SetCustomerLoggerLogAction points a static
+// field on the loaded Amazon.Lambda.Core assembly at a per-invocation StringWriter, and the handler
+// tests drive LambdaBootstrap whose background RunAsync work writes through that static action. When
+// test collections run in parallel, one test's logging can be captured by another's writer (observed
+// intermittently under load as "Can't find method name in console text" in PositiveHandlerTestsAsync).
+// Some classes already share a [Collection] to serialize relative to each other, but that does not
+// cover the rest of the assembly, so disable in-assembly parallelization outright.
+[assembly: CollectionBehavior(DisableTestParallelization = true)]
diff --git a/Libraries/test/Amazon.Lambda.RuntimeSupport.Tests/Amazon.Lambda.RuntimeSupport.UnitTests/HandlerTests.cs b/Libraries/test/Amazon.Lambda.RuntimeSupport.Tests/Amazon.Lambda.RuntimeSupport.UnitTests/HandlerTests.cs
index dacd01f87..fe5c952ae 100644
--- a/Libraries/test/Amazon.Lambda.RuntimeSupport.Tests/Amazon.Lambda.RuntimeSupport.UnitTests/HandlerTests.cs
+++ b/Libraries/test/Amazon.Lambda.RuntimeSupport.Tests/Amazon.Lambda.RuntimeSupport.UnitTests/HandlerTests.cs
@@ -257,11 +257,15 @@ private async Task<Exception> TestHandlerFailAsync(string handler, string expect
 
             using (var cancellationTokenSource = new CancellationTokenSource())
             {
-                var exceptionWaiterTask = Task.Run(() =>
+                var exceptionWaiterTask = Task.Run(async () =>
                 {
                     _output.WriteLine($"Waiting for an exception.");
+                    // Yield between checks instead of a tight spin. A busy-wait pins a CPU core and,
+                    // under load (e.g. when several test projects run in parallel), starves the
+                    // bootstrap thread that sets LastRecordedException, causing the test to flake.
                     while (testRuntimeApiClient.LastRecordedException == null)
                     {
+                        await Task.Delay(1);
                     }
                     _output.WriteLine($"Exception available.");
                     cancellationTokenSource.Cancel();
@@ -292,8 +296,12 @@ private async Task<string> InvokeAsync(LambdaBootstrap bootstrap, string dataIn,
                 var exceptionWaiterTask = Task.Run(async () =>
                 {
                     _output.WriteLine($"Waiting for an output.");
+                    // Yield between checks instead of a tight spin. A busy-wait pins a CPU core and,
+                    // under load (e.g. when several test projects run in parallel), starves the
+                    // bootstrap thread that sets LastOutputStream, causing the handler test to flake.
                     while (testRuntimeApiClient.LastOutputStream == null)
                     {
+                        await Task.Delay(1);
                     }
                     _output.WriteLine($"Output available.");
                     cancellationTokenSource.Cancel();

From 9ae885ec12ce5910949b48b9c3cbbdd2fdc3eb87 Mon Sep 17 00:00:00 2001
From: Garrett Beatty <gcbeatty@amazon.com>
Date: Wed, 8 Jul 2026 16:20:05 -0400
Subject: [PATCH 6/7] Fix AspNetCoreServer.Test CI hang from leaked SnapStart
 bootstrap

The last CI run's unit tests all passed but the build hung ~1h50m after
they finished, until the 2-hour AWS credential expired ('security token
expired'). Amazon.Lambda.AspNetCoreServer.Test was the one project that
never printed a completion line: TestSnapStartInitialization started a
LambdaBootstrap polling loop against a dead endpoint (localhost:123) as
fire-and-forget (_ = bootstrap.RunAsync(cts.Token)). After the assert the
leaked loop kept retrying (the log shows GET /api/SnapStart repeating), so
under parallel load dotnet test never exited.

- Keep the RunAsync task, assert before teardown, then cancel and await
  the task so no background work outlives the test. The dead-endpoint loop
  surfaces OperationCanceledException or HttpRequestException on teardown;
  both are expected and swallowed.
- Add AssemblyInfo.cs disabling in-assembly parallelization (same approach
  as Hosting.Tests and RuntimeSupport.UnitTests): this project shares the
  process-global AWS_LAMBDA_* env vars and the static SnapStartController
  .Invoked flag across tests.

Verified 193/193 on net8.0 and net10.0, stable across repeated runs, with
no hang.
---
 .../AssemblyInfo.cs                           | 12 ++++++++
 .../TestApiGatewayHttpApiV2Calls.cs           | 30 ++++++++++++++++---
 2 files changed, 38 insertions(+), 4 deletions(-)
 create mode 100644 Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/AssemblyInfo.cs

diff --git a/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/AssemblyInfo.cs b/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/AssemblyInfo.cs
new file mode 100644
index 000000000..6b6d83099
--- /dev/null
+++ b/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/AssemblyInfo.cs
@@ -0,0 +1,12 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+using Xunit;
+
+// Tests in this assembly share process-global state: TestSnapStartInitialization sets the
+// AWS_LAMBDA_FUNCTION_NAME / AWS_LAMBDA_INITIALIZATION_TYPE environment variables and drives a real
+// LambdaBootstrap polling loop, and SnapStartController.Invoked is a static flag. Running test
+// collections in parallel lets that background bootstrap and the env-var state interfere with other
+// tests (observed in CI as the whole dotnet test process hanging until credentials expired). Disable
+// in-assembly parallelization so these tests run one at a time.
+[assembly: CollectionBehavior(DisableTestParallelization = true)]
diff --git a/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/TestApiGatewayHttpApiV2Calls.cs b/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/TestApiGatewayHttpApiV2Calls.cs
index b28f82cc2..2c55f524e 100644
--- a/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/TestApiGatewayHttpApiV2Calls.cs
+++ b/Libraries/test/Amazon.Lambda.AspNetCoreServer.Test/TestApiGatewayHttpApiV2Calls.cs
@@ -2,6 +2,7 @@
 using System.IO;
 using System.Linq;
 using System.Net;
+using System.Net.Http;
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
@@ -299,15 +300,36 @@ public async Task TestSnapStartInitialization()
                     new DefaultLambdaJsonSerializer())
                 .ConfigureOptions(opt => opt.RuntimeApiEndpoint = "localhost:123")
                 .Build();
-            
-            _ = bootstrap.RunAsync(cts.Token);
+
+            // Keep the task so we can tear the bootstrap down before the test returns. Previously this
+            // was fire-and-forget (_ = bootstrap.RunAsync(...)); the polling loop (against a dead
+            // endpoint) then kept running after the assert, and under parallel CI load the leaked loop
+            // hung the whole test process until the credentials expired ~2h later.
+            var bootstrapTask = bootstrap.RunAsync(cts.Token);
 
             // allow some time for Bootstrap to initialize in background
-            await Task.Delay(100, cts.Token);
+            await Task.Delay(100);
+
+            // Assert what the test is actually about (the SnapStart before-snapshot hook ran) before
+            // tearing down, so a teardown exception can't mask the real result.
+            Assert.True(SnapStartController.Invoked);
 
             await cts.CancelAsync();
 
-            Assert.True(SnapStartController.Invoked);
+            // Wait for the polling loop to actually stop so no background work outlives the test. The
+            // bootstrap runs against a dead endpoint (localhost:123), so its loop either observes the
+            // cancellation (OperationCanceledException) or throws the connection failure it was
+            // retrying (HttpRequestException); both are expected teardown noise, not test failures.
+            try
+            {
+                await bootstrapTask;
+            }
+            catch (OperationCanceledException)
+            {
+            }
+            catch (HttpRequestException)
+            {
+            }
         }
 
         private async Task<APIGatewayHttpApiV2ProxyResponse> InvokeAPIGatewayRequest(string fileName, bool configureApiToReturnExceptionDetail = false)

From d1bcd3a9ffb1934c877d951268eadd1cd2101ed5 Mon Sep 17 00:00:00 2001
From: Garrett Beatty <gcbeatty@amazon.com>
Date: Thu, 9 Jul 2026 11:00:24 -0400
Subject: [PATCH 7/7] Run AspNetCoreServer.Test serially, not in the parallel
 unit-test pool

Two CI runs hung ~1h50m (until the 2-hour credential expired) inside
Amazon.Lambda.AspNetCoreServer.Test. Its TestSnapStartInitialization drives
SnapStart init, which invokes the before-snapshot hooks accumulated in the
process-global Amazon.Lambda.Core.SnapshotRestore registry by every test's
function constructor; each hook runs in-process ASP.NET requests. Under the
CPU/host contention of the parallel pool that work deadlocked. The project
passes reliably on its own (193/193, ~8s), so run it serially after the
parallel pool instead of concurrently.

run-unit-tests.ps1 now splits discovered projects into a parallel pool and
a serial list (matched by file name); all are built once up front, the pool
runs with --no-build, then the serial projects run one at a time. Verified
locally: AspNetCoreServer.Test passes serially with no hang.
---
 buildtools/run-unit-tests.ps1 | 96 +++++++++++++++++++++++++----------
 1 file changed, 69 insertions(+), 27 deletions(-)

diff --git a/buildtools/run-unit-tests.ps1 b/buildtools/run-unit-tests.ps1
index ee3450dd2..340eab525 100644
--- a/buildtools/run-unit-tests.ps1
+++ b/buildtools/run-unit-tests.ps1
@@ -15,8 +15,8 @@
 #
 # Mirrors run-integ-tests-parallel.ps1: each project's output is streamed live, prefixed with the
 # project name so interleaved logs stay attributable, and failed projects get their full output
-# reprinted as one clean block at the end. The script runs all projects (it does not short-circuit)
-# so every failure is surfaced in a single pass, then exits non-zero listing which projects failed.
+# reprinted as one clean block at the end. All projects run (it does not short-circuit) so every
+# failure is surfaced in a single pass, then it exits non-zero listing which projects failed.
 
 param(
     [string]$Configuration = "Release",
@@ -28,8 +28,17 @@ param(
 
 $ErrorActionPreference = 'Stop'
 
+# Projects that must NOT run concurrently with the parallel pool. Amazon.Lambda.AspNetCoreServer.Test
+# drives SnapStart initialization that invokes before-snapshot hooks accumulated in a process-global
+# registry, each running in-process ASP.NET requests; under the CPU/host contention of the parallel
+# pool that work deadlocked and hung CI until the credentials expired. It passes fine on its own, so
+# it is run serially, after the parallel pool. Matched on the file name.
+$serialProjectNames = @(
+    'Amazon.Lambda.AspNetCoreServer.Test.csproj'
+)
+
 # Discover unit-test projects: reference the test SDK / IsTestProject, but are not integration tests.
-$projects = Get-ChildItem -Path $TestRoot -Recurse -Filter "*.csproj" |
+$allProjects = Get-ChildItem -Path $TestRoot -Recurse -Filter "*.csproj" |
     Where-Object { $_.Name -notlike "*.IntegrationTests.csproj" } |
     Where-Object {
         $content = Get-Content -Raw -LiteralPath $_.FullName
@@ -39,22 +48,31 @@ $projects = Get-ChildItem -Path $TestRoot -Recurse -Filter "*.csproj" |
     Select-Object -ExpandProperty FullName |
     Sort-Object
 
-if (-not $projects)
+if (-not $allProjects)
 {
     Write-Host "No unit-test projects found under '$TestRoot'."
     exit 0
 }
 
-Write-Host "Running $($projects.Count) unit-test project(s) in parallel (throttle limit $ThrottleLimit):"
-$projects | ForEach-Object { Write-Host "  - $_" }
+$serialProjects = $allProjects | Where-Object { $serialProjectNames -contains [System.IO.Path]::GetFileName($_) }
+$parallelProjects = $allProjects | Where-Object { $serialProjectNames -notcontains [System.IO.Path]::GetFileName($_) }
+
+Write-Host "Discovered $($allProjects.Count) unit-test project(s):"
+Write-Host "  Parallel (throttle limit $ThrottleLimit):"
+$parallelProjects | ForEach-Object { Write-Host "    - $_" }
+if ($serialProjects)
+{
+    Write-Host "  Serial (run one at a time, after the parallel pool):"
+    $serialProjects | ForEach-Object { Write-Host "    - $_" }
+}
 
 # Build all projects ONCE, up front, before the parallel phase. The test projects share
 # ProjectReferences (e.g. TestWebApp, TestUtilities); running `dotnet test` on them concurrently
 # each rebuilt those shared projects, racing on their build output (e.g. a .deps.json "being used by
-# another process" / GenerateDepsFile failure). Building once here lets the parallel runs use
-# --no-build so they only execute tests, never rebuild shared output.
-Write-Host "Building all unit-test projects once before running in parallel..."
-foreach ($project in $projects)
+# another process" / GenerateDepsFile failure). Building once here lets the runs use --no-build so
+# they only execute tests, never rebuild shared output.
+Write-Host "Building all unit-test projects once before running..."
+foreach ($project in $allProjects)
 {
     dotnet build -c $Configuration $project
     if ($LASTEXITCODE -ne 0)
@@ -64,24 +82,45 @@ foreach ($project in $projects)
     }
 }
 
-$results = $projects | ForEach-Object -ThrottleLimit $ThrottleLimit -Parallel {
-    $project = $_
-    $name = [System.IO.Path]::GetFileNameWithoutExtension($project)
-    $lines = [System.Collections.Generic.List[string]]::new()
-    # --no-build: everything was built serially above, so the parallel runs only execute tests and
-    # never rebuild shared project output. 2>&1 folds stderr into the stream; each line is emitted as
-    # it arrives, prefixed with the project name, so progress is visible.
-    dotnet test -c $using:Configuration --no-build --logger "console;verbosity=detailed" $project 2>&1 |
-        ForEach-Object {
-            $line = $_.ToString()
-            $lines.Add($line)
-            Write-Host "[$name] $line"
+$results = @()
+
+if ($parallelProjects)
+{
+    $results += $parallelProjects | ForEach-Object -ThrottleLimit $ThrottleLimit -Parallel {
+        $project = $_
+        $name = [System.IO.Path]::GetFileNameWithoutExtension($project)
+        $lines = [System.Collections.Generic.List[string]]::new()
+        # --no-build: everything was built serially above, so the runs only execute tests and never
+        # rebuild shared project output. 2>&1 folds stderr into the stream; each line is emitted as it
+        # arrives, prefixed with the project name, so progress is visible.
+        dotnet test -c $using:Configuration --no-build --logger "console;verbosity=detailed" $project 2>&1 |
+            ForEach-Object {
+                $line = $_.ToString()
+                $lines.Add($line)
+                Write-Host "[$name] $line"
+            }
+        [PSCustomObject]@{
+            Name     = $name
+            Project  = $project
+            ExitCode = $LASTEXITCODE
+            Output   = ($lines -join [System.Environment]::NewLine)
         }
-    [PSCustomObject]@{
+    }
+}
+
+# Run the serial projects one at a time, after the parallel pool has finished, so their process-global
+# behavior can't interfere with (or be starved by) the concurrent runs.
+foreach ($project in $serialProjects)
+{
+    $name = [System.IO.Path]::GetFileNameWithoutExtension($project)
+    Write-Host ""
+    Write-Host "==================== $name (serial) ===================="
+    dotnet test -c $Configuration --no-build --logger "console;verbosity=detailed" $project
+    $results += [PSCustomObject]@{
         Name     = $name
         Project  = $project
         ExitCode = $LASTEXITCODE
-        Output   = ($lines -join [System.Environment]::NewLine)
+        Output   = ""
     }
 }
 
@@ -89,9 +128,12 @@ $results = $projects | ForEach-Object -ThrottleLimit $ThrottleLimit -Parallel {
 $failed = $results | Where-Object { $_.ExitCode -ne 0 }
 foreach ($result in $failed)
 {
-    Write-Host ""
-    Write-Host "==================== FAILED: $($result.Name) (exit $($result.ExitCode)) ===================="
-    Write-Host $result.Output
+    if ($result.Output)
+    {
+        Write-Host ""
+        Write-Host "==================== FAILED: $($result.Name) (exit $($result.ExitCode)) ===================="
+        Write-Host $result.Output
+    }
 }
 
 if ($failed)