appium-webdriveragent 16.3.0 → 16.5.0

package/WebDriverAgent.xcodeproj/xcshareddata/xcschemes/IntegrationTests_watchOS.xcscheme

@@ -14,7 +14,7 @@
             buildForAnalyzing = "NO">
             <BuildableReference
                BuildableIdentifier = "primary"
-               BlueprintIdentifier = "4632809915F58C9095914E85"
+               BlueprintIdentifier = "5D9539D7055B5E6EED56D100"
                BuildableName = "IntegrationTests_watchOS.xctest"
                BlueprintName = "IntegrationTests_watchOS"
                ReferencedContainer = "container:WebDriverAgent.xcodeproj">
@@ -32,7 +32,7 @@
             skipped = "NO">
             <BuildableReference
                BuildableIdentifier = "primary"
-               BlueprintIdentifier = "4632809915F58C9095914E85"
+               BlueprintIdentifier = "5D9539D7055B5E6EED56D100"
                BuildableName = "IntegrationTests_watchOS.xctest"
                BlueprintName = "IntegrationTests_watchOS"
                ReferencedContainer = "container:WebDriverAgent.xcodeproj">
@@ -53,7 +53,7 @@
       <MacroExpansion>
          <BuildableReference
             BuildableIdentifier = "primary"
-            BlueprintIdentifier = "4632809915F58C9095914E85"
+            BlueprintIdentifier = "5D9539D7055B5E6EED56D100"
             BuildableName = "IntegrationTests_watchOS.xctest"
             BlueprintName = "IntegrationTests_watchOS"
             ReferencedContainer = "container:WebDriverAgent.xcodeproj">
@@ -69,7 +69,7 @@
       <MacroExpansion>
          <BuildableReference
             BuildableIdentifier = "primary"
-            BlueprintIdentifier = "4632809915F58C9095914E85"
+            BlueprintIdentifier = "5D9539D7055B5E6EED56D100"
             BuildableName = "IntegrationTests_watchOS.xctest"
             BlueprintName = "IntegrationTests_watchOS"
             ReferencedContainer = "container:WebDriverAgent.xcodeproj">

package/WebDriverAgentLib/Categories/XCUIDevice+FBHelpers.h

