Add instrumented xUnit DLLs and diagnostic tracing for RunTest hang

TEMPORARY diagnostic instrumentation to capture what happens during the
intermittent xUnit v3 RunTest hang where finished TCS is never signaled.

Changes:
- Instrumented xunit.v3.core.dll with trace points in TestRunner.RunTest:
  before/after EC.Run, runTest entry, pre-try completion, test invocation,
  and finished signaling. Also moves pre-try code inside try block as a
  structural fix.
- DiagnosticExceptionTracing.cs module initializer hooking
  UnhandledException and UnobservedTaskException for additional context.
- Both test csproj files copy instrumented DLLs post-build via
  ReplaceXunitWithInstrumented target.
- CI workflow collects xunit-runtest-diag.log as test artifact.

All instrumentation writes to xunit-runtest-diag.log and stderr.
Remove once the root cause is identified.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: ericstj

.github/workflows/ci-build-test.yml

@@ -84,7 +84,9 @@ jobs:
       uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
       with:
         name: testresults-${{ matrix.os }}-${{ matrix.configuration }}
-        path: artifacts/testresults/**
+        path: |
+          artifacts/testresults/**
+          artifacts/bin/*Tests/*/xunit-runtest-diag.log
 
   publish-coverage:
     if: github.actor != 'dependabot[bot]'

tests/Common/InstrumentedXunit/xunit.v3.common.dll

@@ -0,0 +1,56 @@
+#if NET
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
+
+namespace ModelContextProtocol.Tests.Utils;
+
+/// <summary>
+/// Module initializer that hooks global exception events to diagnose async void crashes
+/// and other unobserved exceptions during test execution. This is intended to capture
+/// evidence for intermittent xUnit test runner hangs where an async void method's exception
+/// may go unobserved, preventing a TaskCompletionSource from being signaled.
+/// </summary>
+internal static class DiagnosticExceptionTracing
+{
+    private static int s_initialized;
+    private static int s_unhandledExceptionCount;
+    private static int s_unobservedTaskExceptionCount;
+
+    [ModuleInitializer]
+    internal static void Initialize()
+    {
+        if (Interlocked.Exchange(ref s_initialized, 1) != 0)
+        {
+            return;
+        }
+
+        // This fires when an async void method throws and the exception propagates to the
+        // thread pool. If the xUnit runTest async void function throws before its try block,
+        // we'll see it here. Note: this typically terminates the process, so seeing output
+        // from this handler is strong evidence of the suspected bug.
+        AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
+        {
+            int count = Interlocked.Increment(ref s_unhandledExceptionCount);
+            string terminating = e.IsTerminating ? "TERMINATING" : "non-terminating";
+            Console.Error.WriteLine($"[DiagnosticExceptionTracing] UnhandledException #{count} ({terminating}): {e.ExceptionObject}");
+            Console.Error.Flush();
+
+            // Also write to Trace in case stderr is not captured
+            Trace.WriteLine($"[DiagnosticExceptionTracing] UnhandledException #{count} ({terminating}): {e.ExceptionObject}");
+        };
+
+        // This fires when a Task's exception is never observed (no await, no Wait, no Result).
+        // Could indicate fire-and-forget tasks with silent failures.
+        TaskScheduler.UnobservedTaskException += (sender, e) =>
+        {
+            int count = Interlocked.Increment(ref s_unobservedTaskExceptionCount);
+            Console.Error.WriteLine($"[DiagnosticExceptionTracing] UnobservedTaskException #{count}: {e.Exception}");
+            Console.Error.Flush();
+        };
+
+        Console.Error.WriteLine("[DiagnosticExceptionTracing] Exception tracing hooks installed");
+        Console.Error.Flush();
+    }
+}
+#endif

tests/Common/InstrumentedXunit/xunit.v3.core.dll

@@ -62,4 +62,15 @@
     <ProjectReference Include="..\ModelContextProtocol.ConformanceServer\ModelContextProtocol.ConformanceServer.csproj" />
   </ItemGroup>
 
+  <!-- TEMPORARY: Replace xUnit DLLs with instrumented versions that add tracing to
+       TestRunner.RunTest to diagnose intermittent hang where finished TCS is never signaled.
+       Remove this target once the root cause is identified. -->
+  <Target Name="ReplaceXunitWithInstrumented" AfterTargets="Build"
+          Condition="Exists('$(MSBuildThisFileDirectory)..\Common\InstrumentedXunit\xunit.v3.core.dll')">
+    <Copy SourceFiles="$(MSBuildThisFileDirectory)..\Common\InstrumentedXunit\xunit.v3.core.dll"
+          DestinationFolder="$(OutputPath)" OverwriteReadOnlyFiles="true" SkipUnchangedFiles="false" />
+    <Copy SourceFiles="$(MSBuildThisFileDirectory)..\Common\InstrumentedXunit\xunit.v3.common.dll"
+          DestinationFolder="$(OutputPath)" OverwriteReadOnlyFiles="true" SkipUnchangedFiles="false" />
+  </Target>
+
 </Project>

tests/Common/Utils/DiagnosticExceptionTracing.cs

@@ -98,4 +98,15 @@
     </Content>
   </ItemGroup>
 
+  <!-- TEMPORARY: Replace xUnit DLLs with instrumented versions that add tracing to
+       TestRunner.RunTest to diagnose intermittent hang where finished TCS is never signaled.
+       Remove this target once the root cause is identified. -->
+  <Target Name="ReplaceXunitWithInstrumented" AfterTargets="Build"
+          Condition="Exists('$(MSBuildThisFileDirectory)..\Common\InstrumentedXunit\xunit.v3.core.dll')">
+    <Copy SourceFiles="$(MSBuildThisFileDirectory)..\Common\InstrumentedXunit\xunit.v3.core.dll"
+          DestinationFolder="$(OutputPath)" OverwriteReadOnlyFiles="true" SkipUnchangedFiles="false" />
+    <Copy SourceFiles="$(MSBuildThisFileDirectory)..\Common\InstrumentedXunit\xunit.v3.common.dll"
+          DestinationFolder="$(OutputPath)" OverwriteReadOnlyFiles="true" SkipUnchangedFiles="false" />
+  </Target>
+
 </Project>