@devicelab/maestro-runner-darwin-arm64 1.1.25 → 1.1.28

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIDevice+FBRotation.m

@@ -13,7 +13,7 @@
 #import "XCUIApplication+FBHelpers.h"
 #import "XCUIElement+FBUtilities.h"
 
-# if !TARGET_OS_TV
+# if !TARGET_OS_TV && !TARGET_OS_WATCH
 
 @implementation XCUIDevice (FBRotation)
 
@@ -30,19 +30,59 @@
   if (keysForRotationObj.count == 0) {
     return NO;
   }
-  NSInteger orientation = keysForRotationObj.firstObject.integerValue;
+  UIDeviceOrientation orientation = (UIDeviceOrientation)keysForRotationObj.firstObject.integerValue;
   XCUIApplication *application = XCUIApplication.fb_activeApplication;
   [XCUIDevice sharedDevice].orientation = orientation;
   return [self waitUntilInterfaceIsAtOrientation:orientation application:application];
 }
 
-- (BOOL)waitUntilInterfaceIsAtOrientation:(NSInteger)orientation application:(XCUIApplication *)application
+static UIInterfaceOrientation FBInterfaceOrientationFromDeviceOrientation(UIDeviceOrientation orientation)
+{
+  switch (orientation) {
+    case UIDeviceOrientationPortrait:
+      return UIInterfaceOrientationPortrait;
+    case UIDeviceOrientationPortraitUpsideDown:
+      return UIInterfaceOrientationPortraitUpsideDown;
+    case UIDeviceOrientationLandscapeLeft:
+      return UIInterfaceOrientationLandscapeRight;
+    case UIDeviceOrientationLandscapeRight:
+      return UIInterfaceOrientationLandscapeLeft;
+    case UIDeviceOrientationUnknown:
+    case UIDeviceOrientationFaceUp:
+    case UIDeviceOrientationFaceDown:
+    default:
+      return UIInterfaceOrientationUnknown;
+  }
+}
+
+- (BOOL)waitUntilInterfaceIsAtOrientation:(UIDeviceOrientation)orientation application:(XCUIApplication *)application
 {
   // Tapping elements immediately after rotation may fail due to way UIKit is handling touches.
   // We should wait till UI cools off, before continuing
-  [application fb_waitUntilStableWithTimeout:FBConfiguration.animationCoolOffTimeout];
+  [application fb_waitUntilStableWithTimeout:FBConfiguration.sharedInstance.animationCoolOffTimeout];
 
-  return application.interfaceOrientation == orientation;
+  return application.interfaceOrientation == FBInterfaceOrientationFromDeviceOrientation(orientation);
+}
+
+- (NSString *)fb_deviceOrientation
+{
+  switch (self.orientation) {
+    case UIDeviceOrientationPortrait:
+      return @"UIDeviceOrientationPortrait";
+    case UIDeviceOrientationPortraitUpsideDown:
+      return @"UIDeviceOrientationPortraitUpsideDown";
+    case UIDeviceOrientationLandscapeLeft:
+      return @"UIDeviceOrientationLandscapeLeft";
+    case UIDeviceOrientationLandscapeRight:
+      return @"UIDeviceOrientationLandscapeRight";
+    case UIDeviceOrientationFaceUp:
+      return @"UIDeviceOrientationFaceUp";
+    case UIDeviceOrientationFaceDown:
+      return @"UIDeviceOrientationFaceDown";
+    case UIDeviceOrientationUnknown:
+    default:
+      return @"UIDeviceOrientationUnknown";
+  }
 }
 
 - (NSDictionary *)fb_rotationMapping

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIDevice+FBVoiceOver.h

