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

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBXPathExtensions.m

@@ -0,0 +1,418 @@
+/**
+ * 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 "FBXPathExtensions.h"
+
+#import "FBLogger.h"
+
+#import <libxml/xpathInternals.h>
+
+static void FBRegisterXPathExtensions(xmlXPathContextPtr xpathCtx);
+
+static NSString *const FBXPathTokenSequenceSeparator = @"\x1E";
+static const NSRegularExpressionOptions FBXPathNoRegexOptions = (NSRegularExpressionOptions)0;
+static const NSMatchingOptions FBXPathNoMatchingOptions = (NSMatchingOptions)0;
+
+@interface FBXPathExtensions ()
+@property (nonatomic, nullable, readwrite, copy) NSString *lastEvaluationError;
+@end
+
+static FBXPathExtensions *FBXPathExtensionsFromParserContext(xmlXPathParserContextPtr ctxt)
+{
+  if (NULL == ctxt || NULL == ctxt->context || NULL == ctxt->context->userData) {
+    return nil;
+  }
+  return (__bridge FBXPathExtensions *)ctxt->context->userData;
+}
+
+static void FBXPathSetEvaluationError(xmlXPathParserContextPtr ctxt, int xpathErrorCode, NSString *message)
+{
+  FBXPathExtensions *extensions = FBXPathExtensionsFromParserContext(ctxt);
+  extensions.lastEvaluationError = message;
+  [FBLogger logFmt:@"XPath extension evaluation error: %@", message];
+  if (NULL == ctxt) {
+    return;
+  }
+  xmlXPatherror(ctxt, __FILE__, __LINE__, xpathErrorCode);
+  ctxt->error = xpathErrorCode;
+}
+
+static void FBXPathSetInvalidArityError(xmlXPathParserContextPtr ctxt)
+{
+  if (NULL == ctxt) {
+    return;
+  }
+  xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_INVALID_ARITY);
+  ctxt->error = XPATH_INVALID_ARITY;
+}
+
+static BOOL FBXPathFlagsAreValid(NSString *flags, BOOL allowsQFlag)
+{
+  if (nil == flags || 0 == flags.length) {
+    return YES;
+  }
+
+  NSString *validFlags = allowsQFlag ? @"imsxq" : @"imsx";
+  for (NSUInteger index = 0; index < flags.length; index++) {
+    unichar flag = [flags characterAtIndex:index];
+    if ([validFlags rangeOfString:[NSString stringWithCharacters:&flag length:1]].location == NSNotFound) {
+      return NO;
+    }
+  }
+  return YES;
+}
+
+static NSString *FBXPathStringFromUTF8Bytes(const xmlChar *bytes)
+{
+  if (NULL == bytes) {
+    return nil;
+  }
+  return [NSString stringWithUTF8String:(const char *)bytes];
+}
+
+@implementation FBXPathExtensions
+
+- (void)registerFunctionsWithContext:(xmlXPathContextPtr)xpathCtx
+{
+  xpathCtx->userData = (__bridge void *)self;
+  FBRegisterXPathExtensions(xpathCtx);
+}
+
+@end
+
+static NSString *FBXPathPopNSString(xmlXPathParserContextPtr ctxt)
+{
+  xmlChar *value = xmlXPathPopString(ctxt);
+  if (NULL == value || xmlXPathCheckError(ctxt)) {
+    return nil;
+  }
+  NSString *result = [NSString stringWithUTF8String:(const char *)value];
+  xmlFree(value);
+  return result;
+}
+
+static NSRegularExpressionOptions FBXPathRegexOptionsFromFlags(NSString *flags)
+{
+  NSRegularExpressionOptions options = FBXPathNoRegexOptions;
+  if (nil != flags && [flags rangeOfString:@"i"].location != NSNotFound) {
+    options |= NSRegularExpressionCaseInsensitive;
+  }
+  return options;
+}
+
+static NSRegularExpression *FBXPathRegexWithPattern(NSString *pattern,
+                                                  NSString *flags,
+                                                  BOOL allowsQFlag,
+                                                  xmlXPathParserContextPtr ctxt)
+{
+  if (!FBXPathFlagsAreValid(flags, allowsQFlag)) {
+    FBXPathSetEvaluationError(ctxt, XPATH_EXPR_ERROR, @"Invalid regular expression flags");
+    return nil;
+  }
+
+  NSError *error = nil;
+  NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:pattern
+                                                                         options:FBXPathRegexOptionsFromFlags(flags)
+                                                                           error:&error];
+  if (nil == regex) {
+    NSString *message = error.localizedDescription ?: @"Invalid regular expression";
+    FBXPathSetEvaluationError(ctxt, XPATH_EXPR_ERROR, message);
+    return nil;
+  }
+  return regex;
+}
+
+static BOOL FBXPathTokenizeString(NSString *input,
+                                  NSString *pattern,
+                                  xmlXPathParserContextPtr ctxt,
+                                  NSArray<NSString *> **outTokens)
+{
+  if (0 == input.length) {
+    *outTokens = @[];
+    return YES;
+  }
+
+  if (nil == pattern) {
+    NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:@"\\S+"
+                                                                           options:FBXPathNoRegexOptions
+                                                                             error:nil];
+    if (nil == regex) {
+      FBXPathSetEvaluationError(ctxt, XPATH_EXPR_ERROR, @"Invalid regular expression");
+      return NO;
+    }
+    NSMutableArray<NSString *> *tokens = [NSMutableArray array];
+    [regex enumerateMatchesInString:input
+                            options:FBXPathNoMatchingOptions
+                              range:NSMakeRange(0, input.length)
+                         usingBlock:^(NSTextCheckingResult *result, NSMatchingFlags flags, BOOL *stop) {
+      if (nil != result) {
+        [tokens addObject:[input substringWithRange:result.range]];
+      }
+    }];
+    *outTokens = tokens.copy;
+    return YES;
+  }
+
+  if (0 == pattern.length) {
+    NSMutableArray<NSString *> *tokens = [NSMutableArray array];
+    [input enumerateSubstringsInRange:NSMakeRange(0, input.length)
+                              options:NSStringEnumerationByComposedCharacterSequences
+                           usingBlock:^(NSString *substring, NSRange substringRange, NSRange enclosingRange, BOOL *stop) {
+      if (substring.length > 0) {
+        [tokens addObject:substring];
+      }
+    }];
+    *outTokens = tokens.copy;
+    return YES;
+  }
+
+  NSError *error = nil;
+  NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:pattern
+                                                                         options:FBXPathNoRegexOptions
+                                                                           error:&error];
+  if (nil == regex) {
+    NSString *message = error.localizedDescription ?: @"Invalid regular expression";
+    FBXPathSetEvaluationError(ctxt, XPATH_EXPR_ERROR, message);
+    return NO;
+  }
+
+  NSMutableArray<NSString *> *tokens = [NSMutableArray array];
+  __block NSUInteger lastIndex = 0;
+  [regex enumerateMatchesInString:input
+                          options:FBXPathNoMatchingOptions
+                            range:NSMakeRange(0, input.length)
+                       usingBlock:^(NSTextCheckingResult *result, NSMatchingFlags flags, BOOL *stop) {
+    if (nil == result) {
+      return;
+    }
+    if (result.range.location > lastIndex) {
+      NSString *token = [input substringWithRange:NSMakeRange(lastIndex, result.range.location - lastIndex)];
+      if (token.length > 0) {
+        [tokens addObject:token];
+      }
+    }
+    lastIndex = NSMaxRange(result.range);
+  }];
+  if (lastIndex < input.length) {
+    NSString *token = [input substringFromIndex:lastIndex];
+    if (token.length > 0) {
+      [tokens addObject:token];
+    }
+  }
+  *outTokens = tokens.copy;
+  return YES;
+}
+
+static void FBXPathReturnNSString(xmlXPathParserContextPtr ctxt, NSString *value)
+{
+  if (nil == value) {
+    xmlXPathReturnEmptyString(ctxt);
+    return;
+  }
+  xmlChar *copiedValue = xmlStrdup((const xmlChar *)[value UTF8String]);
+  if (NULL == copiedValue) {
+    xmlXPathReturnEmptyString(ctxt);
+    return;
+  }
+  // xmlXPathWrapString takes ownership of the buffer passed to xmlXPathReturnString.
+  xmlXPathReturnString(ctxt, copiedValue);
+}
+
+static NSArray<NSString *> *FBXPathPartsFromXPathObject(xmlXPathObjectPtr sequence)
+{
+  if (sequence->type == XPATH_NODESET && NULL != sequence->nodesetval) {
+    NSMutableArray<NSString *> *parts = [NSMutableArray array];
+    for (int index = 0; index < sequence->nodesetval->nodeNr; index++) {
+      xmlChar *content = xmlNodeGetContent(sequence->nodesetval->nodeTab[index]);
+      if (NULL != content) {
+        NSString *part = FBXPathStringFromUTF8Bytes(content);
+        xmlFree(content);
+        if (nil != part) {
+          [parts addObject:part];
+        }
+      }
+    }
+    return parts.copy;
+  }
+
+  xmlChar *asString = xmlXPathCastToString(sequence);
+  if (NULL == asString) {
+    return @[];
+  }
+  NSString *value = FBXPathStringFromUTF8Bytes(asString);
+  xmlFree(asString);
+  if (nil == value || 0 == value.length) {
+    return @[];
+  }
+  if ([value rangeOfString:FBXPathTokenSequenceSeparator].location != NSNotFound) {
+    return [value componentsSeparatedByString:FBXPathTokenSequenceSeparator];
+  }
+  return @[value];
+}
+
+static void FBXPathMatchesFunction(xmlXPathParserContextPtr ctxt, int nargs)
+{
+  if (nargs < 2 || nargs > 3) {
+    FBXPathSetInvalidArityError(ctxt);
+    return;
+  }
+
+  NSString *flags = nargs == 3 ? FBXPathPopNSString(ctxt) : nil;
+  NSString *pattern = FBXPathPopNSString(ctxt);
+  NSString *input = FBXPathPopNSString(ctxt);
+  if (nil == pattern || nil == input || xmlXPathCheckError(ctxt)) {
+    return;
+  }
+
+  NSRegularExpression *regex = FBXPathRegexWithPattern(pattern, flags, NO, ctxt);
+  if (nil == regex) {
+    return;
+  }
+
+  NSRange range = NSMakeRange(0, input.length);
+  NSTextCheckingResult *match = [regex firstMatchInString:input options:FBXPathNoMatchingOptions range:range];
+  xmlXPathReturnBoolean(ctxt, nil != match);
+}
+
+static void FBXPathEndsWithFunction(xmlXPathParserContextPtr ctxt, int nargs)
+{
+  if (nargs != 2) {
+    FBXPathSetInvalidArityError(ctxt);
+    return;
+  }
+
+  NSString *suffix = FBXPathPopNSString(ctxt);
+  NSString *input = FBXPathPopNSString(ctxt);
+  if (nil == suffix || nil == input || xmlXPathCheckError(ctxt)) {
+    return;
+  }
+
+  xmlXPathReturnBoolean(ctxt, [input hasSuffix:suffix]);
+}
+
+static void FBXPathLowerCaseFunction(xmlXPathParserContextPtr ctxt, int nargs)
+{
+  if (nargs != 1) {
+    FBXPathSetInvalidArityError(ctxt);
+    return;
+  }
+
+  NSString *input = FBXPathPopNSString(ctxt);
+  if (nil == input || xmlXPathCheckError(ctxt)) {
+    return;
+  }
+
+  FBXPathReturnNSString(ctxt, input.lowercaseString);
+}
+
+static void FBXPathUpperCaseFunction(xmlXPathParserContextPtr ctxt, int nargs)
+{
+  if (nargs != 1) {
+    FBXPathSetInvalidArityError(ctxt);
+    return;
+  }
+
+  NSString *input = FBXPathPopNSString(ctxt);
+  if (nil == input || xmlXPathCheckError(ctxt)) {
+    return;
+  }
+
+  FBXPathReturnNSString(ctxt, input.uppercaseString);
+}
+
+static void FBXPathReplaceFunction(xmlXPathParserContextPtr ctxt, int nargs)
+{
+  if (nargs < 3 || nargs > 4) {
+    FBXPathSetInvalidArityError(ctxt);
+    return;
+  }
+
+  NSString *flags = nargs == 4 ? FBXPathPopNSString(ctxt) : nil;
+  NSString *replacement = FBXPathPopNSString(ctxt);
+  NSString *pattern = FBXPathPopNSString(ctxt);
+  NSString *input = FBXPathPopNSString(ctxt);
+  if (nil == replacement || nil == pattern || nil == input || xmlXPathCheckError(ctxt)) {
+    return;
+  }
+
+  NSRegularExpression *regex = FBXPathRegexWithPattern(pattern, flags, YES, ctxt);
+  if (nil == regex) {
+    return;
+  }
+
+  NSRange range = NSMakeRange(0, input.length);
+  NSString *result = [regex stringByReplacingMatchesInString:input
+                                                     options:FBXPathNoMatchingOptions
+                                                       range:range
+                                                withTemplate:replacement];
+  FBXPathReturnNSString(ctxt, result);
+}
+
+static void FBXPathTokenizeFunction(xmlXPathParserContextPtr ctxt, int nargs)
+{
+  if (nargs < 1 || nargs > 2) {
+    FBXPathSetInvalidArityError(ctxt);
+    return;
+  }
+
+  NSString *pattern = nargs == 2 ? FBXPathPopNSString(ctxt) : nil;
+  NSString *input = FBXPathPopNSString(ctxt);
+  if (nil == input || xmlXPathCheckError(ctxt)) {
+    return;
+  }
+
+  NSArray<NSString *> *tokens = nil;
+  if (!FBXPathTokenizeString(input, pattern, ctxt, &tokens)) {
+    return;
+  }
+
+  FBXPathReturnNSString(ctxt, [tokens componentsJoinedByString:FBXPathTokenSequenceSeparator]);
+}
+
+static void FBXPathStringJoinFunction(xmlXPathParserContextPtr ctxt, int nargs)
+{
+  if (nargs != 2) {
+    FBXPathSetInvalidArityError(ctxt);
+    return;
+  }
+
+  xmlChar *separatorChars = xmlXPathPopString(ctxt);
+  xmlXPathObjectPtr sequence = valuePop(ctxt);
+  if (xmlXPathCheckError(ctxt) || NULL == sequence || NULL == separatorChars) {
+    if (NULL != separatorChars) {
+      xmlFree(separatorChars);
+    }
+    if (NULL != sequence) {
+      xmlXPathFreeObject(sequence);
+    }
+    return;
+  }
+
+  NSString *separator = FBXPathStringFromUTF8Bytes(separatorChars);
+  xmlFree(separatorChars);
+  if (nil == separator) {
+    xmlXPathFreeObject(sequence);
+    return;
+  }
+
+  NSArray<NSString *> *parts = FBXPathPartsFromXPathObject(sequence);
+  xmlXPathFreeObject(sequence);
+
+  FBXPathReturnNSString(ctxt, [parts componentsJoinedByString:separator]);
+}
+
+static void FBRegisterXPathExtensions(xmlXPathContextPtr xpathCtx)
+{
+  xmlXPathRegisterFunc(xpathCtx, BAD_CAST "matches", FBXPathMatchesFunction);
+  xmlXPathRegisterFunc(xpathCtx, BAD_CAST "ends-with", FBXPathEndsWithFunction);
+  xmlXPathRegisterFunc(xpathCtx, BAD_CAST "lower-case", FBXPathLowerCaseFunction);
+  xmlXPathRegisterFunc(xpathCtx, BAD_CAST "upper-case", FBXPathUpperCaseFunction);
+  xmlXPathRegisterFunc(xpathCtx, BAD_CAST "replace", FBXPathReplaceFunction);
+  xmlXPathRegisterFunc(xpathCtx, BAD_CAST "tokenize", FBXPathTokenizeFunction);
+  xmlXPathRegisterFunc(xpathCtx, BAD_CAST "string-join", FBXPathStringJoinFunction);
+}

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/XCTestPrivateSymbols.h

@@ -50,8 +50,8 @@ extern NSArray<NSNumber *> *(*XCAXAccessibilityAttributesForStringAttributes)(id
  */
 void *FBRetrieveXCTestSymbol(const char *name);
 
