@devicelab/maestro-runner-darwin-x64 1.1.25

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

@@ -0,0 +1,170 @@
+/**
+ * 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 "FBImageProcessor.h"
+
+#import <ImageIO/ImageIO.h>
+#import <UIKit/UIKit.h>
+@import UniformTypeIdentifiers;
+
+#import "FBConfiguration.h"
+#import "FBErrorBuilder.h"
+#import "FBImageUtils.h"
+#import "FBLogger.h"
+
+const CGFloat FBMinScalingFactor = 0.01f;
+const CGFloat FBMaxScalingFactor = 1.0f;
+const CGFloat FBMinCompressionQuality = 0.0f;
+const CGFloat FBMaxCompressionQuality = 1.0f;
+
+@interface FBImageProcessor ()
+
+@property (nonatomic) NSData *nextImage;
+@property (nonatomic, readonly) NSLock *nextImageLock;
+@property (nonatomic, readonly) dispatch_queue_t scalingQueue;
+
+@end
+
+@implementation FBImageProcessor
+
+- (id)init
+{
+  self = [super init];
+  if (self) {
+    _nextImageLock = [[NSLock alloc] init];
+    _scalingQueue = dispatch_queue_create("image.scaling.queue", NULL);
+  }
+  return self;
+}
+
+- (void)submitImageData:(NSData *)image
+          scalingFactor:(CGFloat)scalingFactor
+      completionHandler:(void (^)(NSData *))completionHandler
+{
+  [self.nextImageLock lock];
+  if (self.nextImage != nil) {
+    [FBLogger verboseLog:@"Discarding screenshot"];
+  }
+  self.nextImage = image;
+  [self.nextImageLock unlock];
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcompletion-handler"
+  dispatch_async(self.scalingQueue, ^{
+    [self.nextImageLock lock];
+    NSData *nextImageData = self.nextImage;
+    self.nextImage = nil;
+    [self.nextImageLock unlock];
+    if (nextImageData == nil) {
+      return;
+    }
+
+    // We do not want this value to be too high because then we get images larger in size than original ones
+    // Although, we also don't want to lose too much of the quality on recompression
+    CGFloat recompressionQuality = MAX(0.9,
+                                       MIN(FBMaxCompressionQuality, FBConfiguration.mjpegServerScreenshotQuality / 100.0));
+    NSData *thumbnailData = [self.class fixedImageDataWithImageData:nextImageData
+                                                      scalingFactor:scalingFactor
+                                                                uti:UTTypeJPEG
+                                                 compressionQuality:recompressionQuality
+    // iOS always returns screnshots in portrait orientation, but puts the real value into the metadata
+    // Use it with care. See https://github.com/appium/WebDriverAgent/pull/812
+                                                     fixOrientation:FBConfiguration.mjpegShouldFixOrientation
+                                                 desiredOrientation:nil];
+    completionHandler(thumbnailData ?: nextImageData);
+  });
+#pragma clang diagnostic pop
+}
+
++ (nullable NSData *)fixedImageDataWithImageData:(NSData *)imageData
+                                   scalingFactor:(CGFloat)scalingFactor
+                                             uti:(UTType *)uti
+                              compressionQuality:(CGFloat)compressionQuality
+                                  fixOrientation:(BOOL)fixOrientation
+                              desiredOrientation:(nullable NSNumber *)orientation
+{
+  scalingFactor = MAX(FBMinScalingFactor, MIN(FBMaxScalingFactor, scalingFactor));
+  BOOL usesScaling = scalingFactor > 0.0 && scalingFactor < FBMaxScalingFactor;
+  @autoreleasepool {
+    if (!usesScaling && !fixOrientation) {
+      return [uti conformsToType:UTTypePNG] ? FBToPngData(imageData) : FBToJpegData(imageData, compressionQuality);
+    }
+  
+    UIImage *image = [UIImage imageWithData:imageData];
+    if (nil == image
+        || ((image.imageOrientation == UIImageOrientationUp || !fixOrientation) && !usesScaling)) {
+      return [uti conformsToType:UTTypePNG] ? FBToPngData(imageData) : FBToJpegData(imageData, compressionQuality);
+    }
+    
+    CGSize scaledSize = CGSizeMake(image.size.width * scalingFactor, image.size.height * scalingFactor);
+    if (!fixOrientation && usesScaling) {
+      dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+      __block UIImage *result = nil;
+      [image prepareThumbnailOfSize:scaledSize
+                  completionHandler:^(UIImage * _Nullable thumbnail) {
+        result = thumbnail;
+        dispatch_semaphore_signal(semaphore);
+      }];
+      dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
+      if (nil == result) {
+        return [uti conformsToType:UTTypePNG] ? FBToPngData(imageData) : FBToJpegData(imageData, compressionQuality);
+      }
+      return [uti conformsToType:UTTypePNG]
+        ? UIImagePNGRepresentation(result)
+        : UIImageJPEGRepresentation(result, compressionQuality);
+    }
+  
+    UIGraphicsImageRendererFormat *format = [[UIGraphicsImageRendererFormat alloc] init];
+    format.scale = scalingFactor;
+    UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc] initWithSize:scaledSize
+                                                                               format:format];
+    UIImageOrientation desiredOrientation = orientation == nil
+      ? image.imageOrientation
+      : (UIImageOrientation)orientation.integerValue;
+    UIImage *uiImage = [UIImage imageWithCGImage:(CGImageRef)image.CGImage
+                                           scale:image.scale
+                                     orientation:desiredOrientation];
+    return [uti conformsToType:UTTypePNG]
+      ? [renderer PNGDataWithActions:^(UIGraphicsImageRendererContext * _Nonnull rendererContext) {
+        [uiImage drawInRect:CGRectMake(0, 0, scaledSize.width, scaledSize.height)];
+      }]
+      : [renderer JPEGDataWithCompressionQuality:compressionQuality
+                                         actions:^(UIGraphicsImageRendererContext * _Nonnull rendererContext) {
+        [uiImage drawInRect:CGRectMake(0, 0, scaledSize.width, scaledSize.height)];
+      }];
+  }
+}
+
+- (nullable NSData *)scaledImageWithData:(NSData *)imageData
+                                     uti:(UTType *)uti
+                           scalingFactor:(CGFloat)scalingFactor
+                      compressionQuality:(CGFloat)compressionQuality
+                                   error:(NSError **)error
+{
+  NSNumber *orientation = nil;
+#if !TARGET_OS_TV
+  if (FBConfiguration.screenshotOrientation == UIInterfaceOrientationPortrait) {
+    orientation = @(UIImageOrientationUp);
+  } else if (FBConfiguration.screenshotOrientation == UIInterfaceOrientationPortraitUpsideDown) {
+    orientation = @(UIImageOrientationDown);
+  } else if (FBConfiguration.screenshotOrientation == UIInterfaceOrientationLandscapeLeft) {
+    orientation = @(UIImageOrientationRight);
+  } else if (FBConfiguration.screenshotOrientation == UIInterfaceOrientationLandscapeRight) {
+    orientation = @(UIImageOrientationLeft);
+  }
+#endif
+  NSData *resultData = [self.class fixedImageDataWithImageData:imageData
+                                                 scalingFactor:scalingFactor
+                                                           uti:uti
+                                            compressionQuality:compressionQuality
+                                                fixOrientation:YES
+                                            desiredOrientation:orientation];
+  return resultData ?: imageData;
+}
+
+@end

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

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <XCTest/XCTest.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! Returns YES if the data contains a PNG image */
+BOOL FBIsPngImage(NSData *imageData);
+
+/*! Converts the given image data to a PNG representation if necessary */
+NSData *_Nullable FBToPngData(NSData *imageData);
+
+/*! Returns YES if the data contains a JPG image */
+BOOL FBIsJpegImage(NSData *imageData);
+
+/*! Converts the given image data to a JPG representation if necessary */
+NSData *_Nullable FBToJpegData(NSData *imageData, CGFloat compressionQuality);
+
+NS_ASSUME_NONNULL_END

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

