@devicelab/maestro-runner-darwin-arm64 1.1.27 → 1.1.29

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests_tvOS/FBTVFocusIntegrationTests.m

@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <XCTest/XCTest.h>
+
+#if TARGET_OS_TV
+
+// `XCUIElement+FBTVFocuse` is a project-internal category (not exposed as a
+// Public framework header), so its two entry points are forward-declared
+// here rather than imported. The real implementation - the one this suite
+// exercises end to end against a live tvOS Simulator - is still the one
+// linked in from WebDriverAgentLib_tvOS.framework.
+@interface XCUIElement (FBTVFocuseForTesting)
+- (BOOL)fb_setFocusWithError:(NSError **)error;
+- (BOOL)fb_selectWithError:(NSError **)error;
+@end
+
+@interface FBTVFocusIntegrationTests : XCTestCase
+@property (nonatomic, strong) XCUIApplication *app;
+@end
+
+@implementation FBTVFocusIntegrationTests
+
+- (void)setUp
+{
+  [super setUp];
+  self.continueAfterFailure = NO;
+  self.app = [XCUIApplication new];
+  [self.app launch];
+  XCTAssertTrue([self.app.buttons[@"cell_0_0"] waitForExistenceWithTimeout:15]);
+}
+
+- (void)testSetFocusMovesFocusToADistantElement
+{
+  XCUIElement *target = self.app.buttons[@"cell_2_2"];
+  XCTAssertTrue(target.exists);
+  XCTAssertFalse(target.hasFocus);
+
+  NSError *error;
+  BOOL result = [target fb_setFocusWithError:&error];
+
+  XCTAssertTrue(result);
+  XCTAssertNil(error);
+  XCTAssertTrue(target.hasFocus);
+}
+
+- (void)testSelectMovesFocusAndTriggersTheElementsAction
+{
+  XCUIElement *target = self.app.buttons[@"cell_1_2"];
+  XCUIElement *statusLabel = self.app.staticTexts[@"lastSelectedLabel"];
+
+  NSError *error;
+  BOOL result = [target fb_selectWithError:&error];
+
+  XCTAssertTrue(result);
+  XCTAssertNil(error);
+  XCTAssertTrue(target.hasFocus);
+
+  NSPredicate *labelUpdated = [NSPredicate predicateWithFormat:@"label == %@", @"cell_1_2"];
+  XCTNSPredicateExpectation *expectation = [[XCTNSPredicateExpectation alloc] initWithPredicate:labelUpdated object:statusLabel];
+  [self waitForExpectations:@[expectation] timeout:5];
+}
+
+- (void)testSetFocusOnADisabledElementFails
+{
+  XCUIElement *disabled = self.app.buttons[@"disabledButton"];
+  XCTAssertTrue(disabled.exists);
+
+  NSError *error;
+  BOOL result = [disabled fb_setFocusWithError:&error];
+
+  XCTAssertFalse(result);
+  XCTAssertNotNil(error);
+  XCTAssertFalse(disabled.hasFocus);
+}
+
+@end
+
+#endif

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests_tvOS/Info.plist

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.facebook.wda.integrationTests.tvOS</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>BNDL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+</dict>
+</plist>

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests_watchOS/IntegrationTests_watchOS-Bridging-Header.h

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// Exposes the WebDriverAgentLib_watchOS categories these tests call directly, in-process,
+// instead of going through the HTTP server.
+
+#import "XCUIElement+FBFind.h"
+#import "XCUIElement+FBClassChain.h"
+#import "XCUIElement+FBIsVisible.h"
+#import "XCUIElement+FBUtilities.h"
+#import "XCUIElement+FBWebDriverAttributes.h"
+#import "XCUIElement+FBTyping.h"
+#import "XCUIApplication+FBHelpers.h"
+#import "XCUIDevice+FBHelpers.h"
+#import "FBAlert.h"
+#import "FBElement.h"
+#import "FBMjpegServer.h"
+#import "FBTCPSocket.h"

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests_watchOS/WDAAlertIntegrationTests.swift

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import XCTest
+
+/// Covers FBAlert's no-alert-present behavior directly, in-process. IntegrationApp_watchOS never
+/// presents a real alert, so this only exercises the "no alert open" path (`text`/`buttonLabels`
+/// both just return nil - no HTTP-error-style throw at this layer), not the success path.
+final class WDAAlertIntegrationTests: WDAWatchInProcessTestCase {
+  // All reads, no taps/typing - reuse the same running app across the whole class.
+  override class var relaunchForEachTest: Bool { false }
+
+  func testAlertTextWithNoAlertPresentReturnsNil() {
+    XCTAssertNil(FBAlert(application: app).text())
+  }
+
+  func testAlertButtonsWithNoAlertPresentReturnsNil() {
+    XCTAssertNil(FBAlert(application: app).buttonLabels())
+  }
+}

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests_watchOS/WDAAppLifecycleIntegrationTests.swift

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import XCTest
+
+/// Covers the app lifecycle routes (launch/activate/terminate/state/list). FBSession's
+/// implementations of these are themselves thin wrappers over plain XCTest XCUIApplication
+/// APIs (see FBSession.m), so this calls `.launch()`/`.activate()`/`.terminate()`/`.state`
+/// directly instead of going through the HTTP server; only the apps-list route has a real WDA
+/// category behind it (`+fb_activeAppsInfo`).
+final class WDAAppLifecycleIntegrationTests: WDAWatchInProcessTestCase {
+  func testAppsListIncludesTheAppUnderTest() {
+    let apps = XCUIApplication.fb_activeAppsInfo()
+    XCTAssertTrue(apps.contains { $0["bundleId"] as? String == WDAWatchInProcessTestCase.integrationAppBundleId })
+  }
+
+  func testTerminateThenRelaunchLifecycle() {
+    app.terminate()
+    XCTAssertEqual(app.state, .notRunning)
+
+    app.launch()
+    XCTAssertEqual(app.state, .runningForeground)
+
+    // The app relaunched fresh, so its accessibility tree should be back too.
+    XCTAssertTrue(app.buttons["tapMeButton"].waitForExistence(timeout: 15))
+  }
+
+  func testActivateBringsTheAppToTheForeground() {
+    app.activate()
+    XCTAssertEqual(app.state, .runningForeground)
+  }
+}

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests_watchOS/WDAClickIntegrationTests.swift

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import XCTest
+
+/// Covers /element/:uuid/click, which on watchOS (like iOS) is just standard XCTest `-tap`
+/// (see FBElementCommands.handleClick:) - so this just calls `.tap()` directly, the same way
+/// the iOS/tvOS integration tests do. The "click a nonexistent element UUID" case isn't a `tap`
+/// behavior at all (it's FBElementCache's UUID-lookup failure), so it's covered by the HTTP
+/// end-to-end tests instead, where there's an actual UUID/route layer to miss against.
+final class WDAClickIntegrationTests: WDAWatchInProcessTestCase {
+  func testClickingButtonUpdatesTheResultLabel() {
+    let label = app.staticTexts["resultLabel"]
+    XCTAssertEqual(label.wdValue ?? label.wdLabel, "Idle")
+
+    app.buttons["tapMeButton"].tap()
+
+    XCTAssertEqual(label.wdValue ?? label.wdLabel, "Tapped")
+  }
+}

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests_watchOS/WDADeviceIntegrationTests.swift

