@devicelab/maestro-runner-darwin-x64 1.1.25

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

@@ -0,0 +1,22 @@
+/**
+ * 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 <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FBWebServerParams : NSObject
+
+/** The local port number WDA server is running on */
+@property (nonatomic, nullable) NSNumber *port;
+
++ (id)sharedInstance;
+
+@end
+
+NS_ASSUME_NONNULL_END

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

@@ -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.
+ */
+
+#import "FBWebServerParams.h"
+
+@implementation FBWebServerParams
+
++ (instancetype)sharedInstance
+{
+  static FBWebServerParams *instance;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    instance = [[self alloc] init];
+  });
+  return instance;
+}
+
+@end

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

@@ -0,0 +1,49 @@
+/**
+ * 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>
+#import "FBXCElementSnapshot.h"
+
+@protocol FBXCAccessibilityElement;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ This class acts as a proxy between WDA and XCAXClient_iOS.
+ Other classes are obliged to use its methods instead of directly accessing XCAXClient_iOS,
+ since Apple resticted the interface of XCAXClient_iOS class since Xcode10.2
+ */
+@interface FBXCAXClientProxy : NSObject
+
++ (instancetype)sharedClient;
+
+- (BOOL)setAXTimeout:(NSTimeInterval)timeout error:(NSError **)error;
+
+- (nullable id<FBXCElementSnapshot>)snapshotForElement:(id<FBXCAccessibilityElement>)element
+                                            attributes:(nullable NSArray<NSString *> *)attributes
+                                               inDepth:(BOOL)inDepth
+                                                 error:(NSError **)error;
+
+- (NSArray<id<FBXCAccessibilityElement>> *)activeApplications;
+
+- (id<FBXCAccessibilityElement>)systemApplication;
+
+- (NSDictionary *)defaultParameters;
+
+- (void)notifyWhenNoAnimationsAreActiveForApplication:(XCUIApplication *)application
+                                                reply:(void (^)(void))reply;
+
+- (nullable NSDictionary *)attributesForElement:(id<FBXCAccessibilityElement>)element
+                                     attributes:(NSArray *)attributes
+                                          error:(NSError**)error;
+
+- (nullable XCUIApplication *)monitoredApplicationWithProcessIdentifier:(int)pid;
+
+@end
+
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,119 @@
+/**
+ * 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 "FBXCAXClientProxy.h"
+
+#import "FBXCAccessibilityElement.h"
+#import "FBLogger.h"
+#import "FBMacros.h"
+#import "XCAXClient_iOS+FBSnapshotReqParams.h"
+#import "XCUIDevice.h"
+#import "XCUIApplication.h"
+
+static id FBAXClient = nil;
+
+@interface FBXCAXClientProxy ()
+
+@property (nonatomic) NSMutableDictionary<NSNumber *, XCUIApplication *> *appsCache;
+
+@end
+
+@implementation FBXCAXClientProxy
+
++ (instancetype)sharedClient
+{
+  static FBXCAXClientProxy *instance = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    instance = [[self alloc] init];
+    instance.appsCache = [NSMutableDictionary dictionary];
+    FBAXClient = [XCUIDevice.sharedDevice accessibilityInterface];
+  });
+  return instance;
+}
+
+- (BOOL)setAXTimeout:(NSTimeInterval)timeout error:(NSError **)error
+{
+  return [FBAXClient _setAXTimeout:timeout error:error];
+}
+
+- (id<FBXCElementSnapshot>)snapshotForElement:(id<FBXCAccessibilityElement>)element
+                                   attributes:(NSArray<NSString *> *)attributes
+                                      inDepth:(BOOL)inDepth
+                                        error:(NSError **)error
+{
+  NSMutableDictionary *parameters = [NSMutableDictionary dictionaryWithDictionary:self.defaultParameters];
+  if (!inDepth) {
+    parameters[FBSnapshotMaxDepthKey] = @1;
+  }
+
+  id result = [FBAXClient requestSnapshotForElement:element
+                                         attributes:attributes
+                                         parameters:[parameters copy]
+                                              error:error];
+  id<FBXCElementSnapshot> snapshot = [result valueForKey:@"_rootElementSnapshot"];
+  return nil == snapshot ? result : snapshot;
+}
+
+- (NSArray<id<FBXCAccessibilityElement>> *)activeApplications
+{
+  return [FBAXClient activeApplications];
+}
+
+- (id<FBXCAccessibilityElement>)systemApplication
+{
+  return [FBAXClient systemApplication];
+}
+
+- (NSDictionary *)defaultParameters
+{
+  return [FBAXClient defaultParameters];
+}
+
+- (void)notifyWhenNoAnimationsAreActiveForApplication:(XCUIApplication *)application
+                                                reply:(void (^)(void))reply
+{
+  [FBAXClient notifyWhenNoAnimationsAreActiveForApplication:application reply:reply];
+}
+
+- (NSDictionary *)attributesForElement:(id<FBXCAccessibilityElement>)element
+                            attributes:(NSArray *)attributes
+                                 error:(NSError**)error;
+{
+  return [FBAXClient attributesForElement:element
+                               attributes:attributes
+                                    error:error];
+}
+
+- (XCUIApplication *)monitoredApplicationWithProcessIdentifier:(int)pid
+{
+  NSMutableSet *terminatedAppIds = [NSMutableSet set];
+  for (NSNumber *appPid in self.appsCache) {
+    if (![self.appsCache[appPid] running]) {
+      [terminatedAppIds addObject:appPid];
+    }
+  }
+  for (NSNumber *appPid in terminatedAppIds) {
+    [self.appsCache removeObjectForKey:appPid];
+  }
+
+  XCUIApplication *result = [self.appsCache objectForKey:@(pid)];
+  if (nil != result) {
+    return result;
+  }
+
+  XCUIApplication *app = [[FBAXClient applicationProcessTracker]
+                          monitoredApplicationWithProcessIdentifier:pid];
+  if (nil == app) {
+    return nil;
+  }
+  [self.appsCache setObject:app forKey:@(pid)];
+  return app;
+}
+
+@end

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

@@ -0,0 +1,45 @@
+/**
+ * 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
+#import <CoreLocation/CoreLocation.h>
+#endif
+
+#import "XCSynthesizedEventRecord.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol XCTestManager_ManagerInterface;
+@class FBScreenRecordingRequest, FBScreenRecordingPromise;
+
+@interface FBXCTestDaemonsProxy : NSObject
+
++ (id<XCTestManager_ManagerInterface>)testRunnerProxy;
+
++ (BOOL)synthesizeEventWithRecord:(XCSynthesizedEventRecord *)record
+                            error:(NSError *__autoreleasing*)error;
+
++ (BOOL)openURL:(NSURL *)url usingApplication:(NSString *)bundleId error:(NSError **)error;
++ (BOOL)openDefaultApplicationForURL:(NSURL *)url error:(NSError **)error;
+
++ (nullable FBScreenRecordingPromise *)startScreenRecordingWithRequest:(FBScreenRecordingRequest *)request
+                                                                 error:(NSError **)error;
++ (BOOL)stopScreenRecordingWithUUID:(NSUUID *)uuid
+                              error:(NSError **)error;
+
+#if !TARGET_OS_TV
++ (BOOL)setSimulatedLocation:(CLLocation *)location error:(NSError **)error;
++ (nullable CLLocation *)getSimulatedLocation:(NSError **)error;
++ (BOOL)clearSimulatedLocation:(NSError **)error;
+#endif
+
+@end
+
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,359 @@
+/**
+ * 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 "FBXCTestDaemonsProxy.h"
+
+#import <objc/runtime.h>
+
+#import "FBConfiguration.h"
+#import "FBErrorBuilder.h"
+#import "FBExceptions.h"
+#import "FBLogger.h"
+#import "FBRunLoopSpinner.h"
+#import "FBScreenRecordingPromise.h"
+#import "FBScreenRecordingRequest.h"
+#import "XCTestDriver.h"
+#import "XCTRunnerDaemonSession.h"
+#import "XCUIApplication.h"
+#import "XCUIDevice.h"
+
+#define LAUNCH_APP_TIMEOUT_SEC 300
+
+static void (*originalLaunchAppMethod)(id, SEL, NSString*, NSString*, NSArray*, NSDictionary*, void (^)(_Bool, NSError *));
+
+static void swizzledLaunchApp(id self, SEL _cmd, NSString *path, NSString *bundleID,
+                              NSArray *arguments, NSDictionary *environment,
+                              void (^reply)(_Bool, NSError *))
+{
+  __block BOOL isSuccessful;
+  __block NSError *error;
+  dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+  originalLaunchAppMethod(self, _cmd, path, bundleID, arguments, environment, ^(BOOL passed, NSError *innerError) {
+    isSuccessful = passed;
+    error = innerError;
+    dispatch_semaphore_signal(sem);
+  });
+  int64_t timeoutNs = (int64_t)(LAUNCH_APP_TIMEOUT_SEC * NSEC_PER_SEC);
+  if (0 != dispatch_semaphore_wait(sem, dispatch_time(DISPATCH_TIME_NOW, timeoutNs))) {
+    NSString *message = [NSString stringWithFormat:@"The application '%@' cannot be launched within %d seconds timeout",
+                         bundleID ?: path, LAUNCH_APP_TIMEOUT_SEC];
+    @throw [NSException exceptionWithName:FBTimeoutException reason:message userInfo:nil];
+  }
+  if (!isSuccessful || nil != error) {
+    [FBLogger logFmt:@"%@", error.description];
+    NSString *message = error.description ?: [NSString stringWithFormat:@"The application '%@' is not installed on the device under test",
+                         bundleID ?: path];
+    @throw [NSException exceptionWithName:FBApplicationMissingException reason:message userInfo:nil];
+  }
+  reply(isSuccessful, error);
+}
+
+@implementation FBXCTestDaemonsProxy
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wobjc-load-method"
+
++ (void)load
+{
+  [self.class swizzleLaunchApp];
+}
+
+#pragma clang diagnostic pop
+
++ (void)swizzleLaunchApp {
+  Method original = class_getInstanceMethod([XCTRunnerDaemonSession class],
+                                            @selector(launchApplicationWithPath:bundleID:arguments:environment:completion:));
+  if (original == nil) {
+    [FBLogger log:@"Could not find method -[XCTRunnerDaemonSession launchApplicationWithPath:]"];
+    return;
+  }
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcast-function-type-strict"
+  // Workaround for https://github.com/appium/WebDriverAgent/issues/702
+  originalLaunchAppMethod = (void(*)(id, SEL, NSString*, NSString*, NSArray*, NSDictionary*, void (^)(_Bool, NSError *))) method_getImplementation(original);
+  method_setImplementation(original, (IMP)swizzledLaunchApp);
+#pragma clang diagnostic pop
+}
+
++ (id<XCTestManager_ManagerInterface>)testRunnerProxy
+{
+  static id<XCTestManager_ManagerInterface> proxy = nil;
+  if ([FBConfiguration shouldUseSingletonTestManager]) {
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+      [FBLogger logFmt:@"Using singleton test manager"];
+      proxy = [self.class retrieveTestRunnerProxy];
+    });
+  } else {
+    [FBLogger logFmt:@"Using general test manager"];
+    proxy = [self.class retrieveTestRunnerProxy];
+  }
+  NSAssert(proxy != NULL, @"Could not determine testRunnerProxy", proxy);
+  return proxy;
+}
+
++ (id<XCTestManager_ManagerInterface>)retrieveTestRunnerProxy
+{
+  return ((XCTRunnerDaemonSession *)[XCTRunnerDaemonSession sharedSession]).daemonProxy;
+}
+
++ (BOOL)synthesizeEventWithRecord:(XCSynthesizedEventRecord *)record error:(NSError *__autoreleasing*)error
+{
+  __block NSError *innerError = nil;
+  [FBRunLoopSpinner spinUntilCompletion:^(void(^completion)(void)){
+    void (^errorHandler)(NSError *) = ^(NSError *invokeError) {
+      if (nil != invokeError) {
+        innerError = invokeError;
+      }
+      completion();
+    };
+
+    XCEventGeneratorHandler handlerBlock = ^(XCSynthesizedEventRecord *innerRecord, NSError *invokeError) {
+      errorHandler(invokeError);
+    };
+    [[XCUIDevice.sharedDevice eventSynthesizer] synthesizeEvent:record completion:(id)^(BOOL result, NSError *invokeError) {
+      handlerBlock(record, invokeError);
+    }];
+  }];
+  if (nil != innerError) {
+    if (error) {
+      *error = innerError;
+    }
+    return NO;
+  }
+  return YES;
+}
+
++ (BOOL)openURL:(NSURL *)url usingApplication:(NSString *)bundleId error:(NSError *__autoreleasing*)error
+{
+  XCTRunnerDaemonSession *session = [XCTRunnerDaemonSession sharedSession];
+  if (![session respondsToSelector:@selector(openURL:usingApplication:completion:)]) {
+    return [[[FBErrorBuilder builder]
+      withDescriptionFormat:@"The current Xcode SDK does not support opening of URLs with given application"]
+     buildError:error];
+  }
+
+  __block NSError *innerError = nil;
+  __block BOOL didSucceed = NO;
+  [FBRunLoopSpinner spinUntilCompletion:^(void(^completion)(void)){
+    [session openURL:url usingApplication:bundleId completion:^(bool result, NSError *invokeError) {
+      if (nil != invokeError) {
+        innerError = invokeError;
+      } else {
+        didSucceed = result;
+      }
+      completion();
+    }];
+  }];
+  if (nil != innerError && error) {
+    *error = innerError;
+  }
+  return didSucceed;
+}
+
++ (BOOL)openDefaultApplicationForURL:(NSURL *)url error:(NSError *__autoreleasing*)error
+{
+  XCTRunnerDaemonSession *session = [XCTRunnerDaemonSession sharedSession];
+  if (![session respondsToSelector:@selector(openDefaultApplicationForURL:completion:)]) {
+    return [[[FBErrorBuilder builder]
+      withDescriptionFormat:@"The current Xcode SDK does not support opening of URLs. Consider upgrading to Xcode 14.3+/iOS 16.4+"]
+     buildError:error];
+  }
+
+  __block NSError *innerError = nil;
+  __block BOOL didSucceed = NO;
+  [FBRunLoopSpinner spinUntilCompletion:^(void(^completion)(void)){
+    [session openDefaultApplicationForURL:url completion:^(bool result, NSError *invokeError) {
+      if (nil != invokeError) {
+        innerError = invokeError;
+      } else {
+        didSucceed = result;
+      }
+      completion();
+    }];
+  }];
+  if (nil != innerError && error) {
+    *error = innerError;
+  }
+  return didSucceed;
+}
+
+#if !TARGET_OS_TV
++ (BOOL)setSimulatedLocation:(CLLocation *)location error:(NSError *__autoreleasing*)error
+{
+  XCTRunnerDaemonSession *session = [XCTRunnerDaemonSession sharedSession];
+  if (![session respondsToSelector:@selector(setSimulatedLocation:completion:)]) {
+    return [[[FBErrorBuilder builder]
+      withDescriptionFormat:@"The current Xcode SDK does not support location simulation. Consider upgrading to Xcode 14.3+/iOS 16.4+"]
+     buildError:error];
+  }
+  if (![session supportsLocationSimulation]) {
+    return [[[FBErrorBuilder builder]
+      withDescriptionFormat:@"Your device does not support location simulation"]
+     buildError:error];
+  }
+
+  __block NSError *innerError = nil;
+  __block BOOL didSucceed = NO;
+  [FBRunLoopSpinner spinUntilCompletion:^(void(^completion)(void)){
+    [session setSimulatedLocation:location completion:^(bool result, NSError *invokeError) {
+      if (nil != invokeError) {
+        innerError = invokeError;
+      } else {
+        didSucceed = result;
+      }
+      completion();
+    }];
+  }];
+  if (nil != innerError && error) {
+    *error = innerError;
+  }
+  return didSucceed;
+}
+
++ (nullable CLLocation *)getSimulatedLocation:(NSError *__autoreleasing*)error;
+{
+  XCTRunnerDaemonSession *session = [XCTRunnerDaemonSession sharedSession];
+  if (![session respondsToSelector:@selector(getSimulatedLocationWithReply:)]) {
+    [[[FBErrorBuilder builder]
+      withDescriptionFormat:@"The current Xcode SDK does not support location simulation. Consider upgrading to Xcode 14.3+/iOS 16.4+"]
+     buildError:error];
+    return nil;
+  }
+  if (![session supportsLocationSimulation]) {
+    [[[FBErrorBuilder builder]
+      withDescriptionFormat:@"Your device does not support location simulation"]
+     buildError:error];
+    return nil;
+  }
+
+  __block NSError *innerError = nil;
+  __block CLLocation *location = nil;
+  [FBRunLoopSpinner spinUntilCompletion:^(void(^completion)(void)){
+    [session getSimulatedLocationWithReply:^(CLLocation *reply, NSError *invokeError) {
+      if (nil != invokeError) {
+        innerError = invokeError;
+      } else {
+        location = reply;
+      }
+      completion();
+    }];
+  }];
+  if (nil != innerError && error) {
+    *error = innerError;
+  }
+  return location;
+}
+
++ (BOOL)clearSimulatedLocation:(NSError *__autoreleasing*)error
+{
+  XCTRunnerDaemonSession *session = [XCTRunnerDaemonSession sharedSession];
+  if (![session respondsToSelector:@selector(clearSimulatedLocationWithReply:)]) {
+    return [[[FBErrorBuilder builder]
+        withDescriptionFormat:@"The current Xcode SDK does not support location simulation. Consider upgrading to Xcode 14.3+/iOS 16.4+"]
+       buildError:error];
+  }
+  if (![session supportsLocationSimulation]) {
+    return [[[FBErrorBuilder builder]
+        withDescriptionFormat:@"Your device does not support location simulation"]
+       buildError:error];
+  }
+
+  __block NSError *innerError = nil;
+  __block BOOL didSucceed = NO;
+  [FBRunLoopSpinner spinUntilCompletion:^(void(^completion)(void)){
+    [session clearSimulatedLocationWithReply:^(bool result, NSError *invokeError) {
+      if (nil != invokeError) {
+        innerError = invokeError;
+      } else {
+        didSucceed = result;
+      }
+      completion();
+    }];
+  }];
+  if (nil != innerError && error) {
+    *error = innerError;
+  }
+  return didSucceed;
+}
+#endif
+
++ (FBScreenRecordingPromise *)startScreenRecordingWithRequest:(FBScreenRecordingRequest *)request
+                                                        error:(NSError *__autoreleasing*)error
+{
+  XCTRunnerDaemonSession *session = [XCTRunnerDaemonSession sharedSession];
+  if (![session respondsToSelector:@selector(startScreenRecordingWithRequest:withReply:)]) {
+    [[[FBErrorBuilder builder]
+      withDescriptionFormat:@"The current Xcode SDK does not support screen recording. Consider upgrading to Xcode 15+/iOS 17+"]
+     buildError:error];
+    return nil;
+  }
+  if (![session supportsScreenRecording]) {
+    [[[FBErrorBuilder builder]
+      withDescriptionFormat:@"Your device does not support screen recording"]
+     buildError:error];
+    return nil;
+  }
+
+  id nativeRequest = [request toNativeRequestWithError:error];
+  if (nil == nativeRequest) {
+    return nil;
+  }
+
+  __block id futureMetadata = nil;
+  __block NSError *innerError = nil;
+  [FBRunLoopSpinner spinUntilCompletion:^(void(^completion)(void)){
+    [session startScreenRecordingWithRequest:nativeRequest withReply:^(id reply, NSError *invokeError) {
+      if (nil == invokeError) {
+        futureMetadata = reply;
+      } else {
+        innerError = invokeError;
+      }
+      completion();
+    }];
+  }];
+  if (nil != innerError) {
+    if (error) {
+      *error = innerError;
+    }
+    return nil;
+  }
+  return [[FBScreenRecordingPromise alloc] initWithNativePromise:futureMetadata];
+}
+
++ (BOOL)stopScreenRecordingWithUUID:(NSUUID *)uuid error:(NSError *__autoreleasing*)error
+{
+  XCTRunnerDaemonSession *session = [XCTRunnerDaemonSession sharedSession];
+  if (![session respondsToSelector:@selector(stopScreenRecordingWithUUID:withReply:)]) {
+    return [[[FBErrorBuilder builder]
+        withDescriptionFormat:@"The current Xcode SDK does not support screen recording. Consider upgrading to Xcode 15+/iOS 17+"]
+       buildError:error];
+
+  }
+  if (![session supportsScreenRecording]) {
+    return [[[FBErrorBuilder builder]
+        withDescriptionFormat:@"Your device does not support screen recording"]
+       buildError:error];
+  }
+
+  __block NSError *innerError = nil;
+  [FBRunLoopSpinner spinUntilCompletion:^(void(^completion)(void)){
+    [session stopScreenRecordingWithUUID:uuid withReply:^(NSError *invokeError) {
+      if (nil != invokeError) {
+        innerError = invokeError;
+      }
+      completion();
+    }];
+  }];
+  if (nil != innerError && error) {
+    *error = innerError;
+  }
+  return nil == innerError;
+}
+
+@end

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

@@ -0,0 +1,80 @@
+/**
+ * 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 <WebDriverAgentLib/WebDriverAgentLib.h>
+#import "XCPointerEvent.h"
+
+@class FBXCElementSnapshot;
+
+/**
+ The version of testmanagerd process which is running on the device.
+
+ Potentially, we can handle processes based on this version instead of iOS versions,
+ iOS 10.1 -> 6
+ iOS 11.0.1 -> 18
+ iOS 11.4 -> 22
+ iOS 12.1, 12.4 -> 26
+ iOS 13.0, 13.4.1 -> 28
+
+ tvOS 13.3 -> 28
+
+ @return The version of testmanagerd
+ */
+NSInteger FBTestmanagerdVersion(void);
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface XCUIElementQuery (FBCompatibility)
+
+/* Performs short-circuit UI tree traversion in iOS 11+ to get the first element matched by the query. Equals to nil if no matching elements are found */
+@property(nullable, readonly) XCUIElement *fb_firstMatch;
+
+/*
+ This is the local wrapper for bounded elements extraction.
+ It uses either indexed or bounded binding based on the `boundElementsByIndex` configuration
+ flag value.
+ */
+@property(readonly) NSArray<XCUIElement *> *fb_allMatches;
+
+/**
+ Returns single unique matching snapshot for the given query
+
+ @param error The error instance if there was a failure while retrieveing the snapshot
+ @returns The cached unqiue snapshot or nil if the element is stale
+ */
+- (nullable id<FBXCElementSnapshot>)fb_uniqueSnapshotWithError:(NSError **)error;
+
+@end
+
+
+@interface XCPointerEvent (FBCompatibility)
+
+- (BOOL)fb_areKeyEventsSupported;
+
+@end
+
+
+@interface XCUIElement (FBCompatibility)
+
+/**
+ Determines whether current iOS SDK supports non modal elements inlusion into snapshots
+
+ @return Either YES or NO
+ */
++ (BOOL)fb_supportsNonModalElementsInclusion;
+
+/**
+ Retrieves element query
+
+ @return Element query property extended with non modal elements depending on the actual configuration
+ */
+- (XCUIElementQuery *)fb_query;
+
+@end
+
+NS_ASSUME_NONNULL_END