@@ -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 "FBImageUtils.h"
+
+#import "FBMacros.h"
+#import "FBConfiguration.h"
+
+// https://en.wikipedia.org/wiki/List_of_file_signatures
+static uint8_t PNG_MAGIC[] = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A };
+static const NSUInteger PNG_MAGIC_LEN = 8;
+static uint8_t JPG_MAGIC[] = { 0xff, 0xd8, 0xff };
+static const NSUInteger JPG_MAGIC_LEN = 3;
+
+BOOL FBIsPngImage(NSData *imageData)
+{
+  if (nil == imageData || [imageData length] < PNG_MAGIC_LEN) {
+    return NO;
+  }
+
+  static NSData* pngMagicStartData = nil;
+  static dispatch_once_t oncePngToken;
+  dispatch_once(&oncePngToken, ^{
+    pngMagicStartData = [NSData dataWithBytesNoCopy:(void*)PNG_MAGIC length:PNG_MAGIC_LEN freeWhenDone:NO];
+  });
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wassign-enum"
+  NSRange range = [imageData rangeOfData:pngMagicStartData options:kNilOptions range:NSMakeRange(0, PNG_MAGIC_LEN)];
+#pragma clang diagnostic pop
+  return range.location != NSNotFound;
+}
+
+NSData *FBToPngData(NSData *imageData) {
+  if (nil == imageData || [imageData length] < PNG_MAGIC_LEN) {
+    return nil;
+  }
+  if (FBIsPngImage(imageData)) {
+    return imageData;
+  }
+
+  UIImage *image = [UIImage imageWithData:imageData];
+  return nil == image ? nil : (NSData *)UIImagePNGRepresentation(image);
+}
+
+BOOL FBIsJpegImage(NSData *imageData)
+{
+  if (nil == imageData || [imageData length] < JPG_MAGIC_LEN) {
+    return NO;
+  }
+
+  static NSData* jpgMagicStartData = nil;
+  static dispatch_once_t onceJpgToken;
+  dispatch_once(&onceJpgToken, ^{
+    jpgMagicStartData = [NSData dataWithBytesNoCopy:(void*)JPG_MAGIC length:JPG_MAGIC_LEN freeWhenDone:NO];
+  });
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wassign-enum"
+  NSRange range = [imageData rangeOfData:jpgMagicStartData options:kNilOptions range:NSMakeRange(0, JPG_MAGIC_LEN)];
+#pragma clang diagnostic pop
+  return range.location != NSNotFound;
+}
+
+NSData *FBToJpegData(NSData *imageData, CGFloat compressionQuality) {
+  if (nil == imageData || [imageData length] < JPG_MAGIC_LEN) {
+    return nil;
+  }
+  if (FBIsJpegImage(imageData)) {
+    return imageData;
+  }
+  
+  UIImage *image = [UIImage imageWithData:imageData];
+  return nil == image ? nil : (NSData *)UIImageJPEGRepresentation(image, compressionQuality);
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <XCTest/XCTest.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FBKeyboard : NSObject
+
+#if (!TARGET_OS_TV && __clang_major__ >= 15)
+/**
+ Transforms key name to its string representation, which could be used with XCTest
+
+ @param name one of available keyboard key names defined in https://developer.apple.com/documentation/xctest/xcuikeyboardkey?language=objc
+ @return Either the key value or nil if no matches have been found
+ */
++ (nullable NSString *)keyValueForName:(NSString *)name;
+#endif
+
+/**
+ Waits until the keyboard is visible on the screen or a timeout happens
+ 
+ @param app that should be typed
+ @param timeout the maximum duration in seconds to wait until the keyboard is visible. If the timeout value is equal or less than zero then immediate visibility verification is going to be performed.
+ @param error If there is an error, upon return contains an NSError object that describes the problem.
+ @return YES if the keyboard is visible after the timeout, otherwise NO.
+ */
++ (BOOL)waitUntilVisibleForApplication:(XCUIApplication *)app timeout:(NSTimeInterval)timeout  error:(NSError **)error;
+
+@end
+
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,123 @@
+/**
+ * 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 "FBKeyboard.h"
+
+#import "FBConfiguration.h"
+#import "FBXCTestDaemonsProxy.h"
+#import "FBErrorBuilder.h"
+#import "FBRunLoopSpinner.h"
+#import "FBMacros.h"
+#import "FBXCodeCompatibility.h"
+#import "XCUIElement+FBUtilities.h"
+#import "XCUIElement+FBIsVisible.h"
+#import "XCTestDriver.h"
+#import "FBLogger.h"
+#import "FBConfiguration.h"
+
+@implementation FBKeyboard
+
++ (BOOL)waitUntilVisibleForApplication:(XCUIApplication *)app 
+                               timeout:(NSTimeInterval)timeout
+                                 error:(NSError **)error
+{
+  BOOL (^isKeyboardVisible)(void) = ^BOOL(void) {
+    XCUIElement *keyboard = app.keyboards.fb_firstMatch;
+    if (nil == keyboard) {
+      return NO;
+    }
+
+    NSPredicate *keySearchPredicate = [NSPredicate predicateWithBlock:^BOOL(id<FBXCElementSnapshot> snapshot,
+                                                                            NSDictionary *bindings) {
+      return snapshot.label.length > 0 && !CGRectIsEmpty(snapshot.frame);
+    }];
+    XCUIElement *firstKey = [[keyboard descendantsMatchingType:XCUIElementTypeKey]
+                             matchingPredicate:keySearchPredicate].allElementsBoundByIndex.firstObject;
+    return firstKey.exists && firstKey.hittable;
+  };
+  NSString* errMessage = @"The on-screen keyboard must be present to send keys";
+  if (timeout <= 0) {
+    if (!isKeyboardVisible()) {
+      return [[[FBErrorBuilder builder] withDescription:errMessage] buildError:error];
+    }
+    return YES;
+  }
+  return
+    [[[[FBRunLoopSpinner new]
+       timeout:timeout]
+      timeoutErrorMessage:errMessage]
+     spinUntilTrue:isKeyboardVisible
+     error:error];
+}
+
+#if (!TARGET_OS_TV && __clang_major__ >= 15)
+
++ (NSString *)keyValueForName:(NSString *)name
+{
+  static dispatch_once_t onceKeys;
+  static NSDictionary<NSString *, NSString *> *keysMapping;
+  dispatch_once(&onceKeys, ^{
+    keysMapping = @{
+      @"XCUIKeyboardKeyDelete": XCUIKeyboardKeyDelete,
+      @"XCUIKeyboardKeyReturn": XCUIKeyboardKeyReturn,
+      @"XCUIKeyboardKeyEnter": XCUIKeyboardKeyEnter,
+      @"XCUIKeyboardKeyTab": XCUIKeyboardKeyTab,
+      @"XCUIKeyboardKeySpace": XCUIKeyboardKeySpace,
+      @"XCUIKeyboardKeyEscape": XCUIKeyboardKeyEscape,
+
+      @"XCUIKeyboardKeyUpArrow": XCUIKeyboardKeyUpArrow,
+      @"XCUIKeyboardKeyDownArrow": XCUIKeyboardKeyDownArrow,
+      @"XCUIKeyboardKeyLeftArrow": XCUIKeyboardKeyLeftArrow,
+      @"XCUIKeyboardKeyRightArrow": XCUIKeyboardKeyRightArrow,
+
+      @"XCUIKeyboardKeyF1": XCUIKeyboardKeyF1,
+      @"XCUIKeyboardKeyF2": XCUIKeyboardKeyF2,
+      @"XCUIKeyboardKeyF3": XCUIKeyboardKeyF3,
+      @"XCUIKeyboardKeyF4": XCUIKeyboardKeyF4,
+      @"XCUIKeyboardKeyF5": XCUIKeyboardKeyF5,
+      @"XCUIKeyboardKeyF6": XCUIKeyboardKeyF6,
+      @"XCUIKeyboardKeyF7": XCUIKeyboardKeyF7,
+      @"XCUIKeyboardKeyF8": XCUIKeyboardKeyF8,
+      @"XCUIKeyboardKeyF9": XCUIKeyboardKeyF9,
+      @"XCUIKeyboardKeyF10": XCUIKeyboardKeyF10,
+      @"XCUIKeyboardKeyF11": XCUIKeyboardKeyF11,
+      @"XCUIKeyboardKeyF12": XCUIKeyboardKeyF12,
+      @"XCUIKeyboardKeyF13": XCUIKeyboardKeyF13,
+      @"XCUIKeyboardKeyF14": XCUIKeyboardKeyF14,
+      @"XCUIKeyboardKeyF15": XCUIKeyboardKeyF15,
+      @"XCUIKeyboardKeyF16": XCUIKeyboardKeyF16,
+      @"XCUIKeyboardKeyF17": XCUIKeyboardKeyF17,
+      @"XCUIKeyboardKeyF18": XCUIKeyboardKeyF18,
+      @"XCUIKeyboardKeyF19": XCUIKeyboardKeyF19,
+
+      @"XCUIKeyboardKeyForwardDelete": XCUIKeyboardKeyForwardDelete,
+      @"XCUIKeyboardKeyHome": XCUIKeyboardKeyHome,
+      @"XCUIKeyboardKeyEnd": XCUIKeyboardKeyEnd,
+      @"XCUIKeyboardKeyPageUp": XCUIKeyboardKeyPageUp,
+      @"XCUIKeyboardKeyPageDown": XCUIKeyboardKeyPageDown,
+      @"XCUIKeyboardKeyClear": XCUIKeyboardKeyClear,
+      @"XCUIKeyboardKeyHelp": XCUIKeyboardKeyHelp,
+
+      @"XCUIKeyboardKeyCapsLock": XCUIKeyboardKeyCapsLock,
+      @"XCUIKeyboardKeyShift": XCUIKeyboardKeyShift,
+      @"XCUIKeyboardKeyControl": XCUIKeyboardKeyControl,
+      @"XCUIKeyboardKeyOption": XCUIKeyboardKeyOption,
+      @"XCUIKeyboardKeyCommand": XCUIKeyboardKeyCommand,
+      @"XCUIKeyboardKeyRightShift": XCUIKeyboardKeyRightShift,
+      @"XCUIKeyboardKeyRightControl": XCUIKeyboardKeyRightControl,
+      @"XCUIKeyboardKeyRightOption": XCUIKeyboardKeyRightOption,
+      @"XCUIKeyboardKeyRightCommand": XCUIKeyboardKeyRightCommand,
+      @"XCUIKeyboardKeySecondaryFn": XCUIKeyboardKeySecondaryFn
+    };
+  });
+  return keysMapping[name];
+}
+
+#endif
+
+@end

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

@@ -0,0 +1,32 @@
+/**
+ * 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
+
+/**
+ A Global Logger object that understands log levels
+ */
+@interface FBLogger : NSObject
+
+/**
+ Log to stdout.
+ */
++ (void)log:(NSString *)message;
++ (void)logFmt:(NSString *)format, ... NS_FORMAT_FUNCTION(1,2);
+
+/**
+ Log to stdout, only if WDA is Verbose
+ */
++ (void)verboseLog:(NSString *)message;
++ (void)verboseLogFmt:(NSString *)format, ... NS_FORMAT_FUNCTION(1,2);
+
+@end
+
+NS_ASSUME_NONNULL_END

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

@@ -0,0 +1,47 @@
+/**
+ * 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 "FBLogger.h"
+
+#import "FBConfiguration.h"
+
+@implementation FBLogger
+
++ (void)log:(NSString *)message
+{
+  NSLog(@"%@", message);
+}
+
++ (void)logFmt:(NSString *)format, ...
+{
+  va_list args;
+  va_start(args, format);
+  NSLogv(format, args);
+  va_end(args);
+}
+
++ (void)verboseLog:(NSString *)message
+{
+  if (!FBConfiguration.verboseLoggingEnabled) {
+    return;
+  }
+  [self log:message];
+}
+
++ (void)verboseLogFmt:(NSString *)format, ...
+{
+  if (!FBConfiguration.verboseLoggingEnabled) {
+    return;
+  }
+  va_list args;
+  va_start(args, format);
+  NSLogv(format, args);
+  va_end(args);
+}
+
+@end

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

@@ -0,0 +1,57 @@
+/**
+ * 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.
+ */
+
+// Typedef to help with storing constant strings for enums.
+#if __has_feature(objc_arc)
+    typedef __unsafe_unretained NSString* FBLiteralString;
+#else
+    typedef NSString* FBLiteralString;
+#endif
+
+/*! Returns 'value' or nil if 'value' is an empty string */
+#define FBTransferEmptyStringToNil(value) ([value isEqual:@""] ? nil : value)
+
+/*! Returns 'value1' or 'value2' if 'value1' is an empty string */
+#define FBFirstNonEmptyValue(value1, value2) ^{ \
+  id value1computed = value1; \
+  return (value1computed == nil || [value1computed isEqual:@""] ? value2 : value1computed); \
+}()
+
+/*! Returns 'value' or NSNull if 'value' is nil */
+#define FBValueOrNull(value) ((value) ?: [NSNull null])
+
+/*!
+  Returns name of class property as a string
+  previously used [class new] errors out on certain classes because new will be declared unavailable
+  Instead we are casting into a class to get compiler support with property name.
+*/
+#define FBStringify(class, property) ({if(NO){[((class *)nil) property];} @#property;})
+
+/*! Creates weak type for given 'arg' */
+#define FBWeakify(arg) typeof(arg) __weak wda_weak_##arg = arg
+
+/*! Creates strong type for FBWeakify-ed 'arg' */
+#define FBStrongify(arg) \
+  _Pragma("clang diagnostic push") \
+  _Pragma("clang diagnostic ignored \"-Wshadow\"") \
+  typeof(arg) arg = wda_weak_##arg \
+  _Pragma("clang diagnostic pop")
+
+/*! Returns YES if current system version satisfies the given codition */
+#define SYSTEM_VERSION_EQUAL_TO(v)                  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedSame)
+#define SYSTEM_VERSION_GREATER_THAN(v)              ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedDescending)
+#define SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(v)  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedAscending)
+#define SYSTEM_VERSION_LESS_THAN(v)                 ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedAscending)
+#define SYSTEM_VERSION_LESS_THAN_OR_EQUAL_TO(v)     ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedDescending)
+
+/*! Converts the given number of milliseconds into seconds */
+#define FBMillisToSeconds(ms) ((ms) / 1000.0)
+
+/*! Converts boolean value to its string representation */
+#define FBBoolToString(b) ((b) ? @"true" : @"false")
+

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

