@devicelab/maestro-runner-darwin-x64 1.1.25

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/UnitTests/FBElementCacheTests.m

@@ -0,0 +1,124 @@
+/**
+ * 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 "FBElementCache.h"
+#import "XCUIElementDouble.h"
+#import "XCUIElement+FBCaching.h"
+#import "XCUIElement+FBUtilities.h"
+
+@interface FBElementCacheTests : XCTestCase
+@property (nonatomic, strong) FBElementCache *cache;
+@end
+
+@implementation FBElementCacheTests
+
+- (void)setUp
+{
+  [super setUp];
+  self.cache = [FBElementCache new];
+}
+
+- (void)testStoringElement
+{
+  XCUIElementDouble *el1 = XCUIElementDouble.new;
+  el1.wdUID = @"1";
+  XCUIElementDouble *el2 = XCUIElementDouble.new;
+  el2.wdUID = @"2";
+  NSString *firstUUID = [self.cache storeElement:(XCUIElement *)el1];
+  NSString *secondUUID = [self.cache storeElement:(XCUIElement *)el2];
+  XCTAssertEqualObjects(firstUUID, el1.wdUID);
+  XCTAssertEqualObjects(secondUUID, el2.wdUID);
+}
+
+- (void)testFetchingElement
+{
+  XCUIElement *element = (XCUIElement *)XCUIElementDouble.new;
+  NSString *uuid = [self.cache storeElement:element];
+  XCTAssertNotNil(uuid, @"Stored index should be higher than 0");
+  XCUIElement *cachedElement = [self.cache elementForUUID:uuid];
+  XCTAssertEqual(element, cachedElement);
+}
+
+- (void)testFetchingBadIndex
+{
+  XCTAssertThrows([self.cache elementForUUID:@"random"]);
+}
+
+- (void)testLinearCacheExpulsion
+{
+  const int ELEMENT_COUNT = 1050;
+  
+  NSMutableArray *elements = [NSMutableArray arrayWithCapacity:ELEMENT_COUNT];
+  NSMutableArray *elementIds = [NSMutableArray arrayWithCapacity:ELEMENT_COUNT];
+  for(int i = 0; i < ELEMENT_COUNT; i++) {
+    XCUIElementDouble *el = XCUIElementDouble.new;
+    el.wdUID = [NSString stringWithFormat:@"%@", @(i)];
+    [elements addObject:(XCUIElement *)el];
+  }
+  
+  // The capacity of the cache is limited to 1024 elements. Add 1050
+  // elements and make sure:
+  // - The first 26 elements are no longer present in the cache
+  // - The remaining 1024 elements are present in the cache
+  for(int i = 0; i < ELEMENT_COUNT; i++) {
+    [elementIds addObject:[self.cache storeElement:elements[i]]];
+  }
+  
+  for(int i = 0; i < ELEMENT_COUNT - ELEMENT_CACHE_SIZE; i++) {
+    XCTAssertThrows([self.cache elementForUUID:elementIds[i]]);
+  }
+  for(int i = ELEMENT_COUNT - ELEMENT_CACHE_SIZE; i < ELEMENT_COUNT; i++) {
+    XCTAssertEqual(elements[i], [self.cache elementForUUID:elementIds[i]]);
+  }
+}
+
+- (void)testMRUCacheExpulsion
+{
+  const int ELEMENT_COUNT = 1050;
+  const int ACCESSED_ELEMENT_COUNT = 24;
+  
+  NSMutableArray *elements = [NSMutableArray arrayWithCapacity:ELEMENT_COUNT];
+  NSMutableArray *elementIds = [NSMutableArray arrayWithCapacity:ELEMENT_COUNT];
+  for(int i = 0; i < ELEMENT_COUNT; i++) {
+    XCUIElementDouble *el = XCUIElementDouble.new;
+    el.wdUID = [NSString stringWithFormat:@"%@", @(i)];
+    [elements addObject:(XCUIElement *)el];
+  }
+  
+  // The capacity of the cache is limited to 1024 elements. Add 1050
+  // elements, but with a twist: access the first 24 elements before
+  // adding the last 50 elements. Then, make sure:
+  // - The first 24 elements are present in the cache
+  // - The next 26 elements are not present in the cache
+  // - The remaining 1000 elements are present in the cache
+  for(int i = 0; i < ELEMENT_CACHE_SIZE; i++) {
+    [elementIds addObject:[self.cache storeElement:elements[i]]];
+  }
+  
+  for(int i = 0; i < ACCESSED_ELEMENT_COUNT; i++) {
+    [self.cache elementForUUID:elementIds[i]];
+  }
+     
+  for(int i = ELEMENT_CACHE_SIZE; i < ELEMENT_COUNT; i++) {
+    [elementIds addObject:[self.cache storeElement:elements[i]]];
+  }
+  
+  for(int i = 0; i < ACCESSED_ELEMENT_COUNT; i++) {
+    XCTAssertEqual(elements[i], [self.cache elementForUUID:elementIds[i]]);
+  }
+  for(int i = ACCESSED_ELEMENT_COUNT; i < ELEMENT_COUNT - ELEMENT_CACHE_SIZE + ACCESSED_ELEMENT_COUNT; i++) {
+    XCTAssertThrows([self.cache elementForUUID:elementIds[i]]);
+  }
+  for(int i = ELEMENT_COUNT - ELEMENT_CACHE_SIZE + ACCESSED_ELEMENT_COUNT; i < ELEMENT_COUNT; i++) {
+    XCTAssertEqual(elements[i], [self.cache elementForUUID:elementIds[i]]);
+  }
+}
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/UnitTests/FBElementTypeTransformerTests.m

@@ -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>
+
+#import "FBElementTypeTransformer.h"
+
+@interface FBElementTypeTransformerTests : XCTestCase
+@end
+
+@implementation FBElementTypeTransformerTests
+
+- (void)testStringWithElementType
+{
+  XCTAssertEqualObjects(@"XCUIElementTypeAny", [FBElementTypeTransformer stringWithElementType:XCUIElementTypeAny]);
+  XCTAssertEqualObjects(@"XCUIElementTypeIcon", [FBElementTypeTransformer stringWithElementType:XCUIElementTypeIcon]);
+  XCTAssertEqualObjects(@"XCUIElementTypeTab", [FBElementTypeTransformer stringWithElementType:XCUIElementTypeTab]);
+  XCTAssertEqualObjects(@"XCUIElementTypeOther", [FBElementTypeTransformer stringWithElementType:XCUIElementTypeOther]);
+}
+
+- (void)testShortStringWithElementType
+{
+  XCTAssertEqualObjects(@"Any", [FBElementTypeTransformer shortStringWithElementType:XCUIElementTypeAny]);
+  XCTAssertEqualObjects(@"Icon", [FBElementTypeTransformer shortStringWithElementType:XCUIElementTypeIcon]);
+  XCTAssertEqualObjects(@"Tab", [FBElementTypeTransformer shortStringWithElementType:XCUIElementTypeTab]);
+  XCTAssertEqualObjects(@"Other", [FBElementTypeTransformer shortStringWithElementType:XCUIElementTypeOther]);
+}
+
+- (void)testElementTypeWithElementTypeName
+{
+  XCTAssertEqual(XCUIElementTypeAny, [FBElementTypeTransformer elementTypeWithTypeName:@"XCUIElementTypeAny"]);
+  XCTAssertEqual(XCUIElementTypeIcon, [FBElementTypeTransformer elementTypeWithTypeName:@"XCUIElementTypeIcon"]);
+  XCTAssertEqual(XCUIElementTypeTab, [FBElementTypeTransformer elementTypeWithTypeName:@"XCUIElementTypeTab"]);
+  XCTAssertEqual(XCUIElementTypeOther, [FBElementTypeTransformer elementTypeWithTypeName:@"XCUIElementTypeOther"]);
+  XCTAssertThrows([FBElementTypeTransformer elementTypeWithTypeName:@"Whatever"]);
+  XCTAssertThrows([FBElementTypeTransformer elementTypeWithTypeName:nil]);
+  XCTAssertEqual(XCUIElementTypeOther, [FBElementTypeTransformer elementTypeWithTypeName:@"XCUIElementTypeNewType"]);
+}
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/UnitTests/FBElementUtilitiesTests.m

@@ -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 <XCTest/XCTest.h>
+
+#import "FBElement.h"
+#import "XCUIElementDouble.h"
+#import "FBElementUtils.h"
+
+@interface FBElementUtilitiesTests : XCTestCase
+@end
+
+@implementation FBElementUtilitiesTests
+
+- (void)testTypesFiltering {
+  NSMutableArray *elements = [NSMutableArray new];
+  XCUIElementDouble *el1 = [XCUIElementDouble new];
+  [elements addObject:el1];
+  XCUIElementDouble *el2 = [XCUIElementDouble new];
+  el2.elementType = XCUIElementTypeAlert;
+  el2.wdType = @"XCUIElementTypeAlert";
+  [elements addObject:el2];
+  XCUIElementDouble *el3 = [XCUIElementDouble new];
+  [elements addObject:el3];
+  
+  NSSet *result = [FBElementUtils uniqueElementTypesWithElements:elements];
+  XCTAssertEqual([result count], 2);
+}
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/UnitTests/FBErrorBuilderTests.m

@@ -0,0 +1,61 @@
+/**
+ * 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 "FBErrorBuilder.h"
+
+@interface FBErrorBuilderTests : XCTestCase
+@end
+
+@implementation FBErrorBuilderTests
+
+- (void)testErrorWithDescription
+{
+  NSString *expectedDescription = @"Magic description";
+  NSError *error =
+  [[[FBErrorBuilder builder]
+    withDescription:expectedDescription]
+   build];
+  XCTAssertNotNil(error);
+  XCTAssertEqualObjects([error localizedDescription], expectedDescription);
+}
+
+- (void)testErrorWithDescriptionFormat
+{
+  NSError *error =
+  [[[FBErrorBuilder builder]
+    withDescriptionFormat:@"Magic %@", @"bob"]
+   build];
+  XCTAssertEqualObjects([error localizedDescription], @"Magic bob");
+}
+
+- (void)testInnerError
+{
+  NSError *innerError = [NSError errorWithDomain:@"Domain" code:1 userInfo:@{}];
+  NSError *error =
+  [[[FBErrorBuilder builder]
+    withInnerError:innerError]
+   build];
+  XCTAssertEqual(error.userInfo[NSUnderlyingErrorKey], innerError);
+}
+
+- (void)testBuildWithError
+{
+  NSString *expectedDescription = @"Magic description";
+  NSError *error;
+  BOOL result =
+  [[[FBErrorBuilder builder]
+    withDescription:expectedDescription]
+   buildError:&error];
+  XCTAssertNotNil(error);
+  XCTAssertEqualObjects(error.localizedDescription, expectedDescription);
+  XCTAssertFalse(result);
+}
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/UnitTests/FBExceptionHandlerTests.m

@@ -0,0 +1,59 @@
+/**
+ * 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 "FBAlert.h"
+#import "FBExceptionHandler.h"
+#import "FBExceptions.h"
+
+
+@interface RouteResponseDouble : NSObject
+- (void)setHeader:(NSString *)field value:(NSString *)value;
+- (void)setStatusCode:(NSUInteger)code;
+- (void)respondWithData:(NSData *)data;
+@end
+
+@implementation RouteResponseDouble
+- (void)setHeader:(NSString *)field value:(NSString *)value {}
+- (void)setStatusCode:(NSUInteger)code {}
+- (void)respondWithData:(NSData *)data {}
+@end
+
+
+@interface FBExceptionHandlerTests : XCTestCase
+@property (nonatomic) FBExceptionHandler *exceptionHandler;
+@end
+
+@implementation FBExceptionHandlerTests
+
+- (void)setUp
+{
+  self.exceptionHandler = [FBExceptionHandler new];
+}
+
+- (void)testMatchingErrorHandling
+{
+  NSException *exception = [NSException exceptionWithName:FBElementNotVisibleException
+                                                   reason:@"reason"
+                                                 userInfo:@{}];
+  [self.exceptionHandler handleException:exception
+                             forResponse:(RouteResponse *)[RouteResponseDouble new]];
+}
+
+- (void)testNonMatchingErrorHandling
+{
+  NSException *exception = [NSException exceptionWithName:@"something"
+                                                   reason:@"reason"
+                                                 userInfo:@{}];
+  [self.exceptionHandler handleException:exception
+                             forResponse:(RouteResponse *)[RouteResponseDouble new]];
+}
+
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/UnitTests/FBLRUCacheTests.m

@@ -0,0 +1,127 @@
+/**
+ * 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 "LRUCache.h"
+
+@interface FBLRUCacheTests : XCTestCase
+@end
+
+@implementation FBLRUCacheTests
+
+- (void)assertArray:(NSArray *)array1 equalsTo:(NSArray *)array2
+{
+  XCTAssertEqualObjects(array1, array2);
+}
+
+- (void)testRecentlyInsertedObjectReplacesTheOldestOne
+{
+  LRUCache *cache = [[LRUCache alloc] initWithCapacity:1];
+  [cache setObject:@"foo" forKey:@"bar"];
+  [cache setObject:@"foo2" forKey:@"bar2"];
+  [cache setObject:@"foo3" forKey:@"bar3"];
+  XCTAssertEqualObjects(@[@"foo3"], cache.allObjects);
+}
+
+- (void)testRecentObjectReplacementAndBump
+{
+  LRUCache *cache = [[LRUCache alloc] initWithCapacity:2];
+  [cache setObject:@"foo" forKey:@"bar"];
+  [cache setObject:@"foo2" forKey:@"bar2"];
+  [self assertArray:@[@"foo2", @"foo"] equalsTo:cache.allObjects];
+  XCTAssertNotNil([cache objectForKey:@"bar"]);
+  [self assertArray:@[@"foo", @"foo2"] equalsTo:cache.allObjects];
+  [cache setObject:@"foo3" forKey:@"bar3"];
+  [self assertArray:@[@"foo3", @"foo"] equalsTo:cache.allObjects];
+  [cache setObject:@"foo0" forKey:@"bar"];
+  [self assertArray:@[@"foo0", @"foo3"] equalsTo:cache.allObjects];
+  [cache setObject:@"foo4" forKey:@"bar4"];
+  [self assertArray:@[@"foo4", @"foo0"] equalsTo:cache.allObjects];
+}
+
+- (void)testBumpFromHead
+{
+  LRUCache *cache = [[LRUCache alloc] initWithCapacity:3];
+  [cache setObject:@"foo" forKey:@"bar"];
+  [cache setObject:@"foo2" forKey:@"bar2"];
+  [cache setObject:@"foo3" forKey:@"bar3"];
+  XCTAssertNotNil([cache objectForKey:@"bar3"]);
+  [self assertArray:@[@"foo3", @"foo2", @"foo"] equalsTo:cache.allObjects];
+  [cache setObject:@"foo4" forKey:@"bar4"];
+  [cache setObject:@"foo5" forKey:@"bar5"];
+  [self assertArray:@[@"foo5", @"foo4", @"foo3"] equalsTo:cache.allObjects];
+}
+
+- (void)testBumpFromMiddle
+{
+  LRUCache *cache = [[LRUCache alloc] initWithCapacity:3];
+  [cache setObject:@"foo" forKey:@"bar"];
+  [cache setObject:@"foo2" forKey:@"bar2"];
+  [cache setObject:@"foo3" forKey:@"bar3"];
+  XCTAssertNotNil([cache objectForKey:@"bar2"]);
+  [self assertArray:@[@"foo2", @"foo3", @"foo"] equalsTo:cache.allObjects];
+  [cache setObject:@"foo4" forKey:@"bar4"];
+  [cache setObject:@"foo5" forKey:@"bar5"];
+  [self assertArray:@[@"foo5", @"foo4", @"foo2"] equalsTo:cache.allObjects];
+}
+
+- (void)testBumpFromTail
+{
+  LRUCache *cache = [[LRUCache alloc] initWithCapacity:3];
+  [cache setObject:@"foo" forKey:@"bar"];
+  [cache setObject:@"foo2" forKey:@"bar2"];
+  [cache setObject:@"foo3" forKey:@"bar3"];
+  XCTAssertNotNil([cache objectForKey:@"bar3"]);
+  [self assertArray:@[@"foo3", @"foo2", @"foo"] equalsTo:cache.allObjects];
+  [cache setObject:@"foo4" forKey:@"bar4"];
+  [cache setObject:@"foo5" forKey:@"bar5"];
+  [self assertArray:@[@"foo5", @"foo4", @"foo3"] equalsTo:cache.allObjects];
+}
+
+- (void)testInsertionLoop
+{
+  LRUCache *cache = [[LRUCache alloc] initWithCapacity:1];
+  NSUInteger count = 100;
+  for (NSUInteger i = 0; i <= count; ++i) {
+    [cache setObject:@(i) forKey:@(i)];
+    XCTAssertNotNil([cache objectForKey:@(i)]);
+  }
+  XCTAssertEqualObjects(@[@(count)], cache.allObjects);
+}
+
+- (void)testRemoveExistingObjectForKey {
+    LRUCache *cache = [[LRUCache alloc] initWithCapacity:3];
+    [cache setObject:@"foo" forKey:@"bar"];
+    [cache setObject:@"foo2" forKey:@"bar2"];
+    [cache setObject:@"foo3" forKey:@"bar3"];
+    [self assertArray:@[@"foo3", @"foo2", @"foo"] equalsTo:cache.allObjects];
+    [cache removeObjectForKey:@"bar2"];
+    XCTAssertNil([cache objectForKey:@"bar2"]);
+    [self assertArray:@[@"foo3", @"foo"] equalsTo:cache.allObjects];
+}
+
+- (void)testRemoveNonExistingObjectForKey {
+    LRUCache *cache = [[LRUCache alloc] initWithCapacity:2];
+    [cache setObject:@"foo" forKey:@"bar"];
+    [cache removeObjectForKey:@"nonExisting"];
+    XCTAssertNotNil([cache objectForKey:@"bar"]);
+    [self assertArray:@[@"foo"] equalsTo:cache.allObjects];
+}
+
+- (void)testRemoveAndInsertFlow {
+    LRUCache *cache = [[LRUCache alloc] initWithCapacity:2];
+    [cache setObject:@"foo" forKey:@"bar"];
+    [cache setObject:@"foo2" forKey:@"bar2"];
+    [cache removeObjectForKey:@"bar"];
+    XCTAssertNil([cache objectForKey:@"bar"]);
+    [cache setObject:@"foo3" forKey:@"bar3"];
+    [self assertArray:@[@"foo3", @"foo2"] equalsTo:cache.allObjects];
+}
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/UnitTests/FBMathUtilsTests.m

@@ -0,0 +1,113 @@
+/**
+ * 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 "FBMathUtils.h"
+
+@interface FBMathUtilsTests : XCTestCase
+@end
+
+@implementation FBMathUtilsTests
+
+- (void)testGetCenter
+{
+  XCTAssertTrue(CGPointEqualToPoint(FBRectGetCenter(CGRectMake(0, 0, 4, 4)), CGPointMake(2, 2)));
+  XCTAssertTrue(CGPointEqualToPoint(FBRectGetCenter(CGRectMake(1, 1, 4, 4)), CGPointMake(3, 3)));
+  XCTAssertTrue(CGPointEqualToPoint(FBRectGetCenter(CGRectMake(1, 3, 6, 14)), CGPointMake(4, 10)));
+}
+
+- (void)testFuzzyEqualFloats
+{
+  XCTAssertTrue(FBFloatFuzzyEqualToFloat(0, 0, 0));
+  XCTAssertTrue(FBFloatFuzzyEqualToFloat(0.5, 0.6, 0.2));
+  XCTAssertTrue(FBFloatFuzzyEqualToFloat(0.6, 0.5, 0.2));
+  XCTAssertTrue(FBFloatFuzzyEqualToFloat(0.5, 0.6, 0.10001));
+}
+
+- (void)testFuzzyNotEqualFloats
+{
+  XCTAssertFalse(FBFloatFuzzyEqualToFloat(0, 1, 0));
+  XCTAssertFalse(FBFloatFuzzyEqualToFloat(1, 0, 0));
+  XCTAssertFalse(FBFloatFuzzyEqualToFloat(0.5, 0.6, 0.05));
+  XCTAssertFalse(FBFloatFuzzyEqualToFloat(0.6, 0.5, 0.05));
+}
+
+- (void)testFuzzyEqualPoints
+{
+  CGPoint referencePoint = CGPointMake(3, 3);
+  XCTAssertTrue(FBPointFuzzyEqualToPoint(referencePoint, CGPointMake(3, 3), 2));
+  XCTAssertTrue(FBPointFuzzyEqualToPoint(referencePoint, CGPointMake(3, 4), 2));
+  XCTAssertTrue(FBPointFuzzyEqualToPoint(referencePoint, CGPointMake(4, 3), 2));
+}
+
+- (void)testFuzzyNotEqualPoints
+{
+  CGPoint referencePoint = CGPointMake(3, 3);
+  XCTAssertFalse(FBPointFuzzyEqualToPoint(referencePoint, CGPointMake(5, 5), 1));
+  XCTAssertFalse(FBPointFuzzyEqualToPoint(referencePoint, CGPointMake(3, 5), 1));
+  XCTAssertFalse(FBPointFuzzyEqualToPoint(referencePoint, CGPointMake(5, 3), 1));
+}
+
+- (void)testFuzzyEqualSizes
+{
+  CGSize referenceSize = CGSizeMake(3, 3);
+  XCTAssertTrue(FBSizeFuzzyEqualToSize(referenceSize, CGSizeMake(3, 3), 2));
+  XCTAssertTrue(FBSizeFuzzyEqualToSize(referenceSize, CGSizeMake(3, 4), 2));
+  XCTAssertTrue(FBSizeFuzzyEqualToSize(referenceSize, CGSizeMake(4, 3), 2));
+}
+
+- (void)testFuzzyNotEqualSizes
+{
+  CGSize referenceSize = CGSizeMake(3, 3);
+  XCTAssertFalse(FBSizeFuzzyEqualToSize(referenceSize, CGSizeMake(5, 5), 1));
+  XCTAssertFalse(FBSizeFuzzyEqualToSize(referenceSize, CGSizeMake(3, 5), 1));
+  XCTAssertFalse(FBSizeFuzzyEqualToSize(referenceSize, CGSizeMake(5, 3), 1));
+}
+
+- (void)testFuzzyEqualRects
+{
+  CGRect referenceRect = CGRectMake(3, 3, 3, 3);
+  XCTAssertTrue(FBRectFuzzyEqualToRect(referenceRect, CGRectMake(3, 3, 3, 3), 2));
+  XCTAssertTrue(FBRectFuzzyEqualToRect(referenceRect, CGRectMake(3, 4, 3, 3), 2));
+  XCTAssertTrue(FBRectFuzzyEqualToRect(referenceRect, CGRectMake(4, 3, 3, 3), 2));
+  XCTAssertTrue(FBRectFuzzyEqualToRect(referenceRect, CGRectMake(3, 3, 3, 4), 2));
+  XCTAssertTrue(FBRectFuzzyEqualToRect(referenceRect, CGRectMake(3, 3, 4, 3), 2));
+}
+
+- (void)testFuzzyNotEqualRects
+{
+  CGRect referenceRect = CGRectMake(3, 3, 3, 3);
+  XCTAssertFalse(FBRectFuzzyEqualToRect(referenceRect, CGRectMake(5, 5, 5, 5), 1));
+  XCTAssertFalse(FBRectFuzzyEqualToRect(referenceRect, CGRectMake(3, 5, 3, 3), 1));
+  XCTAssertFalse(FBRectFuzzyEqualToRect(referenceRect, CGRectMake(5, 3, 3, 3), 1));
+  XCTAssertFalse(FBRectFuzzyEqualToRect(referenceRect, CGRectMake(3, 3, 3, 5), 1));
+  XCTAssertFalse(FBRectFuzzyEqualToRect(referenceRect, CGRectMake(3, 3, 5, 3), 1));
+}
+
+- (void)testFuzzyEqualRectsSymmetry
+{
+  CGRect referenceRect = CGRectMake(0, 0, 2, 2);
+  XCTAssertFalse(FBRectFuzzyEqualToRect(referenceRect, CGRectMake(1, 1, 3, 3), 1));
+  XCTAssertFalse(FBRectFuzzyEqualToRect(referenceRect, CGRectMake(-1, -1, 1, 1), 1));
+}
+
+- (void)testSizeInversion
+{
+  const CGSize screenSizePortrait = CGSizeMake(10, 15);
+  const CGSize screenSizeLandscape = CGSizeMake(15, 10);
+  const CGFloat t = FBDefaultFrameFuzzyThreshold;
+  XCTAssertTrue(FBSizeFuzzyEqualToSize(screenSizePortrait, FBAdjustDimensionsForApplication(screenSizePortrait, UIInterfaceOrientationPortrait), t));
+  XCTAssertTrue(FBSizeFuzzyEqualToSize(screenSizePortrait, FBAdjustDimensionsForApplication(screenSizePortrait, UIInterfaceOrientationPortraitUpsideDown), t));
+  XCTAssertTrue(FBSizeFuzzyEqualToSize(screenSizeLandscape, FBAdjustDimensionsForApplication(screenSizePortrait, UIInterfaceOrientationLandscapeLeft), t));
+  XCTAssertTrue(FBSizeFuzzyEqualToSize(screenSizeLandscape, FBAdjustDimensionsForApplication(screenSizePortrait, UIInterfaceOrientationLandscapeRight), t));
+  XCTAssertTrue(FBSizeFuzzyEqualToSize(screenSizeLandscape, FBAdjustDimensionsForApplication(screenSizeLandscape, UIInterfaceOrientationLandscapeLeft), t));
+  XCTAssertTrue(FBSizeFuzzyEqualToSize(screenSizeLandscape, FBAdjustDimensionsForApplication(screenSizeLandscape, UIInterfaceOrientationLandscapeRight), t));
+}
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/UnitTests/FBProtocolHelpersTests.m

@@ -0,0 +1,81 @@
+/**
+ * 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 "FBProtocolHelpers.h"
+
+@interface FBProtocolHelpersTests : XCTestCase
+@end
+
+@implementation FBProtocolHelpersTests
+
+- (void)testValidPrefixedCapsParsing
+{
+  NSError *error = nil;
+  NSDictionary<NSString *, id> *parsedCaps = FBParseCapabilities(@{
+    @"firstMatch": @[@{
+      @"appium:bundleId": @"com.example.id"
+    }]
+  }, &error);
+  XCTAssertNil(error);
+  XCTAssertEqualObjects(parsedCaps[@"bundleId"], @"com.example.id");
+}
+
+- (void)testValidPrefixedCapsMerging
+{
+  NSError *error = nil;
+  NSDictionary<NSString *, id> *parsedCaps = FBParseCapabilities(@{
+     @"firstMatch": @[@{
+       @"bundleId": @"com.example.id"
+     }],
+     @"alwaysMatch": @{
+       @"google:cap": @"super"
+     }
+   }, &error);
+  XCTAssertNil(error);
+  XCTAssertEqualObjects(parsedCaps[@"bundleId"], @"com.example.id");
+  XCTAssertEqualObjects(parsedCaps[@"google:cap"], @"super");
+}
+
+- (void)testEmptyCaps
+{
+  NSError *error = nil;
+  NSDictionary<NSString *, id> *parsedCaps = FBParseCapabilities(@{}, &error);
+  XCTAssertNil(error);
+  XCTAssertEqual(parsedCaps.count, 0);
+}
+
+- (void)testCapsMergingFailure
+{
+  NSError *error = nil;
+  NSDictionary<NSString *, id> *parsedCaps = FBParseCapabilities(@{
+    @"firstMatch": @[@{
+      @"appium:bundleId": @"com.example.id"
+    }],
+    @"alwaysMatch": @{
+      @"bundleId": @"other"
+    }
+  }, &error);
+  XCTAssertNil(parsedCaps);
+  XCTAssertNotNil(error);
+}
+
+- (void)testPrefixingStandardCapability
+{
+  NSError *error = nil;
+  NSDictionary<NSString *, id> *parsedCaps = FBParseCapabilities(@{
+    @"firstMatch": @[@{
+      @"appium:platformName": @"com.example.id"
+    }]
+  }, &error);
+  XCTAssertNil(parsedCaps);
+  XCTAssertNotNil(error);
+}
+
+@end