test(ios-runner): cover alert activation against an app that never idles

Reverting the alert path to a plain `activateElement` kept every test green, so the #2546 failure had
no guard: the deadline tests returned before activation, and the ones that reached it used a 10 s
timeout on a fixture that had already settled.

The fixture now animates without end until an alert button is answered, which is the state that made
XCTest hold the event past the caller's deadline in the field. A test that reaches activation there
and is given 6 s reports what actually happens: the response comes back in well under a second of
activation, and if it ever reports `ALERT_DEADLINE_EXCEEDED` again the fixture says whether a button
was activated behind that answer. Reverting the seam costs the run 18 s and produces exactly the
original defect — `ALERT_DEADLINE_EXCEEDED` alongside `First actions: 1`.

Only a `UIView` animation counts here: a repeating main-thread timer and a `CABasicAnimation` both
left the app looking idle and the reverted path still passed.

Author: thymikee

apple/runner/AgentDeviceRunner/AgentDeviceRunner/AgentDeviceRunnerApp.m

@@ -62,11 +62,46 @@ @interface AgentDeviceRunnerViewController : UIViewController
 @property(nonatomic, assign) NSUInteger firstAlertActions;
 @property(nonatomic, assign) NSUInteger replacementAlertActions;
 @property(nonatomic, assign) BOOL alertFixtureStarted;
+@property(nonatomic, strong) NSTimer *alertActivationBusyBackstop;
 @end
 
 @implementation AgentDeviceRunnerViewController
 
 #if TARGET_OS_IOS
+// An animation that never ends is what "busy" looks like to XCTest while it decides whether the app
+// may receive an event: the app keeps reporting work in flight, which is the state that cost an alert
+// command its whole deadline in #2546. It stops the moment an alert button is answered, since that
+// answer is the event the runner is trying to land, and the backstop stops it even when no answer
+// arrives so a regressed run finishes rather than waiting out XCTest's own timeout. A layer
+// animation on its own is not enough; only a UIView animation counts as in-flight work here.
+static NSTimeInterval const kAgentDeviceAlertActivationBusyWindow = 20.0;
+
+- (void)startAlertActivationBusy {
+  if (self.alertActivationBusyBackstop != nil) {
+    return;
+  }
+  self.alertActivationBusyBackstop = [NSTimer scheduledTimerWithTimeInterval:kAgentDeviceAlertActivationBusyWindow
+                                                                      target:self
+                                                                    selector:@selector(stopAlertActivationBusy)
+                                                                    userInfo:nil
+                                                                     repeats:NO];
+  [UIView animateWithDuration:0.4
+                          delay:0
+                        options:(UIViewAnimationOptionRepeat | UIViewAnimationOptionAutoreverse)
+                     animations:^{
+                       self.alertActionStatus.transform = CGAffineTransformMakeTranslation(0, 8);
+                     }
+                     completion:nil];
+}
+
+- (void)stopAlertActivationBusy {
+  [self.alertActionStatus.layer removeAllAnimations];
+  self.alertActionStatus.transform = CGAffineTransformIdentity;
+  [self.alertActivationBusyBackstop invalidate];
+  self.alertActivationBusyBackstop = nil;
+}
+
+
 - (void)updateAlertActionStatus {
   self.alertActionStatus.text = [NSString stringWithFormat:@"First actions: %lu; replacement actions: %lu",
                                                          (unsigned long)self.firstAlertActions,
@@ -88,6 +123,7 @@ - (void)presentAlertFixtureReplacement:(BOOL)replacement {
         ? UIAlertActionStyleCancel : UIAlertActionStyleDefault;
     [alert addAction:[UIAlertAction actionWithTitle:buttonTitle style:style handler:^(UIAlertAction *action) {
       (void)action;
+      [self stopAlertActivationBusy];
       if (replacement) {
         self.replacementAlertActions += 1;
       } else {
@@ -110,6 +146,9 @@ - (void)viewDidAppear:(BOOL)animated {
       [NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-alert-replacement-regression"]) {
     self.alertFixtureStarted = YES;
     [self presentAlertFixtureReplacement:NO];
+    if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-alert-activation-busy"]) {
+      [self startAlertActivationBusy];
+    }
   }
 }
 #endif

apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/UnitTests/RunnerTests+AlertObservationTests.swift

@@ -57,6 +57,38 @@ extension RunnerTests {
     XCTAssertEqual(app.staticTexts["agent-device-alert-actions"].label, "First actions: 0; replacement actions: 0")
   }
 
+  func testAlertActivationIgnoresAnAppThatNeverSettlesBeforeTheDeadline() throws {
+    app.launchArguments = [
+      "--agent-device-alert-replacement-regression",
+      "--agent-device-alert-activation-busy"
+    ]
+    app.launch()
+    defer {
+      invalidateCachedTarget(reason: "unit_test_cleanup")
+      app.terminate()
+    }
+    XCTAssertTrue(app.alerts.firstMatch.waitForExistence(timeout: appExistenceTimeout))
+    let alert = try XCTUnwrap(resolveAlert(app: app, deadline: Date().addingTimeInterval(10)))
+
+    let deadline = Date().addingTimeInterval(6)
+    let startedAt = Date()
+    let response = handleAlert(alert, action: "accept", deadline: deadline)
+    let elapsed = Date().timeIntervalSince(startedAt)
+
+    // The fixture keeps its main thread busy until a button is answered, so this only comes back
+    // early because activation refused to wait for an app that has no intention of settling (#2546).
+    XCTAssertLessThan(elapsed, 9, "activation waited \(elapsed)s for a busy app to idle")
+    XCTAssertTrue(response.ok, String(describing: response.error))
+    XCTAssertEqual(app.staticTexts["agent-device-alert-actions"].label, "First actions: 1; replacement actions: 0")
+    if !response.ok, response.error?.code == "ALERT_DEADLINE_EXCEEDED" {
+      XCTAssertEqual(
+        app.staticTexts["agent-device-alert-actions"].label,
+        "First actions: 0; replacement actions: 0",
+        "a caller told about an expired deadline must not have a button activated behind it"
+      )
+    }
+  }
+
   private func assertReplacementAlertUntouched(action: String, arguments: [String], confirmed: Bool) throws {
     app.launchArguments = ["--agent-device-alert-replacement-regression"] + arguments
     app.launch()