Simulate hag condition

Author: vmoroz

.ado/jobs/e2e-test.yml

@@ -9,17 +9,25 @@ parameters:
   - name: AgentPool
     type: object
   - name: simulateCrashForTesting
+    type: boolean
+    default: false
+    # When true, drops a sentinel file that RNTesterApp-Fabric reads on startup
+    # and uses to trigger a deliberate access violation. Used to validate that
+    # the crash-dump collection path (in-process minidump writer + artifact
+    # publish) actually produces a usable .dmp in CI. Already validated on this
+    # branch — leaving the mechanism in place but disabled by default.
+  - name: simulateHangForTesting
     # !!! TEMPORARY DEFAULT: true !!!
     # This branch (PR/0.84-fix-e2e-test-flakiness) flips the default to true so
-    # that PR validation actually exercises the crash-dump-collection path end
-    # to end. MUST be flipped back to false before merging anywhere — with it
-    # enabled the E2E app crashes on startup and no real tests run.
+    # that PR validation exercises the hang-dump capture path end to end.
+    # MUST be flipped back to false before merging anywhere — with it enabled
+    # the E2E app deliberately hangs and the test step always fails.
     type: boolean
     default: true
-    # When true, drops a sentinel file that RNTesterApp-Fabric reads on startup
-    # and uses to trigger a deliberate access violation. Used to validate that
-    # the crash-dump collection path (WER LocalDumps + artifact publish)
-    # actually produces a usable .dmp in CI.
+    # When true, sets the env var RNW_SIMULATE_HANG=1 on the `yarn e2etest`
+    # step. The HangSimulationTest test then invokes the `HangForTesting`
+    # automation command, which jams the app's UI thread; the post-failure
+    # ProcDump step captures a full dump of the still-alive hung process.
   - name: buildMatrix
     type: object
     default:
@@ -109,6 +117,16 @@ jobs:
                   }
                 displayName: Arm crash-simulation sentinel (TEST ONLY)
 
+            # Test-only: arm the hang-simulation env var, which switches on
+            # the HangSimulationTest.test.ts test. That test invokes the
+            # `HangForTesting` automation command, jamming the app's UI thread
+            # so the post-failure ProcDump path captures a hang dump.
+            - ${{ if eq(parameters.simulateHangForTesting, true) }}:
+              - pwsh: |
+                  Write-Host "##vso[task.setvariable variable=RNW_SIMULATE_HANG]1"
+                  Write-Host "Hang simulation armed (RNW_SIMULATE_HANG=1)"
+                displayName: Arm hang-simulation env var (TEST ONLY)
+
             # Test-only: directly launch the built exe (bypassing WinAppDriver
             # and the packaged-app activation path) with the flag armed, so we
             # can isolate whether WER writes a dump at all. If this produces a
@@ -144,12 +162,14 @@ jobs:
               displayName: yarn e2etest
               workingDirectory: packages/e2e-test-app-fabric
               # Time to wait for this task to complete before the server kills it.
-              # When simulateCrashForTesting=true the app crashes immediately on startup, so a
-              # 10-minute wait is just dead time. Drop to 2 min during simulation. REVERT this
-              # to a single `timeoutInMinutes: 10` when removing the simulation parameter.
-              ${{ if eq(parameters.simulateCrashForTesting, true) }}:
+              # When EITHER simulation is on the test step is guaranteed to fail (crash
+              # exits the app immediately; hang jams the UI thread). The ADO step timeout
+              # is then the primary cutoff that lets the post-failure capture step run, so
+              # 2 minutes is plenty. REVERT this whole conditional block to a single line
+              # `timeoutInMinutes: 10` when removing both simulation parameters.
+              ${{ if or(eq(parameters.simulateCrashForTesting, true), eq(parameters.simulateHangForTesting, true)) }}:
                 timeoutInMinutes: 2
-              ${{ if not(eq(parameters.simulateCrashForTesting, true)) }}:
+              ${{ if and(not(eq(parameters.simulateCrashForTesting, true)), not(eq(parameters.simulateHangForTesting, true))) }}:
                 timeoutInMinutes: 10
 
             # Always disarm the crash sentinel so it cannot leak to a rerun on