@@ -166,6 +166,40 @@ typedef NS_ENUM(NSUInteger, FBUIInterfaceAppearance) {
  */
 - (nullable NSNumber *)fb_getAppearance;
 
+#if TARGET_OS_WATCH
+/**
+ Rotates the Digital Crown on Apple Watch. See
+ https://developer.apple.com/documentation/xcuiautomation/xcuidevice/rotatedigitalcrown(delta:velocity:)
+ and https://developer.apple.com/documentation/xcuiautomation/xcuidevice/rotatedigitalcrown(delta:)
+ Invoked dynamically (this selector was only added to the SDK in Xcode 16.3), so this compiles against
+ older Xcode versions too - it just fails at runtime with an error if the OS/SDK combination in use
+ doesn't actually implement it.
+
+ @param delta The number of full crown rotations, e.g. 1.0 is one complete turn.
+              The sign gives the direction: positive rotates up/clockwise, negative rotates down/counterclockwise.
+ @param velocity The rotation speed, in rotations per second, e.g. 1.0 completes one full
+                 rotation per second. This is the raw value behind the public XCUIGestureVelocity
+                 API, which only exposes it via named presets (.slow/.default/.fast).
+                 Pass nil to use XCTest's own default velocity instead of specifying one explicitly.
+ @param error If there is an error, upon return contains an NSError object that describes the problem.
+ @return YES if the operation succeeds, otherwise NO.
+ */
+- (BOOL)fb_rotateDigitalCrown:(double)delta velocity:(nullable NSNumber *)velocity error:(NSError **)error;
+
+/**
+ Performs a hand gesture on Apple Watch (e.g. Double Tap, Wrist Flick). See
+ https://developer.apple.com/documentation/xcuiautomation/xcuidevice/perform(handgesture:)
+ Invoked dynamically (this selector was only added to the SDK in Xcode 16.3), so this compiles against
+ older Xcode versions too - it just fails at runtime with an error if the OS/SDK combination in use
+ doesn't actually implement it.
+
+ @param gestureName One of the supported gesture names: doubleTap (watchOS 10+), flick (watchOS 26+).
+ @param error If there is an error, upon return contains an NSError object that describes the problem.
+ @return YES if the operation succeeds, otherwise NO.
+ */
+- (BOOL)fb_performHandGesture:(NSString *)gestureName error:(NSError **)error;
+#endif // TARGET_OS_WATCH
+
 #if !TARGET_OS_TV
 /**
  Allows to set a simulated geolocation coordinates.

package/WebDriverAgentLib/Categories/XCUIDevice+FBHelpers.m

@@ -86,6 +86,27 @@ NSDictionary<NSString *, NSNumber *> *fb_availableButtonNames(void) {
 }
 #endif
 
+#if TARGET_OS_WATCH
+// Raw values from XCUIDeviceHandGesture (XCUIAutomation/XCUIDeviceHandGesture.h): doubleTap = 1, flick = 2.
+// Referenced by raw integer rather than the enum constant, and invoked via NSInvocation in
+// fb_performHandGesture:error: below, since that enum/selector was only added to the SDK in Xcode 16.3
+// (flick specifically needs watchOS 12.0/26 - see the @available check below). This way the code compiles
+// against any Xcode version; unsupported gestures/selectors are only rejected at runtime.
+NSDictionary<NSString *, NSNumber *> *fb_availableHandGestureNames(void) {
+  static dispatch_once_t onceToken;
+  static NSDictionary *result;
+  dispatch_once(&onceToken, ^{
+    NSMutableDictionary *gestures = [NSMutableDictionary dictionary];
+    gestures[@"doubletap"] = @(1);
+    if (@available(watchOS 12.0, *)) {
+      gestures[@"flick"] = @(2);
+    }
+    result = [gestures copy];
+  });
+  return result;
+}
+#endif // TARGET_OS_WATCH
+
 @implementation XCUIDevice (FBHelpers)
 
 static bool fb_isLocked;
@@ -386,6 +407,57 @@ static bool fb_isLocked;
   : nil;
 }
 
+#if TARGET_OS_WATCH
+- (BOOL)fb_rotateDigitalCrown:(double)delta velocity:(nullable NSNumber *)velocity error:(NSError **)error
+{
+  SEL selector = nil == velocity
+    ? NSSelectorFromString(@"rotateDigitalCrownByDelta:")
+    : NSSelectorFromString(@"rotateDigitalCrownByDelta:withVelocity:");
+  if (nil == selector || ![self respondsToSelector:selector]) {
+    return [[[FBErrorBuilder builder]
+             withDescriptionFormat:@"Digital Crown rotation is not supported by the current Xcode SDK/OS combination"]
+            buildError:error];
+  }
+  NSMethodSignature *signature = [self methodSignatureForSelector:selector];
+  NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
+  [invocation setSelector:selector];
+  [invocation setTarget:self];
+  [invocation setArgument:&delta atIndex:2];
+  if (velocity) {
+    double velocityValue = velocity.doubleValue;
+    [invocation setArgument:&velocityValue atIndex:3];
+  }
+  [invocation invoke];
+  return YES;
+}
+
+- (BOOL)fb_performHandGesture:(NSString *)gestureName error:(NSError **)error
+{
+  NSDictionary<NSString *, NSNumber *> *availableGestures = fb_availableHandGestureNames();
+  NSNumber *gestureValue = availableGestures[gestureName.lowercaseString];
+  if (!gestureValue) {
+    NSArray *sortedKeys = [availableGestures.allKeys sortedArrayUsingSelector:@selector(compare:)];
+    return [[[FBErrorBuilder builder]
+             withDescriptionFormat:@"The hand gesture '%@' is not supported. The device under test only supports the following hand gestures: %@", gestureName, sortedKeys]
+            buildError:error];
+  }
+  SEL selector = NSSelectorFromString(@"performHandGesture:");
+  if (nil == selector || ![self respondsToSelector:selector]) {
+    return [[[FBErrorBuilder builder]
+             withDescriptionFormat:@"Hand gesture automation is not supported by the current Xcode SDK/OS combination"]
+            buildError:error];
+  }
+  NSMethodSignature *signature = [self methodSignatureForSelector:selector];
+  NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
+  [invocation setSelector:selector];
+  [invocation setTarget:self];
+  NSInteger gestureRawValue = gestureValue.integerValue;
+  [invocation setArgument:&gestureRawValue atIndex:2];
+  [invocation invoke];
+  return YES;
+}
+#endif // TARGET_OS_WATCH
+
 #if !TARGET_OS_TV
 - (BOOL)fb_setSimulatedLocation:(CLLocation *)location error:(NSError **)error
 {

package/WebDriverAgentLib/Commands/FBCustomCommands.m

@@ -63,6 +63,10 @@
     [[FBRoute GET:@"/wda/batteryInfo"] respondWithTarget:self action:@selector(handleGetBatteryInfo:)],
 #endif
     [[FBRoute POST:@"/wda/pressButton"] respondWithTarget:self action:@selector(handlePressButtonCommand:)],
+#if TARGET_OS_WATCH
+    [[FBRoute POST:@"/wda/rotateDigitalCrown"] respondWithTarget:self action:@selector(handleRotateDigitalCrownCommand:)],
+    [[FBRoute POST:@"/wda/performHandGesture"] respondWithTarget:self action:@selector(handlePerformHandGestureCommand:)],
+#endif
     [[FBRoute POST:@"/wda/performAccessibilityAudit"] respondWithTarget:self action:@selector(handlePerformAccessibilityAudit:)],
     [[FBRoute POST:@"/wda/performIoHidEvent"] respondWithTarget:self action:@selector(handlePeformIOHIDEvent:)],
     [[FBRoute POST:@"/wda/expectNotification"] respondWithTarget:self action:@selector(handleExpectNotification:)],
@@ -295,6 +299,38 @@
   return FBResponseWithOK();
 }
 
+#if TARGET_OS_WATCH
++ (id<FBResponsePayload>)handleRotateDigitalCrownCommand:(FBRouteRequest *)request
+{
+  NSNumber *delta = request.arguments[@"delta"];
+  if (nil == delta) {
+    return FBResponseWithStatus([FBCommandStatus invalidArgumentErrorWithMessage:@"'delta' argument is mandatory"
+                                                                         traceback:nil]);
+  }
+  NSError *error;
+  if (![XCUIDevice.sharedDevice fb_rotateDigitalCrown:delta.doubleValue
+                                              velocity:request.arguments[@"velocity"]
+                                                 error:&error]) {
+    return FBResponseWithUnknownError(error);
+  }
+  return FBResponseWithOK();
+}
+
++ (id<FBResponsePayload>)handlePerformHandGestureCommand:(FBRouteRequest *)request
+{
+  NSString *gestureName = request.arguments[@"name"];
+  if (nil == gestureName) {
+    return FBResponseWithStatus([FBCommandStatus invalidArgumentErrorWithMessage:@"'name' argument is mandatory"
+                                                                         traceback:nil]);
+  }
+  NSError *error;
+  if (![XCUIDevice.sharedDevice fb_performHandGesture:gestureName error:&error]) {
+    return FBResponseWithUnknownError(error);
+  }
+  return FBResponseWithOK();
+}
+#endif
+
 + (id<FBResponsePayload>)handleActivateSiri:(FBRouteRequest *)request
 {
   NSError *error;

package/WebDriverAgentLib/FBAlert.m

@@ -236,17 +236,18 @@
   }
 
   XCUIElement *acceptButton = nil;
-  if (FBConfiguration.sharedInstance.acceptAlertButtonSelector.length) {
+  NSString *acceptAlertButtonSelector = FBConfiguration.sharedInstance.acceptAlertButtonSelector ?: @"";
+  if (acceptAlertButtonSelector.length) {
     NSString *errorReason = nil;
     @try {
-      acceptButton = [[alertElement fb_descendantsMatchingClassChain:FBConfiguration.sharedInstance.acceptAlertButtonSelector
+      acceptButton = [[alertElement fb_descendantsMatchingClassChain:acceptAlertButtonSelector
                                            shouldReturnAfterFirstMatch:YES] firstObject];
     } @catch (NSException *ex) {
       errorReason = ex.reason;
     }
     if (nil == acceptButton) {
       [FBLogger logFmt:@"Cannot find any match for Accept alert button using the class chain selector '%@'",
-       FBConfiguration.sharedInstance.acceptAlertButtonSelector];
+       acceptAlertButtonSelector];
       if (nil != errorReason) {
         [FBLogger logFmt:@"Original error: %@", errorReason];
       }
@@ -293,17 +294,18 @@
   }
 
   XCUIElement *dismissButton = nil;
-  if (FBConfiguration.sharedInstance.dismissAlertButtonSelector.length) {
+  NSString *dismissAlertButtonSelector = FBConfiguration.sharedInstance.dismissAlertButtonSelector ?: @"";
+  if (dismissAlertButtonSelector.length) {
     NSString *errorReason = nil;
     @try {
-      dismissButton = [[alertElement fb_descendantsMatchingClassChain:FBConfiguration.sharedInstance.dismissAlertButtonSelector
+      dismissButton = [[alertElement fb_descendantsMatchingClassChain:dismissAlertButtonSelector
                                             shouldReturnAfterFirstMatch:YES] firstObject];
     } @catch (NSException *ex) {
       errorReason = ex.reason;
     }
     if (nil == dismissButton) {
       [FBLogger logFmt:@"Cannot find any match for Dismiss alert button using the class chain selector '%@'",
-       FBConfiguration.sharedInstance.dismissAlertButtonSelector];
+       dismissAlertButtonSelector];
       if (nil != errorReason) {
         [FBLogger logFmt:@"Original error: %@", errorReason];
       }

package/WebDriverAgentLib/Info.plist

@@ -15,11 +15,11 @@
     <key>CFBundlePackageType</key>
     <string>FMWK</string>
     <key>CFBundleShortVersionString</key>
-    <string>16.3.0</string>
+    <string>16.5.0</string>
     <key>CFBundleSignature</key>
     <string>????</string>
     <key>CFBundleVersion</key>
-    <string>16.3.0</string>
+    <string>16.5.0</string>
     <key>NSPrincipalClass</key>
     <string/>
   </dict>

package/WebDriverAgentTests/IntegrationTests_watchOS/IntegrationTests_watchOS-Bridging-Header.h

@@ -0,0 +1,21 @@
+/**
+ * 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"

package/WebDriverAgentTests/IntegrationTests_watchOS/WDAAlertIntegrationTests.swift

@@ -8,16 +8,18 @@
 
 import XCTest
 
-/// Covers FBAlertViewCommands' error path - IntegrationApp_watchOS never presents a real alert,
-/// so this only exercises the "no alert open" error, not the success path.
-final class WDAAlertIntegrationTests: WDAWatchIntegrationTestCase {
-  func testAlertTextWithNoAlertPresentReturnsAnError() throws {
-    let response = try client.get("/session/\(sessionId!)/alert/text")
-    XCTAssertNotEqual(response.statusCode, 200)
+/// 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 testAlertButtonsWithNoAlertPresentReturnsAnError() throws {
-    let response = try client.get("/session/\(sessionId!)/wda/alert/buttons")
-    XCTAssertNotEqual(response.statusCode, 200)
+  func testAlertButtonsWithNoAlertPresentReturnsNil() {
+    XCTAssertNil(FBAlert(application: app).buttonLabels())
   }
 }

package/WebDriverAgentTests/IntegrationTests_watchOS/WDAAppLifecycleIntegrationTests.swift

@@ -8,50 +8,30 @@
 
 import XCTest
 
-/// Covers the app lifecycle routes (launch/activate/terminate/state/list). Unlike
-/// /wda/homescreen or /wda/lock, these only ever target IntegrationApp_watchOS, so they're
-/// safe to run repeatedly without disrupting shared simulator state.
-final class WDAAppLifecycleIntegrationTests: WDAWatchIntegrationTestCase {
-  // XCUIApplicationState raw values: NotRunning = 1, RunningForeground = 4.
-  private static let notRunningState = 1
-  private static let runningForegroundState = 4
-
-  func testAppsListIncludesTheAppUnderTest() throws {
-    let response = try client.get("/session/\(sessionId!)/wda/apps/list")
-    XCTAssertEqual(response.statusCode, 200)
-    guard let apps = response.value as? [[String: Any]] else {
-      return XCTFail("Expected an array of active apps: \(String(describing: response.json))")
-    }
-    XCTAssertTrue(apps.contains { $0["bundleId"] as? String == Self.integrationAppBundleId })
+/// 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() throws {
-    let bundleId = Self.integrationAppBundleId
-
-    let terminateResponse = try client.post("/session/\(sessionId!)/wda/apps/terminate", body: ["bundleId": bundleId])
-    XCTAssertEqual(terminateResponse.statusCode, 200)
-    XCTAssertEqual(terminateResponse.value as? Bool, true)
-
-    let stateAfterTerminate = try client.post("/session/\(sessionId!)/wda/apps/state", body: ["bundleId": bundleId])
-    XCTAssertEqual(stateAfterTerminate.value as? Int, Self.notRunningState)
+  func testTerminateThenRelaunchLifecycle() {
+    app.terminate()
+    XCTAssertEqual(app.state, .notRunning)
 
-    let launchResponse = try client.post("/session/\(sessionId!)/wda/apps/launch", body: ["bundleId": bundleId])
-    XCTAssertEqual(launchResponse.statusCode, 200)
-    Thread.sleep(forTimeInterval: 1)
-
-    let stateAfterLaunch = try client.post("/session/\(sessionId!)/wda/apps/state", body: ["bundleId": bundleId])
-    XCTAssertEqual(stateAfterLaunch.value as? Int, Self.runningForegroundState)
+    app.launch()
+    XCTAssertEqual(app.state, .runningForeground)
 
     // The app relaunched fresh, so its accessibility tree should be back too.
-    XCTAssertNoThrow(try findElement(byAccessibilityId: "tapMeButton"))
+    XCTAssertTrue(app.buttons["tapMeButton"].waitForExistence(timeout: 15))
   }
 
-  func testActivateBringsTheAppToTheForeground() throws {
-    let bundleId = Self.integrationAppBundleId
-    let activateResponse = try client.post("/session/\(sessionId!)/wda/apps/activate", body: ["bundleId": bundleId])
-    XCTAssertEqual(activateResponse.statusCode, 200)
-
-    let stateResponse = try client.post("/session/\(sessionId!)/wda/apps/state", body: ["bundleId": bundleId])
-    XCTAssertEqual(stateResponse.value as? Int, Self.runningForegroundState)
+  func testActivateBringsTheAppToTheForeground() {
+    app.activate()
+    XCTAssertEqual(app.state, .runningForeground)
   }
 }

package/WebDriverAgentTests/IntegrationTests_watchOS/WDAClickIntegrationTests.swift

@@ -8,24 +8,18 @@
 
 import XCTest
 
-/// Covers /element/:uuid/click - the only tap-like interaction registered on watchOS
-/// (gesture synthesis routes aren't).
-final class WDAClickIntegrationTests: WDAWatchIntegrationTestCase {
-  func testClickingButtonUpdatesTheResultLabel() throws {
-    let labelId = try findElement(byAccessibilityId: "resultLabel")
-    XCTAssertEqual(try attributeValue(labelId, "label"), "Idle")
+/// 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")
 
-    let buttonId = try findElement(byAccessibilityId: "tapMeButton")
-    let clickResponse = try client.post("/session/\(sessionId!)/element/\(buttonId)/click")
-    XCTAssertEqual(clickResponse.statusCode, 200)
+    app.buttons["tapMeButton"].tap()
 
-    // Re-find: element UUIDs aren't stable across snapshots, and the label just changed.
-    let updatedLabelId = try findElement(byAccessibilityId: "resultLabel")
-    XCTAssertEqual(try attributeValue(updatedLabelId, "label"), "Tapped")
-  }
-
-  func testClickingAnElementThatDoesNotExistReturnsAnError() throws {
-    let response = try client.post("/session/\(sessionId!)/element/00000000-0000-0000-0000-000000000000/click")
-    XCTAssertNotEqual(response.statusCode, 200)
+    XCTAssertEqual(label.wdValue ?? label.wdLabel, "Tapped")
   }
 }

package/WebDriverAgentTests/IntegrationTests_watchOS/WDADeviceIntegrationTests.swift

@@ -6,45 +6,87 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+import CoreLocation
+import WatchKit
 import XCTest
 
-/// Covers device-info and location routes. These only read device state or set a simulated
-/// GPS fix, so unlike /wda/lock or /wda/voiceOver/enable, they won't disrupt later tests.
-final class WDADeviceIntegrationTests: WDAWatchIntegrationTestCase {
-  func testDeviceInfo() throws {
-    let response = try client.get("/session/\(sessionId!)/wda/device/info")
-    XCTAssertEqual(response.statusCode, 200)
-    XCTAssertFalse((response.valueDict?["name"] as? String ?? "").isEmpty)
-    XCTAssertFalse((response.valueDict?["model"] as? String ?? "").isEmpty)
+/// 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() throws {
-    let response = try client.get("/session/\(sessionId!)/wda/activeAppInfo")
-    XCTAssertEqual(response.statusCode, 200)
-    XCTAssertEqual(response.valueDict?["bundleId"] as? String, Self.integrationAppBundleId)
-    XCTAssertGreaterThan(response.valueDict?["pid"] as? Int ?? 0, 0)
+  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 testDeviceLocation() throws {
-    let response = try client.get("/session/\(sessionId!)/wda/device/location")
-    XCTAssertEqual(response.statusCode, 200)
-    XCTAssertNotNil(response.valueDict?["latitude"])
-    XCTAssertNotNil(response.valueDict?["authorizationStatus"])
+  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()
   }
 
-  func testSimulatedLocationRoundTrip() throws {
-    let setResponse = try client.post("/session/\(sessionId!)/wda/simulatedLocation", body: [
-      "latitude": 37.3230,
-      "longitude": -122.0322,
-    ])
-    XCTAssertEqual(setResponse.statusCode, 200)
-
-    let getResponse = try client.get("/session/\(sessionId!)/wda/simulatedLocation")
-    XCTAssertEqual(getResponse.statusCode, 200)
-    XCTAssertEqual(getResponse.valueDict?["latitude"] as? Double ?? 0, 37.3230, accuracy: 0.001)
-    XCTAssertEqual(getResponse.valueDict?["longitude"] as? Double ?? 0, -122.0322, accuracy: 0.001)
-
-    let clearResponse = try client.delete("/session/\(sessionId!)/wda/simulatedLocation")
-    XCTAssertEqual(clearResponse.statusCode, 200)
+  /// 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/WebDriverAgentTests/IntegrationTests_watchOS/WDAElementAttributeIntegrationTests.swift

@@ -8,50 +8,32 @@
 
 import XCTest
 
-/// Covers FBElementCommands' read-only element/window attribute routes.
-final class WDAElementAttributeIntegrationTests: WDAWatchIntegrationTestCase {
-  func testWindowSizeAndRect() throws {
-    let sizeResponse = try client.get("/session/\(sessionId!)/window/size")
-    XCTAssertEqual(sizeResponse.statusCode, 200)
-    XCTAssertGreaterThan(sizeResponse.valueDict?["width"] as? Double ?? 0, 0)
-    XCTAssertGreaterThan(sizeResponse.valueDict?["height"] as? Double ?? 0, 0)
-
-    let rectResponse = try client.get("/session/\(sessionId!)/window/rect")
-    XCTAssertEqual(rectResponse.statusCode, 200)
-    XCTAssertGreaterThan(rectResponse.valueDict?["width"] as? Double ?? 0, 0)
+/// 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() throws {
-    let buttonId = try findElement(byAccessibilityId: "tapMeButton")
-
-    let enabledResponse = try client.get("/session/\(sessionId!)/element/\(buttonId)/enabled")
-    XCTAssertEqual(enabledResponse.value as? Bool, true)
-
-    let displayedResponse = try client.get("/session/\(sessionId!)/element/\(buttonId)/displayed")
-    XCTAssertEqual(displayedResponse.value as? Bool, true)
-
-    let rectResponse = try client.get("/session/\(sessionId!)/element/\(buttonId)/rect")
-    XCTAssertEqual(rectResponse.statusCode, 200)
-    XCTAssertGreaterThan(rectResponse.valueDict?["width"] as? Double ?? 0, 0)
-
-    let nameResponse = try client.get("/session/\(sessionId!)/element/\(buttonId)/name")
-    XCTAssertEqual(nameResponse.valueString, "XCUIElementTypeButton")
-
-    let labelResponse = try client.get("/session/\(sessionId!)/element/\(buttonId)/attribute/label")
-    XCTAssertEqual(labelResponse.valueString, "Tap Me")
-
-    let accessibleResponse = try client.get("/session/\(sessionId!)/wda/element/\(buttonId)/accessible")
-    XCTAssertEqual(accessibleResponse.statusCode, 200)
+  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() throws {
-    let labelId = try findElement(byAccessibilityId: "resultLabel")
-
-    let textResponse = try client.get("/session/\(sessionId!)/element/\(labelId)/text")
-    XCTAssertEqual(textResponse.valueString, "Idle")
-
-    let selectedResponse = try client.get("/session/\(sessionId!)/element/\(labelId)/selected")
-    XCTAssertEqual(selectedResponse.statusCode, 200)
-    XCTAssertEqual(selectedResponse.value as? Bool, false)
+  func testResultLabelTextAndSelectedState() {
+    let label = app.staticTexts["resultLabel"]
+    XCTAssertEqual(label.wdValue ?? label.wdLabel, "Idle")
+    XCTAssertFalse(label.isWDSelected)
   }
 }