@@ -0,0 +1,36 @@
+/**
+ * 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 <UIKit/UIKit.h>
+
+@class XCUIApplication;
+
+extern CGFloat FBDefaultFrameFuzzyThreshold;
+
+/*! Returns center point of given rect */
+CGPoint FBRectGetCenter(CGRect rect);
+
+/*! Returns whether floatss are equal within given threshold */
+BOOL FBFloatFuzzyEqualToFloat(CGFloat float1, CGFloat float2, CGFloat threshold);
+
+/*! Returns whether points are equal within given threshold */
+BOOL FBPointFuzzyEqualToPoint(CGPoint point1, CGPoint point2, CGFloat threshold);
+
+/*! Returns whether vectors are equal within given threshold */
+BOOL FBVectorFuzzyEqualToVector(CGVector a, CGVector b, CGFloat threshold);
+
+/*! Returns whether size are equal within given threshold */
+BOOL FBSizeFuzzyEqualToSize(CGSize size1, CGSize size2, CGFloat threshold);
+
+/*! Returns whether rect are equal within given threshold */
+BOOL FBRectFuzzyEqualToRect(CGRect rect1, CGRect rect2, CGFloat threshold);
+
+#if !TARGET_OS_TV
+/*! Inverts size if necessary to match current screen orientation */
+CGSize FBAdjustDimensionsForApplication(CGSize actualSize, UIInterfaceOrientation orientation);
+#endif

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