@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import CoreLocation
+import WatchKit
+import XCTest
+
+/// Covers device-info, active-app-info, simulated location, digital crown rotation, and hand
+/// gesture, calling the same underlying APIs FBCustomCommands/XCUIDevice+FBHelpers use directly
+/// in-process. The real (non-simulated) GPS location route and the two pure argument-validation
+/// cases (missing delta/gesture name, rejected before any category method is even called) aren't
+/// WDA category behavior, so they're not covered here.
+final class WDADeviceIntegrationTests: WDAWatchInProcessTestCase {
+  func testDeviceInfo() {
+    XCTAssertFalse(WKInterfaceDevice.current().name.isEmpty)
+    XCTAssertFalse(WKInterfaceDevice.current().model.isEmpty)
+  }
+
+  func testActiveAppInfo() {
+    let apps = XCUIApplication.fb_activeAppsInfo()
+    let ourApp = apps.first { $0["bundleId"] as? String == WDAWatchInProcessTestCase.integrationAppBundleId }
+    XCTAssertNotNil(ourApp)
+    XCTAssertGreaterThan(ourApp?["pid"] as? Int ?? 0, 0)
+  }
+
+  func testSimulatedLocationRoundTrip() throws {
+    let location = CLLocation(latitude: 37.3230, longitude: -122.0322)
+    try XCUIDevice.shared.fb_setSimulatedLocation(location)
+
+    let fetched = try XCUIDevice.shared.fb_getSimulatedLocation()
+    XCTAssertEqual(fetched.coordinate.latitude, 37.3230, accuracy: 0.001)
+    XCTAssertEqual(fetched.coordinate.longitude, -122.0322, accuracy: 0.001)
+
+    try XCUIDevice.shared.fb_clearSimulatedLocation()
+  }
+
+  /// rotateDigitalCrownByDelta:/performHandGesture: were only added to the SDK in Xcode 16.3 - WDA calls
+  /// them dynamically (NSInvocation) so it keeps building on older Xcode too, but they only actually work
+  /// when the toolchain that built this very test bundle (same build as the runner) is new enough. Checked
+  /// the same way WDA itself does, via responds(to:), rather than hardcoding an Xcode/OS version number here.
+  private var supportsDigitalCrownAndHandGesture: Bool {
+    XCUIDevice.shared.responds(to: NSSelectorFromString("rotateDigitalCrownByDelta:"))
+  }
+
+  private func assertSucceeds(_ expectedToSucceed: Bool, file: StaticString = #filePath, line: UInt = #line, _ body: () throws -> Void) {
+    do {
+      try body()
+      XCTAssertTrue(expectedToSucceed, "expected this to throw, but it didn't", file: file, line: line)
+    } catch {
+      XCTAssertFalse(expectedToSucceed, "expected this to succeed, but it threw \(error)", file: file, line: line)
+    }
+  }
+
+  func testRotateDigitalCrown() {
+    assertSucceeds(supportsDigitalCrownAndHandGesture) {
+      try XCUIDevice.shared.fb_rotateDigitalCrown(0.2, velocity: 1.0)
+    }
+  }
+
+  func testPerformHandGestureDoubleTap() {
+    assertSucceeds(supportsDigitalCrownAndHandGesture) {
+      try XCUIDevice.shared.fb_performHandGesture("doubleTap")
+    }
+  }
+
+  func testPerformHandGestureFlick() {
+    // flick additionally needs watchOS 26+ (still internally versioned 12.0 pre-rename) on top of the
+    // Xcode 16.3+ toolchain floor - below that OS version it isn't even advertised as a supported name,
+    // so the server rejects it the same way it would reject any other unknown gesture name.
+    let shouldSucceed: Bool
+    if #available(watchOS 12.0, *) {
+      shouldSucceed = supportsDigitalCrownAndHandGesture
+    } else {
+      shouldSucceed = false
+    }
+    assertSucceeds(shouldSucceed) {
+      try XCUIDevice.shared.fb_performHandGesture("flick")
+    }
+  }
+
+  func testPerformHandGestureUnsupportedName() {
+    // Not a real gesture name in any environment, so always rejected regardless of toolchain/OS version.
+    assertSucceeds(false) {
+      try XCUIDevice.shared.fb_performHandGesture("clench")
+    }
+  }
+}

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests_watchOS/WDAElementAttributeIntegrationTests.swift

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import XCTest
+
+/// Covers the FBElement attribute properties (wdEnabled/wdVisible/wdRect/wdType/wdLabel/
+/// wdSelected/wdAccessible/fb_valueForWDAttributeName:) directly, in-process - the same
+/// properties FBElementCommands' attribute routes read from.
+final class WDAElementAttributeIntegrationTests: WDAWatchInProcessTestCase {
+  // All reads, no taps/typing - reuse the same running app across the whole class.
+  override class var relaunchForEachTest: Bool { false }
+
+  func testWindowSizeAndRect() {
+    XCTAssertGreaterThan(app.wdFrame.width, 0)
+    XCTAssertGreaterThan(app.wdFrame.height, 0)
+  }
+
+  func testButtonAttributes() {
+    let button = app.buttons["tapMeButton"]
+    XCTAssertTrue(button.isWDEnabled)
+    XCTAssertTrue(button.isWDVisible)
+    XCTAssertGreaterThan(button.wdRect["width"] as? Double ?? 0, 0)
+    XCTAssertEqual(button.wdType, "XCUIElementTypeButton")
+    XCTAssertEqual(button.wdLabel, "Tap Me")
+    XCTAssertEqual(button.fb_value(forWDAttributeName: "label") as? String, "Tap Me")
+    XCTAssertTrue(button.isWDAccessible)
+  }
+
+  func testResultLabelTextAndSelectedState() {
+    let label = app.staticTexts["resultLabel"]
+    XCTAssertEqual(label.wdValue ?? label.wdLabel, "Idle")
+    XCTAssertFalse(label.isWDSelected)
+  }
+}

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests_watchOS/WDAFindIntegrationTests.swift

