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

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

@@ -12,12 +12,17 @@
 #import "FBElementCache.h"
 #import "FBRouteRequest-Private.h"
 #import "FBSession.h"
+#import "FBResponsePayload.h"
+#import "RouteResponse.h"
+#import "XCUIDevice+FBHinge.h"
 #import "Doubles/XCUIElementDouble.h"
 
 #if !TARGET_OS_TV && __clang_major__ >= 15
 
 @interface FBCustomCommands (FBWDATestable)
 + (id<FBResponsePayload>)handleKeyboardInput:(FBRouteRequest *)request;
++ (id<FBResponsePayload>)handleGetSimulatedHingeAngle:(FBRouteRequest *)request;
++ (id<FBResponsePayload>)handleSetSimulatedHingeAngle:(FBRouteRequest *)request;
 @end
 
 @interface FBCustomCommandsTests : XCTestCase
@@ -78,6 +83,62 @@
   XCTAssertEqual(element.lastTypedModifierFlags, 2);
 }
 
+- (NSDictionary *)hingeResponseWithArguments:(NSDictionary *)arguments
+{
+  FBRouteRequest *request = [FBRouteRequest routeRequestWithURL:[NSURL URLWithString:@"http://localhost:8100/"]
+                                                  parameters:@{}
+                                                   arguments:arguments];
+  RouteResponse *response = [RouteResponse new];
+  [[FBCustomCommands handleSetSimulatedHingeAngle:request] dispatchWithResponse:response];
+  return [NSJSONSerialization JSONObjectWithData:response.responseData options:0 error:nil];
+}
+
+- (void)testHingeAngleReading
+{
+  NSError *error = nil;
+  NSNumber *angle = [XCUIDevice.sharedDevice fb_getSimulatedHingeAngle:&error];
+  BOOL available = XCUIDevice.sharedDevice.fb_supportsHingeAngleReading;
+  if (available) {
+    XCTAssertNotNil(angle);
+    XCTAssertNil(error);
+    XCTAssertTrue(isfinite(angle.doubleValue));
+  } else {
+    XCTAssertNil(angle);
+    XCTAssertNotNil(error);
+  }
+
+  FBRouteRequest *request = [FBRouteRequest routeRequestWithURL:[NSURL URLWithString:@"http://localhost:8100/"]
+                                                  parameters:@{}
+                                                   arguments:@{}];
+  RouteResponse *response = [RouteResponse new];
+  [[FBCustomCommands handleGetSimulatedHingeAngle:request] dispatchWithResponse:response];
+  NSDictionary *body = [NSJSONSerialization JSONObjectWithData:response.responseData options:0 error:nil];
+  if (available) {
+    XCTAssertTrue([body[@"value"] isKindOfClass:NSNumber.class]);
+    XCTAssertTrue(isfinite([body[@"value"] doubleValue]));
+  } else {
+    XCTAssertEqualObjects(body[@"value"][@"error"], @"unsupported operation");
+  }
+}
+
+- (void)testHingeAngleRejectsInvalidArguments
+{
+  for (id value in @[@(-1), @181, @YES, @"90", NSNull.null, @(NAN), @(INFINITY)]) {
+    NSDictionary *response = [self hingeResponseWithArguments:@{@"angle": value}];
+    XCTAssertEqualObjects(response[@"value"][@"error"], @"invalid argument");
+  }
+  XCTAssertEqualObjects([self hingeResponseWithArguments:@{}][@"value"][@"error"], @"invalid argument");
+}
+
+- (void)testHingeAngleRejectsUnsupportedDevices
+{
+  XCTSkipIf(XCUIDevice.sharedDevice.fb_canAttemptSimulatedHingeAngleInjection, @"Requires a device without an available hinge");
+  for (NSNumber *angle in @[@0, @90, @180]) {
+    XCTAssertEqualObjects([self hingeResponseWithArguments:@{@"angle": angle}][@"value"][@"error"],
+                          @"unsupported operation");
+  }
+}
+
 @end
 
 #endif

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