@@ -0,0 +1,63 @@
+/**
+ * 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 "FBMathUtils.h"
+
+#import "FBMacros.h"
+
+CGFloat FBDefaultFrameFuzzyThreshold = 2.0;
+
+CGPoint FBRectGetCenter(CGRect rect)
+{
+  return CGPointMake(CGRectGetMidX(rect), CGRectGetMidY(rect));
+}
+
+BOOL FBFloatFuzzyEqualToFloat(CGFloat float1, CGFloat float2, CGFloat threshold)
+{
+  return (fabs(float1 - float2) <= threshold);
+}
+
+BOOL FBVectorFuzzyEqualToVector(CGVector a, CGVector b, CGFloat threshold)
+{
+  return FBFloatFuzzyEqualToFloat(a.dx, b.dx, threshold) && FBFloatFuzzyEqualToFloat(a.dy, b.dy, threshold);
+}
+
+BOOL FBPointFuzzyEqualToPoint(CGPoint point1, CGPoint point2, CGFloat threshold)
+{
+  return FBFloatFuzzyEqualToFloat(point1.x, point2.x, threshold) && FBFloatFuzzyEqualToFloat(point1.y, point2.y, threshold);
+}
+
+BOOL FBSizeFuzzyEqualToSize(CGSize size1, CGSize size2, CGFloat threshold)
+{
+  return FBFloatFuzzyEqualToFloat(size1.width, size2.width, threshold) && FBFloatFuzzyEqualToFloat(size1.height, size2.height, threshold);
+}
+
+BOOL FBRectFuzzyEqualToRect(CGRect rect1, CGRect rect2, CGFloat threshold)
+{
+  return
+  FBPointFuzzyEqualToPoint(FBRectGetCenter(rect1), FBRectGetCenter(rect2), threshold) &&
+  FBSizeFuzzyEqualToSize(rect1.size, rect2.size, threshold);
+}
+
+#if !TARGET_OS_TV
+
+CGSize FBAdjustDimensionsForApplication(CGSize actualSize, UIInterfaceOrientation orientation)
+{
+  if (orientation == UIInterfaceOrientationLandscapeLeft || orientation == UIInterfaceOrientationLandscapeRight) {
+    /*
+     There is an XCTest bug that application.frame property returns exchanged dimensions for landscape mode.
+     This verification is just to make sure the bug is still there (since height is never greater than width in landscape) 
+     and to make it still working properly after XCTest itself starts to respect landscape mode.
+     */
+    if (actualSize.height > actualSize.width) {
+      return CGSizeMake(actualSize.height, actualSize.width);
+    }
+  }
+  return actualSize;
+}
+#endif