@@ -0,0 +1,101 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import XCTest
+
+/// Covers the XCUIElement+FBFind/+FBClassChain category methods directly, in-process - the same
+/// implementations FBFindElementCommands dispatches to over HTTP. Locator-string aliasing
+/// ("name"/"id" both meaning accessibility id, "link text" vs "partial link text") is a route
+/// dispatch concern, not a category one, so it isn't re-tested here - see the HTTP end-to-end
+/// tests for coverage of the actual route layer.
+final class WDAFindIntegrationTests: WDAWatchInProcessTestCase {
+  // All reads, no taps/typing - reuse the same running app across the whole class.
+  override class var relaunchForEachTest: Bool { false }
+
+  func testDescendantsMatchingIdentifier() {
+    let matches = app.fb_descendants(matchingIdentifier: "tapMeButton", shouldReturnAfterFirstMatch: true)
+    XCTAssertEqual(matches.count, 1)
+    XCTAssertEqual(matches.first?.elementType, .button)
+  }
+
+  func testDescendantsMatchingClassName() {
+    let matches = app.fb_descendants(matchingClassName: "XCUIElementTypeButton", shouldReturnAfterFirstMatch: false)
+    XCTAssertGreaterThanOrEqual(matches.count, 1)
+    XCTAssertTrue(matches.allSatisfy { $0.elementType == .button })
+  }
+
+  func testDescendantsMatchingPredicate() {
+    let predicate = NSPredicate(format: "label == %@", "Tap Me")
+    let matches = app.fb_descendants(matching: predicate, shouldReturnAfterFirstMatch: true)
+    XCTAssertEqual(matches.count, 1)
+  }
+
+  func testDescendantsMatchingClassChain() {
+    let matches = app.fb_descendants(matchingClassChain: "**/XCUIElementTypeButton", shouldReturnAfterFirstMatch: false)
+    XCTAssertGreaterThanOrEqual(matches.count, 1)
+  }
+
+  func testDescendantsMatchingXPathQuery() {
+    // XPath resolution is a two-phase lookup (snapshot to XML, then re-resolve by uid) - on a
+    // just-launched app this occasionally races the accessibility connection settling and loses
+    // it entirely ("Lost connection to the application"), a hard XCTest issue with no NSError to
+    // catch. Reproduces consistently on the Xcode 27 beta toolchain; not reproduced through the
+    // (slower, naturally more settled) HTTP route in WDAHTTPEndToEndTests. Non-strict so this
+    // stops masking anything the moment the race is gone.
+    XCTExpectFailure(
+      "XPath resolution can lose the accessibility connection right after a fresh app launch - a beta-toolchain timing race",
+      options: .nonStrict()
+    ) {
+      let matches = app.fb_descendants(
+        matchingXPathQuery: "//XCUIElementTypeButton[@name=\"tapMeButton\"]",
+        shouldReturnAfterFirstMatch: true
+      )
+      XCTAssertEqual(matches.count, 1)
+    }
+  }
+
+  func testDescendantsMatchingProperty() {
+    let matches = app.fb_descendants(matchingProperty: "name", value: "tapMe", partialSearch: true)
+    XCTAssertGreaterThanOrEqual(matches.count, 1)
+  }
+
+  func testDescendantsMatchingIdentifierThatDoesNotExistReturnsEmptyArray() {
+    let matches = app.fb_descendants(matchingIdentifier: "thisElementDoesNotExist", shouldReturnAfterFirstMatch: true)
+    XCTAssertTrue(matches.isEmpty)
+  }
+
+  func testDescendantsUnderASubElement() {
+    let window = app.windows.firstMatch
+    XCTAssertTrue(window.exists)
+    let matches = window.fb_descendants(matchingIdentifier: "tapMeButton", shouldReturnAfterFirstMatch: true)
+    XCTAssertEqual(matches.count, 1)
+  }
+
+  func testActiveElementResolvesToTheFocusedTextField() {
+    // watchOS classifies an inline TextField's element type differently across OS versions (e.g.
+    // a button-styled placeholder pre-tap on some versions, .textField on others), so look it up
+    // by identifier across all types rather than filtering through app.textFields.
+    app.descendants(matching: .any)["typingField"].tap()
+
+    // Focus reporting lags the tap slightly on watchOS (the same flakiness the old HTTP-based
+    // version of this test papered over with a whole-suite retry) - poll briefly instead.
+    var activeElement: XCUIElement?
+    let deadline = Date().addingTimeInterval(5)
+    repeat {
+      activeElement = app.fb_activeElement()
+    } while activeElement == nil && Date() < deadline
+    XCTAssertNotNil(activeElement)
+
+    // Tapping the field opens a full-screen keyboard sheet - back out so later tests in this
+    // class (which reuse this same running app instance) see tapMeButton again, not the sheet.
+    let cancel = app.buttons["Cancel"]
+    if cancel.waitForExistence(timeout: 2) {
+      cancel.tap()
+    }
+  }
+}

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests_watchOS/WDAMjpegStreamingIntegrationTests.swift

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import Network
+import XCTest
+
+/// Exercises FBMjpegServer+FBTCPSocket the same way FBWebServer wires them together in
+/// -initScreenshotsBroadcaster, but standalone (no full FBWebServer/HTTP command server needed).
+/// A client NWConnection reads the raw wire bytes back to confirm the multipart/x-mixed-replace
+/// stream and its JPEG frames actually arrive, since watchOS has no BSD sockets/GCDAsyncSocket -
+/// the production implementation is Network.framework-backed and worth covering for real.
+final class WDAMjpegStreamingIntegrationTests: WDAWatchInProcessTestCase {
+  override class var relaunchForEachTest: Bool { false }
+
+  private static let jpegMagicBytes: [UInt8] = [0xFF, 0xD8, 0xFF]
+
+  func testMjpegStreamingProducesJpegFrames() throws {
+    // Port 0 asks the system to assign an ephemeral port; -[FBTCPSocket port] then reflects the
+    // actual bound port once -start returns, per nw_listener_get_port's documented behavior.
+    let socket = FBTCPSocket(port: 0)
+    let server = FBMjpegServer()
+    server.socket = socket
+    socket.delegate = server
+    defer {
+      server.stopStreaming()
+      socket.stop()
+    }
+    try socket.start()
+    let boundPort = socket.port
+    XCTAssertNotEqual(boundPort, 0, "FBTCPSocket did not report its bound ephemeral port")
+
+    let connection = NWConnection(host: "127.0.0.1", port: NWEndpoint.Port(rawValue: boundPort)!, using: .tcp)
+    defer { connection.cancel() }
+
+    let connected = expectation(description: "client connected to the mjpeg broadcaster")
+    connection.stateUpdateHandler = { state in
+      if case .ready = state {
+        connected.fulfill()
+      }
+    }
+    connection.start(queue: .main)
+    wait(for: [connected], timeout: 15)
+
+    // FBMjpegServer only starts broadcasting once it has seen any data from the client - mimic the
+    // request line a real HTTP client would send.
+    let sent = expectation(description: "sent the request line")
+    connection.send(content: Data("GET / HTTP/1.0\r\n\r\n".utf8), completion: .contentProcessed { _ in
+      sent.fulfill()
+    })
+    wait(for: [sent], timeout: 15)
+
+    var received = Data()
+    let jpegMagicData = Data(Self.jpegMagicBytes)
+    let sawJpegFrame = expectation(description: "received at least one jpeg frame")
+    func receiveMore() {
+      connection.receive(minimumIncompleteLength: 1, maximumLength: 65536) { data, _, _, error in
+        if let data = data {
+          received.append(data)
+          if received.range(of: jpegMagicData) != nil {
+            sawJpegFrame.fulfill()
+            return
+          }
+        }
+        if error == nil {
+          receiveMore()
+        }
+      }
+    }
+    receiveMore()
+    wait(for: [sawJpegFrame], timeout: 15)
+
+    XCTAssertNotNil(received.range(of: Data("multipart/x-mixed-replace".utf8)), "Response is not a multipart stream")
+    XCTAssertNotNil(received.range(of: Data("Content-type: image/jpeg".utf8)), "No JPEG part header found")
+    XCTAssertNotNil(received.range(of: jpegMagicData), "No JPEG frame data found")
+  }
+}

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests_watchOS/WDAScreenshotAndSourceIntegrationTests.swift

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import XCTest
+// XCUIAutomation is a separate module on newer SDKs but folded into XCTest on older ones
+// (Xcode 15.4) - guard the import so this builds on both.
+#if canImport(XCUIAutomation)
+import XCUIAutomation
+#endif
+
+/// Covers device/element screenshots and page source, calling XCUIDevice+FBHelpers/
+/// XCUIApplication+FBHelpers and plain XCTest APIs directly in-process.
+final class WDAScreenshotAndSourceIntegrationTests: WDAWatchInProcessTestCase {
+  // All reads, no taps/typing - reuse the same running app across the whole class.
+  override class var relaunchForEachTest: Bool { false }
+
+  private static let pngMagicBytes: [UInt8] = [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]
+
+  private func assertLooksLikeAPNG(_ data: Data?, file: StaticString = #filePath, line: UInt = #line) {
+    guard let data = data else {
+      return XCTFail("No screenshot data returned", file: file, line: line)
+    }
+    XCTAssertGreaterThan(data.count, Self.pngMagicBytes.count, file: file, line: line)
+    XCTAssertEqual(Array(data.prefix(Self.pngMagicBytes.count)), Self.pngMagicBytes, "not a PNG", file: file, line: line)
+  }
+
+  func testDeviceScreenshot() throws {
+    let data = try XCUIDevice.shared.fb_screenshot()
+    assertLooksLikeAPNG(data)
+  }
+
+  func testElementScreenshot() {
+    let provider: XCUIScreenshotProviding = app.buttons["tapMeButton"]
+    assertLooksLikeAPNG(provider.screenshot().pngRepresentation)
+  }
+
+  func testPageSourceContainsTheKnownElements() {
+    guard let xml = app.fb_xmlRepresentation() else {
+      return XCTFail("No XML source returned")
+    }
+    XCTAssertTrue(xml.contains("tapMeButton"))
+    XCTAssertTrue(xml.contains("resultLabel"))
+    XCTAssertTrue(xml.contains("typingField"))
+  }
+
+  func testAccessibleSource() {
+    XCTAssertFalse(app.fb_accessibilityTree().isEmpty)
+  }
+}

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests_watchOS/WDATypingIntegrationTests.swift

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import XCTest
+
+/// Covers XCUIElement+FBTyping (set value/clear) and the keyboard-dismiss helper, calling them
+/// directly in-process instead of over HTTP.
+///
+/// KNOWN LIMITATION (see XCUIElement+FBTyping.m): the keyboard opens and the field gets focus,
+/// but no keystrokes land. Wrapped in XCTExpectFailure so this re-verifies itself and starts
+/// failing loudly the moment it starts working, instead of silently staying stale.
+final class WDATypingIntegrationTests: WDAWatchInProcessTestCase {
+  // watchOS classifies an inline TextField's element type differently across OS versions (e.g.
+  // a button-styled placeholder pre-tap on some versions, .textField on others), so look it up
+  // by identifier across all types rather than filtering through app.textFields.
+  private var typingField: XCUIElement { app.descendants(matching: .any)["typingField"] }
+
+  private func backOutOfKeyboardIfPresented() {
+    let cancel = app.buttons["Cancel"]
+    if cancel.waitForExistence(timeout: 2) {
+      cancel.tap()
+    }
+  }
+
+  func testSetValueOpensTheKeyboardAndAttemptsToTypeIntoTheField() {
+    let field = typingField
+
+    // Some watchOS versions (confirmed: 10.5) don't expose an inline TextField's placeholder via
+    // accessibility until it's been focused at least once, so this can legitimately read nil.
+    XCTExpectFailure(
+      "watchOS can omit an unfocused TextField's placeholder from the accessibility tree",
+      options: .nonStrict()
+    ) {
+      XCTAssertEqual(field.wdValue ?? field.wdPlaceholderValue, "Type here")
+    }
+
+    // fb_typeText taps to focus internally if needed, but watchOS's full-screen keyboard sheet
+    // transition can outlast its short internal settle wait - tap and wait for the sheet
+    // ourselves first to shrink (not eliminate) the race.
+    field.tap()
+    _ = app.buttons["Cancel"].waitForExistence(timeout: 5)
+
+    // Both possible failure modes - typeText: recording a "no keyboard focus" issue internally
+    // if the sheet transition is still lagging, or it landing focus fine but the keystrokes
+    // themselves not registering - are the same known watchOS limitation, so both are expected
+    // here. If this ever starts reliably working, XCTExpectFailure itself starts failing loudly.
+    XCTExpectFailure("watchOS keystroke delivery into the on-screen keyboard is a known unresolved limitation") {
+      _ = try? field.fb_typeText("hi", shouldClear: false)
+      XCTAssertEqual(field.wdValue, "hi")
+    }
+
+    backOutOfKeyboardIfPresented()
+  }
+
+  func testClearingAnAlreadyEmptyFieldSucceeds() throws {
+    // Clearing an empty field short-circuits, so this works despite the typing limitation.
+    try typingField.fb_clearText()
+  }
+
+  func testDismissKeyboardDoesNotCrashTheApp() {
+    // Only asserts the call round-trips cleanly, not that dismissal actually happens.
+    typingField.tap()
+
+    _ = try? app.fb_dismissKeyboard(withKeyNames: nil)
+
+    backOutOfKeyboardIfPresented()
+  }
+}