@@ -0,0 +1,66 @@
+/**
+ * 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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface XCUIDevice (FBVoiceOver)
+
+/**
+ Whether VoiceOver control APIs are available in the current OS runtime.
+
+ @return YES if the VoiceOver service is exposed by XCUIDevice
+ */
+- (BOOL)fb_isVoiceOverServiceAvailable;
+
+/**
+ Enable VoiceOver. Only works since iOS 27 runtime.
+
+ @param error If there is an error, upon return contains an NSError object that describes the problem.
+ @return YES if VoiceOver has been successfully enabled
+ */
+- (BOOL)fb_enableVoiceOver:(NSError **)error;
+
+/**
+ Disable VoiceOver. Only works since iOS 27 runtime.
+
+ @param error If there is an error, upon return contains an NSError object that describes the problem.
+ @return YES if VoiceOver has been successfully disabled
+ */
+- (BOOL)fb_disableVoiceOver:(NSError **)error;
+
+/**
+ Whether VoiceOver is currently enabled. Only works since iOS 27 runtime.
+
+ @param error If there is an error, upon return contains an NSError object that describes the problem.
+ @return YES if VoiceOver is enabled
+ */
+- (BOOL)fb_isVoiceOverEnabled:(NSError **)error;
+
+/**
+ Move VoiceOver focus and return speech for the newly focused element.
+ Only works since iOS 27 runtime.
+
+ @param direction One of: forward, backward, in (iOS only), out (iOS only)
+ @param error If there is an error, upon return contains an NSError object that describes the problem.
+ @return The spoken utterance or nil in case of failure
+ */
+- (nullable NSString *)fb_voiceOverMove:(NSString *)direction error:(NSError **)error;
+
+/**
+ Return the speech for the currently focused element. Only works since iOS 27 runtime.
+
+ @param error If there is an error, upon return contains an NSError object that describes the problem.
+ @return The spoken utterance or nil in case of failure
+ */
+- (nullable NSString *)fb_voiceOverCurrentSpeech:(NSError **)error;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIDevice+FBVoiceOver.m