-/*! Static constructor that will retrieve XCTest private symbols */
-__attribute__((constructor)) void FBLoadXCTestSymbols(void);
+/*! Loads XCTest private symbols. Safe to call multiple times. */
+void FBLoadXCTestSymbols(void);
 
 /**
  Method is used to tranform attribute names into the format, which

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/XCTestPrivateSymbols.m

@@ -30,41 +30,61 @@ id<XCDebugLogDelegate> (*XCDebugLogger)(void);
 
 NSArray<NSNumber *> *(*XCAXAccessibilityAttributesForStringAttributes)(id);
 
-__attribute__((constructor)) void FBLoadXCTestSymbols(void)
+@interface FBXCTestSymbolsLoader : NSObject
+@end
+
+@implementation FBXCTestSymbolsLoader
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wobjc-load-method"
+
++ (void)load
 {
-  NSString *XC_kAXXCAttributeIsVisible = *(NSString*__autoreleasing*)FBRetrieveXCTestSymbol([FB_XCAXAIsVisibleAttributeName UTF8String]);
-  NSString *XC_kAXXCAttributeIsElement = *(NSString*__autoreleasing*)FBRetrieveXCTestSymbol([FB_XCAXAIsElementAttributeName UTF8String]);
-
-  XCAXAccessibilityAttributesForStringAttributes =
-  (NSArray<NSNumber *> *(*)(id))FBRetrieveXCTestSymbol("XCAXAccessibilityAttributesForStringAttributes");
-
-  XCSetDebugLogger = (void (*)(id <XCDebugLogDelegate>))FBRetrieveXCTestSymbol("XCSetDebugLogger");
-  XCDebugLogger = (id<XCDebugLogDelegate>(*)(void))FBRetrieveXCTestSymbol("XCDebugLogger");
-
-  NSArray<NSNumber *> *accessibilityAttributes = XCAXAccessibilityAttributesForStringAttributes(@[XC_kAXXCAttributeIsVisible, XC_kAXXCAttributeIsElement]);
-  FB_XCAXAIsVisibleAttribute = accessibilityAttributes[0];
-  FB_XCAXAIsElementAttribute = accessibilityAttributes[1];
-
-  NSCAssert(FB_XCAXAIsVisibleAttribute != nil , @"Failed to retrieve FB_XCAXAIsVisibleAttribute", FB_XCAXAIsVisibleAttribute);
-  NSCAssert(FB_XCAXAIsElementAttribute != nil , @"Failed to retrieve FB_XCAXAIsElementAttribute", FB_XCAXAIsElementAttribute);
-  
-  NSString *XC_kAXXCAttributeMinValue = *(NSString *__autoreleasing *)FBRetrieveXCTestSymbol([FB_XCAXACustomMinValueAttributeName UTF8String]);
-  NSString *XC_kAXXCAttributeMaxValue = *(NSString *__autoreleasing *)FBRetrieveXCTestSymbol([FB_XCAXACustomMaxValueAttributeName UTF8String]);
-  
-  NSString *XC_kAXXCAttributeCustomActions = *(NSString *__autoreleasing *)FBRetrieveXCTestSymbol([FB_XCAXACustomActionsAttributeName UTF8String]);
-  
-  NSArray<NSNumber *> *customAttrs = XCAXAccessibilityAttributesForStringAttributes(@[
-    XC_kAXXCAttributeMinValue,
-    XC_kAXXCAttributeMaxValue,
-    XC_kAXXCAttributeCustomActions
-  ]);
-  FB_XCAXACustomMinValueAttribute = customAttrs[0];
-  FB_XCAXACustomMaxValueAttribute = customAttrs[1];
-  FB_XCAXACustomActionsAttribute = customAttrs[2];
-  
-  NSCAssert(FB_XCAXACustomMinValueAttribute != nil, @"Failed to retrieve FB_XCAXACustomMinValueAttribute", FB_XCAXACustomMinValueAttribute);
-  NSCAssert(FB_XCAXACustomMaxValueAttribute != nil, @"Failed to retrieve FB_XCAXACustomMaxValueAttribute", FB_XCAXACustomMaxValueAttribute);
-  NSCAssert(FB_XCAXACustomActionsAttribute != nil, @"Failed to retrieve FB_XCAXACustomActionsAttribute", FB_XCAXACustomActionsAttribute);
+  FBLoadXCTestSymbols();
+}
+
+#pragma clang diagnostic pop
+
+@end
+
+void FBLoadXCTestSymbols(void)
+{
+  static dispatch_once_t loadOnceToken;
+  dispatch_once(&loadOnceToken, ^{
+    NSString *XC_kAXXCAttributeIsVisible = *(NSString*__autoreleasing*)FBRetrieveXCTestSymbol([FB_XCAXAIsVisibleAttributeName UTF8String]);
+    NSString *XC_kAXXCAttributeIsElement = *(NSString*__autoreleasing*)FBRetrieveXCTestSymbol([FB_XCAXAIsElementAttributeName UTF8String]);
+
+    XCAXAccessibilityAttributesForStringAttributes =
+    (NSArray<NSNumber *> *(*)(id))FBRetrieveXCTestSymbol("XCAXAccessibilityAttributesForStringAttributes");
+
+    XCSetDebugLogger = (void (*)(id <XCDebugLogDelegate>))FBRetrieveXCTestSymbol("XCSetDebugLogger");
+    XCDebugLogger = (id<XCDebugLogDelegate>(*)(void))FBRetrieveXCTestSymbol("XCDebugLogger");
+
+    NSArray<NSNumber *> *accessibilityAttributes = XCAXAccessibilityAttributesForStringAttributes(@[XC_kAXXCAttributeIsVisible, XC_kAXXCAttributeIsElement]);
+    FB_XCAXAIsVisibleAttribute = accessibilityAttributes[0];
+    FB_XCAXAIsElementAttribute = accessibilityAttributes[1];
+
+    NSCAssert(FB_XCAXAIsVisibleAttribute != nil , @"Failed to retrieve FB_XCAXAIsVisibleAttribute", FB_XCAXAIsVisibleAttribute);
+    NSCAssert(FB_XCAXAIsElementAttribute != nil , @"Failed to retrieve FB_XCAXAIsElementAttribute", FB_XCAXAIsElementAttribute);
+
+    NSString *XC_kAXXCAttributeMinValue = *(NSString *__autoreleasing *)FBRetrieveXCTestSymbol([FB_XCAXACustomMinValueAttributeName UTF8String]);
+    NSString *XC_kAXXCAttributeMaxValue = *(NSString *__autoreleasing *)FBRetrieveXCTestSymbol([FB_XCAXACustomMaxValueAttributeName UTF8String]);
+
+    NSString *XC_kAXXCAttributeCustomActions = *(NSString *__autoreleasing *)FBRetrieveXCTestSymbol([FB_XCAXACustomActionsAttributeName UTF8String]);
+
+    NSArray<NSNumber *> *customAttrs = XCAXAccessibilityAttributesForStringAttributes(@[
+      XC_kAXXCAttributeMinValue,
+      XC_kAXXCAttributeMaxValue,
+      XC_kAXXCAttributeCustomActions
+    ]);
+    FB_XCAXACustomMinValueAttribute = customAttrs[0];
+    FB_XCAXACustomMaxValueAttribute = customAttrs[1];
+    FB_XCAXACustomActionsAttribute = customAttrs[2];
+
+    NSCAssert(FB_XCAXACustomMinValueAttribute != nil, @"Failed to retrieve FB_XCAXACustomMinValueAttribute", FB_XCAXACustomMinValueAttribute);
+    NSCAssert(FB_XCAXACustomMaxValueAttribute != nil, @"Failed to retrieve FB_XCAXACustomMaxValueAttribute", FB_XCAXACustomMaxValueAttribute);
+    NSCAssert(FB_XCAXACustomActionsAttribute != nil, @"Failed to retrieve FB_XCAXACustomActionsAttribute", FB_XCAXACustomActionsAttribute);
+  });
 }
 
 void *FBRetrieveXCTestSymbol(const char *name)

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/WebDriverAgentLib.h

@@ -48,6 +48,7 @@ FOUNDATION_EXPORT const unsigned char WebDriverAgentLib_VersionString[];
 #import <WebDriverAgentLib/XCUIApplication+FBHelpers.h>
 #import <WebDriverAgentLib/XCUIDevice+FBHelpers.h>
 #import <WebDriverAgentLib/XCUIDevice+FBRotation.h>
+#import <WebDriverAgentLib/XCUIDevice+FBVoiceOver.h>
 #import <WebDriverAgentLib/XCUIElement.h>
 #import <WebDriverAgentLib/XCUIElement+FBAccessibility.h>
 #import <WebDriverAgentLib/XCUIElement+FBFind.h>

package/drivers/ios/WebDriverAgent/WebDriverAgentRunner/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,14 @@
+{
+  "images" : [
+    {
+      "filename" : "icon-1024.png",
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

package/drivers/ios/WebDriverAgent/WebDriverAgentRunner/Assets.xcassets/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

package/drivers/ios/WebDriverAgent/WebDriverAgentRunner/UITestingUITests.m

@@ -22,18 +22,18 @@
 + (void)setUp
 {
   [FBDebugLogDelegateDecorator decorateXCTestLogger];
-  [FBConfiguration disableRemoteQueryEvaluation];
-  [FBConfiguration configureDefaultKeyboardPreferences];
-  [FBConfiguration disableApplicationUIInterruptionsHandling];
+  [FBConfiguration.sharedInstance disableRemoteQueryEvaluation];
+  [FBConfiguration.sharedInstance configureDefaultKeyboardPreferences];
+  [FBConfiguration.sharedInstance disableApplicationUIInterruptionsHandling];
   if (NSProcessInfo.processInfo.environment[@"ENABLE_AUTOMATIC_SCREEN_RECORDINGS"]) {
-    [FBConfiguration enableScreenRecordings];
+    [FBConfiguration.sharedInstance enableScreenRecordings];
   } else {
-    [FBConfiguration disableScreenRecordings];
+    [FBConfiguration.sharedInstance disableScreenRecordings];
   }
   if (NSProcessInfo.processInfo.environment[@"ENABLE_AUTOMATIC_SCREENSHOTS"]) {
-    [FBConfiguration enableScreenshots];
+    [FBConfiguration.sharedInstance enableScreenshots];
   } else {
-    [FBConfiguration disableScreenshots];
+    [FBConfiguration.sharedInstance disableScreenshots];
   }
   [super setUp];
 }

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationApp/COORDINATE_PROBE.md

@@ -0,0 +1,50 @@
+# Coordinate probe
+
+Open **Coordinate Probe** below **DeepHierarchy** on the IntegrationApp home screen.
+Use the standard Back button to return to the existing fixtures. Opening the probe
+creates a fresh measurement session.
+
+The **Touch** canvas records actual `UITouch.locationInView:` coordinates rather
+than assuming that a gesture succeeded because it hit a large button. **Scroll**
+shows 80 numbered rows, each 44 points high.
+
+## Automation identifiers
+
+| Identifier | Purpose |
+| --- | --- |
+| `coordinate-probe` | Home screen button that opens the probe |
+| `probe-status` | Label containing the measurement JSON |
+| `coordinate-canvas` | Touch target |
+| `probe-mode` | Touch/Scroll segmented control |
+| `probe-table` | Scrollable table |
+| `probe-row-0` through `probe-row-79` | Individual table rows |
+
+The `probe-status` label exposes `start`, `last`, `phase`, and `count` after a
+touch. `start` and `last` are **canvas-local app points**. It also exposes
+`canvasBounds`, `canvasWindowRect`, `windowSize`, `screenSize`, and `scrollY`.
+Geometry is refreshed when the view lays out, including after rotation or window
+resizing. Touch-related fields are absent before the first touch.
+
+For example, locate `coordinate-probe` by accessibility ID and click it. Then
+locate `coordinate-canvas`, send an element-relative action, and read the JSON
+from `probe-status`. Check that `count` increased and compare `start`/`last` with
+the expected canvas-local point within a suitable tolerance. Derive test offsets
+from the current element rectangle rather than hard-coding a device size.
+
+## Native and compatibility builds
+
+The screen uses the same source for both configurations. Keep the IntegrationApp
+scheme and set the build's `TARGETED_DEVICE_FAMILY`:
+
+- `1,2`: native support for iPhone and iPad (the existing default).
+- `1`: iPhone-only; install on iPad to exercise iPhone compatibility mode.
+
+These are build settings, not a switch within the running app. Verify the actual
+window and element frames before interpreting results. An iPad-native app can
+also run in a resized window; maximize it when testing a full-screen native case.
+For the compatibility case, compare app and SpringBoard window sizes and the
+reported element rectangles with the recorded probe geometry.
+
+If keeping both builds installed at once, give them distinct bundle IDs. This
+change does not add another app target or alter the existing bundle ID or signing
+configuration.

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationApp/Classes/FBCoordinateProbeViewController.h

@@ -0,0 +1,4 @@
+#import <UIKit/UIKit.h>
+
+@interface FBCoordinateProbeViewController : UIViewController
+@end