packages/e2e-test-app-fabric/test/HangSimulationTest.test.ts

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * @format
+ */
+
+// Test-only: validates the hang-dump capture path of the E2E pipeline.
+//
+// Normally skipped. When the pipeline parameter `simulateHangForTesting=true`
+// (see .ado/jobs/e2e-test.yml), the env var RNW_SIMULATE_HANG=1 is set on the
+// `yarn e2etest` step, this test runs, and it tells the app to jam its UI
+// thread via the `HangForTesting` automation command. After the resulting jest
+// timeout, the post-failure ProcDump step in the pipeline captures a full
+// memory dump of the still-alive packaged-app process.
+//
+// Must be flipped off (along with the pipeline parameter) before merging.
+
+import {app} from '@react-native-windows/automation';
+import {AutomationClient} from '@react-native-windows/automation-channel';
+
+declare const automationClient: AutomationClient | undefined;
+
+const shouldRun = process.env.RNW_SIMULATE_HANG === '1';
+
+(shouldRun ? describe : describe.skip)('Hang Simulation (TEST ONLY)', () => {
+  test('jams the UI thread until the test times out', async () => {
+    if (!automationClient) {
+      throw new Error('RPC client is not enabled');
+    }
+
+    // Asks the app to Post a Sleep(INFINITE) onto its UI dispatcher. The
+    // command itself returns quickly; the UI thread is jammed on the next
+    // queued work item, so any subsequent UIA query will block.
+    await automationClient.invoke('HangForTesting', {});
+
+    // Touch the UI to surface the hang to jest. This call would normally
+    // return quickly; with the UI thread jammed it blocks until jest's
+    // testTimeout fires.
+    const anyElement = await app.findElementByTestID('components-tab');
+    await anyElement.waitForDisplayed({timeout: 60000});
+  });
+});
+
+export {};

packages/e2e-test-app-fabric/windows/RNTesterApp-Fabric/RNTesterApp-Fabric.cpp

@@ -40,6 +40,7 @@ winrt::Microsoft::ReactNative::IReactContext global_reactContext{nullptr};
 // Forward declarations of functions included in this code module:
 winrt::Windows::Data::Json::JsonObject ListErrors(winrt::Windows::Data::Json::JsonValue payload);
 winrt::Windows::Data::Json::JsonObject DumpVisualTree(winrt::Windows::Data::Json::JsonValue payload);
+winrt::Windows::Data::Json::JsonObject HangForTesting(winrt::Windows::Data::Json::JsonValue payload);
 winrt::Windows::Foundation::IAsyncAction LoopServer(winrt::AutomationChannel::Server &server);
 
 // Create and configure the ReactNativeHost
@@ -242,6 +243,26 @@ static void MaybeSimulateCrashForTesting() {
   *reinterpret_cast<volatile int *>(nullptr) = 0xC0FFEE;
 }
 
+// Test-only: when invoked over the automation channel, jam the UI thread
+// forever. Used by the E2E pipeline (see .ado/jobs/e2e-test.yml
+// `simulateHangForTesting` parameter) to validate that the post-failure
+// ProcDump capture step actually produces a usable dump of a hung app.
+//
+// We Post the sleep onto the UI dispatcher rather than blocking inline so the
+// channel handler returns a normal response to the test client — that's the
+// realistic scenario (the app appears to acknowledge a request, then locks up
+// on the next UI-thread work item, exactly like a deadlock in production).
+winrt::Windows::Data::Json::JsonObject HangForTesting(winrt::Windows::Data::Json::JsonValue /*payload*/) {
+  if (global_reactContext) {
+    global_reactContext.UIDispatcher().Post([]() { ::Sleep(INFINITE); });
+  } else {
+    // Fallback: hang the channel-loop thread itself. Less realistic but still
+    // produces a hung process that the post-failure ProcDump path can capture.
+    ::Sleep(INFINITE);
+  }
+  return {};
+}
+
 _Use_decl_annotations_ int CALLBACK
 WinMain(HINSTANCE /* instance */, HINSTANCE, PSTR /* commandLine */, int /* showCmd */) {
   // Install our in-process crash handler before anything else can crash. This
@@ -301,6 +322,7 @@ WinMain(HINSTANCE /* instance */, HINSTANCE, PSTR /* commandLine */, int /* show
   winrt::AutomationChannel::CommandHandler handler;
   handler.BindOperation(L"DumpVisualTree", DumpVisualTree);
   handler.BindOperation(L"ListErrors", ListErrors);
+  handler.BindOperation(L"HangForTesting", HangForTesting);
   global_rootView = reactNativeWindow.ReactNativeIsland();
 
   auto server = winrt::AutomationChannel::Server(handler);