@@ -0,0 +1,218 @@
+/**
+ * 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 "XCUIDevice+FBVoiceOver.h"
+
+#import "FBErrorBuilder.h"
+
+static NSString *const FBVoiceOverSDKUnsupportedError =
+@"The current OS runtime does not support VoiceOver control. This API requires an iOS 27+ runtime";
+
+static BOOL FBVoiceOverBuildSDKUnsupportedError(NSError **error)
+{
+  return [[[FBErrorBuilder builder]
+           withDescription:FBVoiceOverSDKUnsupportedError]
+          buildError:error];
+}
+
+static BOOL FBIsVoiceOverServiceAvailable(void)
+{
+  static BOOL isAvailable = NO;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    isAvailable = [XCUIDevice.sharedDevice respondsToSelector:NSSelectorFromString(@"voiceOverService")];
+  });
+  return isAvailable;
+}
+
+static id FBVoiceOverService(NSError **error)
+{
+  if (!FBIsVoiceOverServiceAvailable()) {
+    FBVoiceOverBuildSDKUnsupportedError(error);
+    return nil;
+  }
+  return [XCUIDevice.sharedDevice valueForKey:@"voiceOverService"];
+}
+
+static BOOL FBInvokeVoiceOverBoolMethod(id voiceOverService,
+                                        SEL selector,
+                                        NSError **error)
+{
+  if (![voiceOverService respondsToSelector:selector]) {
+    return FBVoiceOverBuildSDKUnsupportedError(error);
+  }
+
+  NSMethodSignature *signature = [voiceOverService methodSignatureForSelector:selector];
+  NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
+  [invocation setSelector:selector];
+  [invocation setTarget:voiceOverService];
+  NSError *invokeError = nil;
+  [invocation setArgument:&invokeError atIndex:2];
+  [invocation invoke];
+  if (nil != invokeError) {
+    if (error) {
+      *error = invokeError;
+    }
+    return NO;
+  }
+
+  BOOL result = NO;
+  [invocation getReturnValue:&result];
+  return result;
+}
+
+static id FBInvokeVoiceOverOutputMethod(id voiceOverService,
+                                        SEL selector,
+                                        NSError **error)
+{
+  if (![voiceOverService respondsToSelector:selector]) {
+    FBVoiceOverBuildSDKUnsupportedError(error);
+    return nil;
+  }
+
+  NSMethodSignature *signature = [voiceOverService methodSignatureForSelector:selector];
+  NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
+  [invocation setSelector:selector];
+  [invocation setTarget:voiceOverService];
+  NSError *invokeError = nil;
+  [invocation setArgument:&invokeError atIndex:2];
+  [invocation invoke];
+  if (nil != invokeError) {
+    if (error) {
+      *error = invokeError;
+    }
+    return nil;
+  }
+
+  id __unsafe_unretained output = nil;
+  [invocation getReturnValue:&output];
+  return output;
+}
+
+static NSString *FBUtteranceFromVoiceOverOutput(id output, NSError **error)
+{
+  if (nil == output) {
+    return nil;
+  }
+
+  if (![output respondsToSelector:NSSelectorFromString(@"utterance")]) {
+    [[[FBErrorBuilder builder]
+      withDescription:@"VoiceOver output does not provide an utterance"]
+     buildError:error];
+    return nil;
+  }
+
+  id utterance = [output valueForKey:@"utterance"];
+  return [utterance isKindOfClass:NSString.class] ? utterance : nil;
+}
+
+static NSString *FBVoiceOverSpeechFromSelector(SEL selector, NSError **error)
+{
+  id service = FBVoiceOverService(error);
+  if (nil == service) {
+    return nil;
+  }
+
+  id output = FBInvokeVoiceOverOutputMethod(service, selector, error);
+  if (nil != error && nil != *error) {
+    return nil;
+  }
+  return FBUtteranceFromVoiceOverOutput(output, error);
+}
+
+static NSDictionary<NSString *, NSString *> *FBVoiceOverMoveSelectors(void)
+{
+  static NSDictionary<NSString *, NSString *> *selectors = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSMutableDictionary<NSString *, NSString *> *mapping = [@{
+      @"forward": @"moveForwardAndReturnError:",
+      @"backward": @"moveBackwardAndReturnError:",
+    } mutableCopy];
+#if TARGET_OS_IOS
+    mapping[@"in"] = @"moveInAndReturnError:";
+    mapping[@"out"] = @"moveOutAndReturnError:";
+#endif
+    selectors = mapping.copy;
+  });
+  return selectors;
+}
+
+@implementation XCUIDevice (FBVoiceOver)
+
+- (BOOL)fb_isVoiceOverServiceAvailable
+{
+  return FBIsVoiceOverServiceAvailable();
+}
+
+- (BOOL)fb_enableVoiceOver:(NSError **)error
+{
+  id service = FBVoiceOverService(error);
+  if (nil == service) {
+    return NO;
+  }
+  return FBInvokeVoiceOverBoolMethod(service,
+                                     NSSelectorFromString(@"enableAndReturnError:"),
+                                     error);
+}
+
+- (BOOL)fb_disableVoiceOver:(NSError **)error
+{
+  id service = FBVoiceOverService(error);
+  if (nil == service) {
+    return NO;
+  }
+  return FBInvokeVoiceOverBoolMethod(service,
+                                     NSSelectorFromString(@"disableAndReturnError:"),
+                                     error);
+}
+
+- (BOOL)fb_isVoiceOverEnabled:(NSError **)error
+{
+  id service = FBVoiceOverService(error);
+  if (nil == service) {
+    return NO;
+  }
+
+  if (![service respondsToSelector:NSSelectorFromString(@"isEnabled")] &&
+      ![service respondsToSelector:NSSelectorFromString(@"enabled")]) {
+    return FBVoiceOverBuildSDKUnsupportedError(error);
+  }
+
+  return [[service valueForKey:@"enabled"] boolValue];
+}
+
+- (nullable NSString *)fb_voiceOverMove:(NSString *)direction error:(NSError **)error
+{
+  if (![direction isKindOfClass:NSString.class] || 0 == direction.length) {
+    [[[FBErrorBuilder builder]
+      withDescription:@"VoiceOver move direction must be a non-empty string"]
+     buildError:error];
+    return nil;
+  }
+
+  NSString *normalizedDirection = direction.lowercaseString;
+  NSString *selectorName = FBVoiceOverMoveSelectors()[normalizedDirection];
+  if (nil == selectorName) {
+    NSArray *supportedDirections = [FBVoiceOverMoveSelectors().allKeys sortedArrayUsingSelector:@selector(compare:)];
+    [[[FBErrorBuilder builder]
+      withDescriptionFormat:@"Unsupported VoiceOver move direction '%@'. Supported directions: %@",
+      direction, supportedDirections]
+     buildError:error];
+    return nil;
+  }
+
+  return FBVoiceOverSpeechFromSelector(NSSelectorFromString(selectorName), error);
+}
+
+- (nullable NSString *)fb_voiceOverCurrentSpeech:(NSError **)error
+{
+  return FBVoiceOverSpeechFromSelector(NSSelectorFromString(@"currentSpeechAndReturnError:"), error);
+}
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBClassChain.m

@@ -11,6 +11,7 @@
 #import "FBClassChainQueryParser.h"
 #import "FBXCodeCompatibility.h"
 #import "FBExceptions.h"
+#import "XCUIElement+FBUtilities.h"
 
 @implementation XCUIElement (FBClassChain)
 
@@ -22,7 +23,39 @@
     @throw [NSException exceptionWithName:FBClassChainQueryParseException reason:error.localizedDescription userInfo:error.userInfo];
     return nil;
   }
-  NSMutableArray<FBClassChainItem *> *lookupChain = parsedChain.elements.mutableCopy;
+  // The snapshot-walk strategy below only pays off when an intermediate
+  // (non-final) segment carries an explicit position: that is the only
+  // shape where the query-based strategy has to resolve a live element
+  // mid-chain - and pay an accessibility round trip - just to keep building
+  // the next segment's query. Every other shape (including the common case
+  // of zero or one position, on the final segment only) already resolves in
+  // a single round trip with the query-based strategy, while the snapshot
+  // walk always pays for one full upfront subtree snapshot regardless of
+  // whether it is actually needed - a bad trade in deep/large trees. See
+  // https://github.com/appium/WebDriverAgent/pull/1194#issuecomment-5156633352
+  NSArray<FBClassChainItem *> *chainItems = parsedChain.elements;
+  return [self.class fb_hasIntermediatePosition:chainItems]
+    ? [self fb_snapshotDescendantsMatchingChainItems:chainItems shouldReturnAfterFirstMatch:shouldReturnAfterFirstMatch]
+    : [self fb_queryDescendantsMatchingChainItems:chainItems shouldReturnAfterFirstMatch:shouldReturnAfterFirstMatch];
+}
+
++ (BOOL)fb_hasIntermediatePosition:(NSArray<FBClassChainItem *> *)chainItems
+{
+  for (NSUInteger i = 0; i + 1 < chainItems.count; i++) {
+    if (nil != chainItems[i].position) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+#pragma mark - Query-based strategy
+#pragma mark (single accessibility round trip; used whenever no intermediate
+#pragma mark  segment carries an explicit position)
+
+- (NSArray<XCUIElement *> *)fb_queryDescendantsMatchingChainItems:(NSArray<FBClassChainItem *> *)chainItems shouldReturnAfterFirstMatch:(BOOL)shouldReturnAfterFirstMatch
+{
+  NSMutableArray<FBClassChainItem *> *lookupChain = chainItems.mutableCopy;
   FBClassChainItem *chainItem = lookupChain.firstObject;
   XCUIElement *currentRoot = self;
   XCUIElementQuery *query = [currentRoot fb_queryWithChainItem:chainItem query:nil];
@@ -30,8 +63,6 @@
   while (lookupChain.count > 0) {
     BOOL isRootChanged = NO;
     if (nil != chainItem.position) {
-      // It is necessary to resolve the query if intermediate element index is not zero or one,
-      // because predicates don't support search by indexes
       NSArray<XCUIElement *> *currentRootMatch = [self.class fb_matchingElementsWithItem:chainItem
                                                                                    query:query
                                                              shouldReturnAfterFirstMatch:nil];
@@ -95,4 +126,114 @@
   return @[];
 }
 
+#pragma mark - Snapshot-based strategy
+#pragma mark (single upfront snapshot walked in memory; used when an
+#pragma mark  intermediate segment has an explicit position, avoiding one
+#pragma mark  extra accessibility round trip per such segment)
+
+- (NSArray<XCUIElement *> *)fb_snapshotDescendantsMatchingChainItems:(NSArray<FBClassChainItem *> *)chainItems shouldReturnAfterFirstMatch:(BOOL)shouldReturnAfterFirstMatch
+{
+  NSMutableArray<FBClassChainItem *> *lookupChain = chainItems.mutableCopy;
+  // self.lastSnapshot may be stale leftover from an unrelated earlier command.
+  NSArray<id<FBXCElementSnapshot>> *currentRoots = @[self.fb_cachedSnapshot ?: [self fb_customSnapshot]];
+  FBClassChainItem *chainItem = lookupChain.firstObject;
+  NSArray<id<FBXCElementSnapshot>> *candidates = [self.class fb_snapshotsMatchingItem:chainItem inRoots:currentRoots];
+  [lookupChain removeObjectAtIndex:0];
+  while (lookupChain.count > 0) {
+    if (nil != chainItem.position) {
+      // An explicit position always narrows the match set down to a single
+      // element, which becomes the sole root for the rest of the chain, so
+      // it has to be resolved now instead of being folded into `candidates`
+      // like an unindexed segment would be
+      NSArray<id<FBXCElementSnapshot>> *currentRootMatch = [self.class fb_matchingSnapshotsWithItem:chainItem
+                                                                                           candidates:candidates
+                                                                          shouldReturnAfterFirstMatch:nil];
+      if (0 == currentRootMatch.count) {
+        return @[];
+      }
+      currentRoots = @[(id<FBXCElementSnapshot> _Nonnull)currentRootMatch.firstObject];
+    } else {
+      currentRoots = candidates;
+    }
+    chainItem = lookupChain.firstObject;
+    candidates = [self.class fb_snapshotsMatchingItem:chainItem inRoots:currentRoots];
+    [lookupChain removeObjectAtIndex:0];
+  }
+  NSArray<id<FBXCElementSnapshot>> *matchedSnapshots = [self.class fb_matchingSnapshotsWithItem:chainItem
+                                                                                      candidates:candidates
+                                                                     shouldReturnAfterFirstMatch:@(shouldReturnAfterFirstMatch)];
+  return [self fb_filterDescendantsWithSnapshots:matchedSnapshots onlyChildren:NO];
+}
+
++ (NSArray<id<FBXCElementSnapshot>> *)fb_snapshotsMatchingItem:(FBClassChainItem *)item inRoots:(NSArray<id<FBXCElementSnapshot>> *)roots
+{
+  NSMutableArray<id<FBXCElementSnapshot>> *typeMatches = [NSMutableArray array];
+  for (id<FBXCElementSnapshot> root in roots) {
+    if (item.isDescendant) {
+      // descendantsByFilteringWithBlock: includes the receiver itself if it
+      // matches the filter, unlike XCUIElementQuery's descendantsMatchingType:,
+      // so the root has to be excluded explicitly here.
+      [typeMatches addObjectsFromArray:[root descendantsByFilteringWithBlock:^BOOL(id<FBXCElementSnapshot> snapshot) {
+        return snapshot != root && (item.type == XCUIElementTypeAny || snapshot.elementType == item.type);
+      }]];
+    } else {
+      for (id<FBXCElementSnapshot> child in root.children) {
+        if (item.type == XCUIElementTypeAny || child.elementType == item.type) {
+          [typeMatches addObject:child];
+        }
+      }
+    }
+  }
+  if (roots.count > 1) {
+    // Overlapping roots (e.g. a previous segment matched both an ancestor
+    // and its own descendant) can otherwise yield the same snapshot twice,
+    // which would skew positional selection ([2], [-1], etc.) compared to
+    // the XCUIElementQuery-based matching this replaced, which always
+    // operated on a de-duplicated element set.
+    NSMutableArray<id<FBXCElementSnapshot>> *dedupedMatches = [NSMutableArray arrayWithCapacity:typeMatches.count];
+    NSHashTable<id<FBXCElementSnapshot>> *seenMatches = [NSHashTable hashTableWithOptions:NSHashTableObjectPointerPersonality];
+    for (id<FBXCElementSnapshot> match in typeMatches) {
+      if (![seenMatches containsObject:match]) {
+        [seenMatches addObject:match];
+        [dedupedMatches addObject:match];
+      }
+    }
+    typeMatches = dedupedMatches;
+  }
+  for (FBAbstractPredicateItem *predicateItem in item.predicates) {
+    if ([predicateItem isKindOfClass:FBSelfPredicateItem.class]) {
+      typeMatches = [[typeMatches filteredArrayUsingPredicate:predicateItem.value] mutableCopy];
+    } else if ([predicateItem isKindOfClass:FBDescendantPredicateItem.class]) {
+      NSMutableArray<id<FBXCElementSnapshot>> *containingMatches = [NSMutableArray array];
+      for (id<FBXCElementSnapshot> candidate in typeMatches) {
+        NSArray<id<FBXCElementSnapshot>> *matchingDescendants = [candidate descendantsByFilteringWithBlock:^BOOL(id<FBXCElementSnapshot> descendant) {
+          return descendant != candidate && [predicateItem.value evaluateWithObject:descendant];
+        }];
+        if (matchingDescendants.count > 0) {
+          [containingMatches addObject:candidate];
+        }
+      }
+      typeMatches = containingMatches;
+    }
+  }
+  return typeMatches.copy;
+}
+
++ (NSArray<id<FBXCElementSnapshot>> *)fb_matchingSnapshotsWithItem:(FBClassChainItem *)item candidates:(NSArray<id<FBXCElementSnapshot>> *)candidates shouldReturnAfterFirstMatch:(nullable NSNumber *)shouldReturnAfterFirstMatch
+{
+  if (1 == item.position.integerValue || (0 == item.position.integerValue && shouldReturnAfterFirstMatch.boolValue)) {
+    id<FBXCElementSnapshot> result = candidates.firstObject;
+    return result ? @[result] : @[];
+  }
+  if (0 == item.position.integerValue) {
+    return candidates;
+  }
+  if (candidates.count >= (NSUInteger)ABS(item.position.integerValue)) {
+    return item.position.integerValue > 0
+      ? @[[candidates objectAtIndex:item.position.integerValue - 1]]
+      : @[[candidates objectAtIndex:candidates.count + item.position.integerValue]];
+  }
+  return @[];
+}
+
 @end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBFind.m

@@ -109,7 +109,7 @@
     id<FBXCElementSnapshot> snapshot = matchingSnapshots.firstObject;
     matchingSnapshots = @[snapshot];
   }
-  XCUIElement *scopeRoot = FBConfiguration.limitXpathContextScope ? self : self.application;
+  XCUIElement *scopeRoot = FBConfiguration.sharedInstance.limitXpathContextScope ? self : self.application;
   return [scopeRoot fb_filterDescendantsWithSnapshots:matchingSnapshots
                                          onlyChildren:NO];
 }

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBForceTouch.m

@@ -11,6 +11,7 @@
 #if !TARGET_OS_TV
 
 #import "FBErrorBuilder.h"
+#import "FBMathUtils.h"
 #import "XCUICoordinate.h"
 #import "XCUIDevice.h"
 
@@ -36,8 +37,10 @@
   } else {
     CGVector offset = CGVectorMake(relativeCoordinate.CGPointValue.x,
                                    relativeCoordinate.CGPointValue.y);
-    XCUICoordinate *hitPoint = [[self coordinateWithNormalizedOffset:CGVectorMake(0, 0)]
-                                coordinateWithOffset:offset];
+    XCUICoordinate *hitPoint = FBCoordinateWithAnchorOffset(self, CGVectorMake(0, 0), offset, error);
+    if (nil == hitPoint) {
+      return NO;
+    }
     if (nil == pressure || nil == duration) {
       [hitPoint forcePress];
     } else {

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBPickerWheel.m

@@ -16,7 +16,7 @@
 #import "XCUIElement+FBCaching.h"
 #import "XCUIElement+FBResolve.h"
 
-#if !TARGET_OS_TV
+#if !TARGET_OS_TV && !TARGET_OS_WATCH
 @implementation XCUIElement (FBPickerWheel)
 
 static const NSTimeInterval VALUE_CHANGE_TIMEOUT = 2;
@@ -25,8 +25,9 @@ static const NSTimeInterval VALUE_CHANGE_TIMEOUT = 2;
 {
   id<FBXCElementSnapshot> snapshot = [self fb_standardSnapshot];
   NSString *previousValue = snapshot.value;
-  XCUICoordinate *startCoord = [self coordinateWithNormalizedOffset:CGVectorMake(0.5, 0.5)];
-  XCUICoordinate *endCoord = [startCoord coordinateWithOffset:CGVectorMake(0.0, relativeHeightOffset * snapshot.frame.size.height)];
+  // Stay in normalized offsets end-to-end: XCTest never rescales a composed raw
+  // coordinateWithOffset: for compatibility-mode windows (appium/appium#16185).
+  XCUICoordinate *endCoord = [self coordinateWithNormalizedOffset:CGVectorMake(0.5, 0.5 + relativeHeightOffset)];
   // If picker value is reflected in its accessiblity id
   // then fetching of the next snapshot may fail with StaleElementReferenceError
   // because we bound elements by their accessbility ids by default.