@@ -12,12 +12,52 @@
 #import "FBElement.h"
 #import "XCUIElementDouble.h"
 #import "FBElementUtils.h"
+#import "FBConfiguration.h"
+#import "XCUIElement+FBUtilities.h"
+#import <objc/runtime.h>
+
+@interface FBQuiescenceApplicationDouble : NSObject
+@property (nonatomic) BOOL fb_shouldWaitForQuiescence;
+@property (nonatomic) NSTimeInterval observedTimeout;
+@end
+@implementation FBQuiescenceApplicationDouble
+- (id)applicationImpl { return self; }
+- (id)currentProcess { return self; }
+- (void)fb_waitForQuiescenceIncludingAnimationsIdle:(BOOL)includingAnimations
+{
+  self.observedTimeout = FBConfiguration.sharedInstance.waitForIdleTimeout;
+  @throw [NSException exceptionWithName:@"QuiescenceFailure" reason:@"test" userInfo:nil];
+}
+@end
 
 @interface FBElementUtilitiesTests : XCTestCase
 @end
 
 @implementation FBElementUtilitiesTests
 
+- (void)testStabilityWaitRestoresSettingsAfterAnException
+{
+  NSTimeInterval originalTimeout = FBConfiguration.sharedInstance.waitForIdleTimeout;
+  FBQuiescenceApplicationDouble *application = [FBQuiescenceApplicationDouble new];
+  XCUIElementDouble *element = [XCUIElementDouble new];
+  element.application = (id)application;
+  SEL selector = @selector(fb_waitUntilStableWithTimeout:);
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcast-function-type-strict"
+  void (*wait)(id, SEL, NSTimeInterval) = (void (*)(id, SEL, NSTimeInterval))
+    class_getMethodImplementation(XCUIElement.class, selector);
+#pragma clang diagnostic pop
+  @try {
+    FBConfiguration.sharedInstance.waitForIdleTimeout = 17;
+    XCTAssertThrowsSpecificNamed(wait(element, selector, 2), NSException, @"QuiescenceFailure");
+    XCTAssertEqual(application.observedTimeout, 2);
+    XCTAssertFalse(application.fb_shouldWaitForQuiescence);
+    XCTAssertEqual(FBConfiguration.sharedInstance.waitForIdleTimeout, 17);
+  } @finally {
+    FBConfiguration.sharedInstance.waitForIdleTimeout = originalTimeout;
+  }
+}
+
 - (void)testTypesFiltering {
   NSMutableArray *elements = [NSMutableArray new];
   XCUIElementDouble *el1 = [XCUIElementDouble new];

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

@@ -13,6 +13,7 @@
 #import <sys/socket.h>
 
 #import "FBHTTPServer.h"
+#import "FBSession-Private.h"
 
 static atomic_int gSessionProbeHits;
 
@@ -23,10 +24,26 @@ static atomic_int gSessionProbeHits;
 
 @implementation FBHTTPServerSessionTests
 
+- (void)testAbandonmentDoesNotRetainResponsesAfterPendingRequestsDrain
+{
+  __weak RouteResponse *weakResponse;
+  @autoreleasepool {
+    RouteResponse *response = [RouteResponse new];
+    [response respondWithString:@"deleted"];
+    weakResponse = response;
+    for (NSUInteger index = 0; index < 1000; index++) {
+      [self.server abandonPendingRequestsForSessionID:[NSString stringWithFormat:@"old-%lu", (unsigned long)index]
+                                         withResponse:response];
+    }
+  }
+  XCTAssertNil(weakResponse);
+}
+
 - (void)setUp
 {
   [super setUp];
   atomic_store(&gSessionProbeHits, 0);
+  [FBSession initWithApplication:nil].identifier = @"live-session";
   self.server = [FBHTTPServer new];
   [self.server get:@"/session/:sessionID/probe" withBlock:^(RouteRequest *request, RouteResponse *response) {
     atomic_fetch_add(&gSessionProbeHits, 1);
@@ -42,6 +59,7 @@ static atomic_int gSessionProbeHits;
 {
   [self.server stop:NO];
   self.server = nil;
+  [FBSession.activeSession kill];
   [super tearDown];
 }
 
@@ -93,14 +111,14 @@ static atomic_int gSessionProbeHits;
 
   NSString *response = [self responseForRawPayload:(NSData * _Nonnull)[@"GET /session/dead-session/probe HTTP/1.1\r\n\r\n" dataUsingEncoding:NSUTF8StringEncoding]
                                             timeout:5.0];
-  XCTAssertTrue([response containsString:@"session-was-deleted"], @"%@", response);
+  XCTAssertTrue([response containsString:@"invalid session id"], @"%@", response);
   XCTAssertEqual(atomic_load(&gSessionProbeHits), 0, @"the route must not run for a deleted session");
 }
 
 - (void)testAbandonedSessionIsRememberedAfterManyLaterAbandonments
 {
-  // Abandoned ids are kept for the server's lifetime; evicting them would let a stale request
-  // queue on a possibly wedged route queue again, which is the hang this rejection prevents.
+  // A stale UUID must still be rejected after arbitrarily many other sessions,
+  // without needing to remember every deleted UUID.
   RouteResponse *abandonedResponse = [RouteResponse new];
   [abandonedResponse respondWithString:@"session-was-deleted"];
   [self.server abandonPendingRequestsForSessionID:@"dead-session" withResponse:abandonedResponse];
@@ -113,7 +131,7 @@ static atomic_int gSessionProbeHits;
 
   NSString *response = [self responseForRawPayload:(NSData * _Nonnull)[@"GET /session/dead-session/probe HTTP/1.1\r\n\r\n" dataUsingEncoding:NSUTF8StringEncoding]
                                             timeout:5.0];
-  XCTAssertTrue([response containsString:@"session-was-deleted"], @"%@", response);
+  XCTAssertTrue([response containsString:@"invalid session id"], @"%@", response);
   XCTAssertEqual(atomic_load(&gSessionProbeHits), 0, @"the route must not run for a deleted session");
 }
 

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

@@ -14,14 +14,44 @@
 #import <unistd.h>
 
 #import "FBHTTPServer.h"
+#import "FBTCPSocket.h"
+#import "FBWebServer.h"
+
+@interface FBWebServer (FBWDATestable)
+- (void)registerServerKeyRouteHandlers;
+@end
 
 static atomic_int gFramingProbeHits;
 
+// The response in `data` once all of it has arrived - its header block and Content-Length body -
+// or nil while more is due.
+static NSString *FBCompleteResponse(NSData *data)
+{
+  NSData *separator = (NSData * _Nonnull)[@"\r\n\r\n" dataUsingEncoding:NSUTF8StringEncoding];
+  NSRange headerEnd = [data rangeOfData:separator options:(NSDataSearchOptions)0 range:NSMakeRange(0, data.length)];
+  if (NSNotFound == headerEnd.location) {
+    return nil;
+  }
+  NSString *headers = [[NSString alloc] initWithData:[data subdataWithRange:NSMakeRange(0, headerEnd.location)] encoding:NSUTF8StringEncoding];
+  NSUInteger contentLength = 0;
+  for (NSString *line in [headers componentsSeparatedByString:@"\r\n"]) {
+    NSArray<NSString *> *field = [line componentsSeparatedByString:@":"];
+    if (2 == field.count && NSOrderedSame == [field[0] caseInsensitiveCompare:@"Content-Length"]) {
+      contentLength = (NSUInteger)[field[1] stringByTrimmingCharactersInSet:NSCharacterSet.whitespaceCharacterSet].integerValue;
+    }
+  }
+  if (data.length < NSMaxRange(headerEnd) + contentLength) {
+    return nil;
+  }
+  return [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+}
+
 // Exercises FBHTTPServer's HTTP framing defenses with raw socket data that URL-loading APIs
 // cannot produce: malformed Content-Length values and header blocks that never terminate.
 @interface FBHTTPServerTests : XCTestCase
 @property (nonatomic, strong) FBHTTPServer *server;
 @property (nonatomic, assign) uint16_t port;
+@property (nonatomic, strong) dispatch_semaphore_t slowRouteStarted;
 @end
 
 @implementation FBHTTPServerTests
@@ -38,6 +68,13 @@ static atomic_int gFramingProbeHits;
   [self.server get:@"/framing/ping" withBlock:^(RouteRequest *request, RouteResponse *response) {
     [response respondWithString:@"pong"];
   }];
+  dispatch_semaphore_t slowRouteStarted = dispatch_semaphore_create(0);
+  self.slowRouteStarted = slowRouteStarted;
+  [self.server get:@"/framing/slow" withBlock:^(RouteRequest *request, RouteResponse *response) {
+    dispatch_semaphore_signal(slowRouteStarted);
+    [NSThread sleepForTimeInterval:0.5];
+    [response respondWithString:@"slow-ok"];
+  }];
   self.server.port = 0;
   NSError *error;
   XCTAssertTrue([self.server start:&error], @"%@", error);
@@ -51,14 +88,12 @@ static atomic_int gFramingProbeHits;
   [super tearDown];
 }
 
-// Sends `payload` as-is and reads until the server closes the connection or `timeout` elapses.
-// Returns everything received (nil on connect failure); *didClose reports whether EOF was seen.
-- (NSString *)responseForRawPayload:(NSData *)payload timeout:(NSTimeInterval)timeout didClose:(BOOL *)didClose
+// A socket connected to the server that gives up reading after `timeout`, or -1.
+- (int)connectedSocketWithTimeout:(NSTimeInterval)timeout
 {
-  *didClose = NO;
   int fd = socket(AF_INET, SOCK_STREAM, 0);
   if (fd < 0) {
-    return nil;
+    return -1;
   }
   int noSigpipe = 1;
   setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, &noSigpipe, sizeof(noSigpipe));
@@ -68,6 +103,84 @@ static atomic_int gFramingProbeHits;
   addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
   if (0 != connect(fd, (struct sockaddr *)&addr, sizeof(addr))) {
     close(fd);
+    return -1;
+  }
+  return fd;
+}
+
+// Descriptors in this process bound to the server's port: its listener plus one per server-side
+// connection still open. Client sockets are bound to ephemeral ports, so they never count.
+- (NSInteger)serverSocketCount
+{
+  NSInteger count = 0;
+  int limit = getdtablesize();
+  for (int fd = 0; fd < limit; fd++) {
+    struct sockaddr_storage addr;
+    socklen_t length = sizeof(addr);
+    if (0 != getsockname(fd, (struct sockaddr *)&addr, &length)) {
+      continue;
+    }
+    in_port_t port = 0;
+    if (AF_INET == addr.ss_family) {
+      port = ((struct sockaddr_in *)&addr)->sin_port;
+    } else if (AF_INET6 == addr.ss_family) {
+      port = ((struct sockaddr_in6 *)&addr)->sin6_port;
+    }
+    if (ntohs(port) == self.port) {
+      count++;
+    }
+  }
+  return count;
+}
+
+// The server learns about hang-ups asynchronously: polls until it holds `expected` sockets or
+// 5 seconds pass, and returns the last count.
+- (NSInteger)serverSocketCountSettlingAt:(NSInteger)expected
+{
+  NSInteger count = [self serverSocketCount];
+  NSDate *deadline = [NSDate dateWithTimeIntervalSinceNow:5.0];
+  while (count != expected && deadline.timeIntervalSinceNow > 0) {
+    [NSThread sleepForTimeInterval:0.05];
+    count = [self serverSocketCount];
+  }
+  return count;
+}
+
+// Sends `request` on a new connection, reads its complete response and then hangs up first, the
+// way curl or iproxy end a keep-alive exchange. Returns nil unless the server answered and still
+// held its side open when the client hung up.
+- (NSString *)responseClosingFirstForRequest:(NSString *)request
+{
+  int fd = [self connectedSocketWithTimeout:5.0];
+  if (fd < 0) {
+    return nil;
+  }
+  NSData *payload = (NSData * _Nonnull)[request dataUsingEncoding:NSUTF8StringEncoding];
+  send(fd, payload.bytes, payload.length, 0);
+  NSMutableData *received = [NSMutableData data];
+  NSString *response = nil;
+  char chunk[4096];
+  while (nil == response) {
+    ssize_t n = recv(fd, chunk, sizeof(chunk), 0);
+    if (n <= 0) {
+      break;
+    }
+    [received appendBytes:chunk length:(NSUInteger)n];
+    response = FBCompleteResponse(received);
+  }
+  char probe;
+  BOOL isStillOpen = -1 == recv(fd, &probe, 1, MSG_PEEK | MSG_DONTWAIT) && EAGAIN == errno;
+  close(fd);
+  return isStillOpen ? response : nil;
+}
+
+// Sends `payload` as-is and reads until the server closes the connection or `timeout` elapses.
+// Returns everything received (nil on connect failure); *didClose reports whether EOF was seen.
+- (NSString *)responseForRawPayload:(NSData *)payload timeout:(NSTimeInterval)timeout didClose:(BOOL *)didClose
+{
+  *didClose = NO;
+  int fd = [self connectedSocketWithTimeout:timeout];
+  if (fd < 0) {
     return nil;
   }
   // send(2) may write only part of the payload, which would truncate the multi-KiB flood
@@ -122,6 +235,87 @@ static atomic_int gFramingProbeHits;
   XCTAssertTrue([response containsString:@"pong"], @"%@", response);
 }
 
+- (void)testHealthRespondsWhileRouteQueueIsBlocked
+{
+  FBWebServer *webServer = [FBWebServer new];
+  [webServer setValue:self.server forKey:@"server"];
+  [webServer registerServerKeyRouteHandlers];
+  dispatch_queue_t routeQueue = dispatch_queue_create("com.facebook.wda.test.health", DISPATCH_QUEUE_SERIAL);
+  [self.server setRouteQueue:routeQueue];
+  dispatch_suspend(routeQueue);
+  @try {
+    NSString *response = [self responseClosingFirstForRequest:@"GET /health HTTP/1.1\r\nHost: localhost\r\n\r\n"];
+    XCTAssertTrue([response hasPrefix:@"HTTP/1.1 200"], @"%@", response);
+    XCTAssertTrue([response hasSuffix:@"<!DOCTYPE html><html><title>Health Check</title><body><p>I-AM-ALIVE</p></body></html>"], @"%@", response);
+  } @finally {
+    dispatch_resume(routeQueue);
+    dispatch_sync(routeQueue, ^{});
+  }
+}
+
+- (void)testConnectionsTheClientClosesReleaseTheirSockets
+{
+  // The server keeps a connection open after answering, so the client is the one that hangs up.
+  // Each such connection must give its server-side socket back, or a long-running server
+  // eventually fails every request with EMFILE.
+  NSInteger baseline = [self serverSocketCount];
+  for (int i = 0; i < 50; i++) {
+    NSString *response = [self responseClosingFirstForRequest:@"GET /framing/ping HTTP/1.1\r\n\r\n"];
+    XCTAssertTrue([response containsString:@"pong"], @"%@", response);
+  }
+  XCTAssertEqual([self serverSocketCountSettlingAt:baseline], baseline);
+}
+
+- (void)testEofWaitsForPreviouslyReceivedBytesToBeParsed
+{
+  FBHTTPServer *server = [FBHTTPServer new];
+  __block NSUInteger calls = 0;
+  [server get:@"/probe" withBlock:^(RouteRequest *request, RouteResponse *response) {
+    calls++;
+  }];
+  dispatch_queue_t queue = [server valueForKey:@"bufferProcessingQueue"];
+  nw_connection_t client = nw_connection_create(nw_endpoint_create_host("127.0.0.1", "1"),
+    nw_parameters_create_secure_tcp(NW_PARAMETERS_DISABLE_PROTOCOL, NW_PARAMETERS_DEFAULT_CONFIGURATION));
+  id<FBTCPSocketDelegate> delegate = (id)server;
+  [delegate didClientConnect:client];
+  dispatch_suspend(queue);
+  @try {
+    NSData *data = [@"GET /probe HTTP/1.1\r\n\r\n" dataUsingEncoding:NSUTF8StringEncoding];
+    [delegate client:client didReceiveData:data];
+    [delegate didClientDisconnect:client];
+  } @finally {
+    dispatch_resume(queue);
+  }
+  dispatch_sync(queue, ^{});
+  XCTAssertEqual(calls, 1u);
+  [server stop:YES];
+  nw_connection_cancel(client);
+}
+
+- (void)testHalfClosedClientGetsItsResponseAndIsThenClosed
+{
+  // A client may shut down its sending side right after the request and wait for the response.
+  // Its end-of-stream must not cost it that response, and the server must close afterwards.
+  NSInteger baseline = [self serverSocketCount];
+  int fd = [self connectedSocketWithTimeout:5.0];
+  XCTAssertGreaterThanOrEqual(fd, 0);
+  NSData *payload = (NSData * _Nonnull)[@"GET /framing/slow HTTP/1.1\r\n\r\n" dataUsingEncoding:NSUTF8StringEncoding];
+  XCTAssertEqual(send(fd, payload.bytes, payload.length, 0), (ssize_t)payload.length);
+  XCTAssertEqual(dispatch_semaphore_wait(self.slowRouteStarted, dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC))), 0L);
+  XCTAssertEqual(shutdown(fd, SHUT_WR), 0);
+  NSMutableData *received = [NSMutableData data];
+  char chunk[4096];
+  ssize_t n;
+  while ((n = recv(fd, chunk, sizeof(chunk), 0)) > 0) {
+    [received appendBytes:chunk length:(NSUInteger)n];
+  }
+  close(fd);
+  NSString *response = [[NSString alloc] initWithData:received encoding:NSUTF8StringEncoding];
+  XCTAssertTrue([response containsString:@"slow-ok"], @"%@", response);
+  XCTAssertEqual(n, (ssize_t)0, @"the server must close the connection once it has answered");
+  XCTAssertEqual([self serverSocketCountSettlingAt:baseline], baseline);
+}
+
 - (void)testNonNumericContentLengthIsRejected
 {
   // Under -integerValue's lenient parsing "bogus" became 0: the probe route would run with an

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

@@ -15,6 +15,40 @@
 
 @implementation FBLRUCacheTests
 
+- (void)testDestroyingCacheReleasesAllValues
+{
+  __weak NSObject *firstValue;
+  __weak NSObject *secondValue;
+  @autoreleasepool {
+    LRUCache *cache = [[LRUCache alloc] initWithCapacity:2];
+    NSObject *first = [NSObject new];
+    NSObject *second = [NSObject new];
+    firstValue = first;
+    secondValue = second;
+    [cache setObject:first forKey:@"first"];
+    [cache setObject:second forKey:@"second"];
+    XCTAssertNotNil([cache objectForKey:@"first"]);
+  }
+  XCTAssertNil(firstValue);
+  XCTAssertNil(secondValue);
+}
+
+- (void)testRemovingValueReleasesItWhileCacheRemainsAlive
+{
+  LRUCache *cache = [[LRUCache alloc] initWithCapacity:3];
+  __weak NSObject *removedValue;
+  @autoreleasepool {
+    NSObject *value = [NSObject new];
+    removedValue = value;
+    [cache setObject:@"oldest" forKey:@"oldest"];
+    [cache setObject:value forKey:@"removed"];
+    [cache setObject:@"newest" forKey:@"newest"];
+    [cache removeObjectForKey:@"removed"];
+  }
+  XCTAssertNil(removedValue);
+  XCTAssertEqualObjects(cache.allObjects, (@[@"newest", @"oldest"]));
+}
+
 - (void)assertArray:(NSArray *)array1 equalsTo:(NSArray *)array2
 {
   XCTAssertEqualObjects(array1, array2);

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

@@ -148,4 +148,49 @@
   XCTAssertTrue(endOffset.dx == -1 && endOffset.dy == -1);
 }
 
+- (void)testDisplayCoordinateOffsets
+{
+  CGSize mainSize = CGSizeMake(402, 874);
+  CGSize innerSize = CGSizeMake(669, 951);
+  NSArray<NSNumber *> *orientations = @[
+    @(UIInterfaceOrientationPortrait),
+    @(UIInterfaceOrientationLandscapeLeft),
+    @(UIInterfaceOrientationLandscapeRight),
+    @(UIInterfaceOrientationPortraitUpsideDown),
+  ];
+  NSArray<NSValue *> *expected = @[
+    [NSValue valueWithCGPoint:CGPointZero],
+    [NSValue valueWithCGPoint:CGPointMake(0, 77)],
+    [NSValue valueWithCGPoint:CGPointMake(267, 0)],
+    [NSValue valueWithCGPoint:CGPointMake(267, 77)],
+  ];
+  for (NSUInteger i = 0; i < orientations.count; i++) {
+    UIInterfaceOrientation orientation = orientations[i].integerValue;
+    CGVector offset = FBDisplayCoordinateOffset(mainSize, innerSize, orientation);
+    XCTAssertEqual(offset.dx, expected[i].CGPointValue.x);
+    XCTAssertEqual(offset.dy, expected[i].CGPointValue.y);
+    CGVector sameDisplay = FBDisplayCoordinateOffset(mainSize, mainSize, orientation);
+    XCTAssertEqual(sameDisplay.dx, 0);
+    XCTAssertEqual(sameDisplay.dy, 0);
+    CGVector reverse = FBDisplayCoordinateOffset(innerSize, mainSize, orientation);
+    XCTAssertEqual(reverse.dx, -expected[i].CGPointValue.x);
+    XCTAssertEqual(reverse.dy, -expected[i].CGPointValue.y);
+  }
+}
+
+- (void)testPortraitVisibleFrameRotation
+{
+  CGSize size = CGSizeMake(669, 951);
+  CGRect clipped = CGRectMake(200, 100, 300, 400);
+  XCTAssertTrue(CGRectEqualToRect(FBRectFromPortraitCoordinates(clipped, size, UIInterfaceOrientationPortrait), clipped));
+  XCTAssertTrue(CGRectEqualToRect(FBRectFromPortraitCoordinates(clipped, size, UIInterfaceOrientationLandscapeLeft), CGRectMake(451, 200, 400, 300)));
+  XCTAssertTrue(CGRectEqualToRect(FBRectFromPortraitCoordinates(clipped, size, UIInterfaceOrientationLandscapeRight), CGRectMake(100, 169, 400, 300)));
+  XCTAssertTrue(CGRectEqualToRect(FBRectFromPortraitCoordinates(clipped, size, UIInterfaceOrientationPortraitUpsideDown), CGRectMake(169, 451, 300, 400)));
+  // Observed on Duo's inner landscape display: keep the clipping in the same
+  // coordinate space as the element's reported frame.
+  XCTAssertTrue(CGRectEqualToRect(FBRectFromPortraitCoordinates(CGRectMake(236, 104, 379, 827), size, UIInterfaceOrientationLandscapeLeft), CGRectMake(20, 236, 827, 379)));
+  XCTAssertTrue(CGRectIsEmpty(FBRectFromPortraitCoordinates(CGRectZero, size, UIInterfaceOrientationLandscapeLeft)));
+  XCTAssertTrue(CGRectIsNull(FBRectFromPortraitCoordinates(CGRectNull, size, UIInterfaceOrientationLandscapeLeft)));
+}
+
 @end