appium-webdriveragent 16.14.0 → 16.14.2

package/WebDriverAgentTests/IntegrationTests/FBScreenTests.m

@@ -11,11 +11,23 @@
 #import "FBIntegrationTestCase.h"
 #import "FBConfiguration.h"
 #import "FBScreen.h"
+#import "FBRunLoopSpinner.h"
+#import "XCUIDevice+FBRotation.h"
+#import "XCUIDevice+FBHinge.h"
+#import "XCUIElement.h"
 #import "FBActiveAppDetectionPoint.h"
 #import "FBExceptions.h"
 #import "FBScreenRecordingRequest.h"
 #import "FBScreenshot.h"
 #import "XCUIScreen.h"
+#import "FBCustomCommands.h"
+#import "FBRouteRequest.h"
+#import "FBResponsePayload.h"
+#import "RouteResponse.h"
+
+@interface FBCustomCommands (FBScreenInfoTesting)
++ (id<FBResponsePayload>)handleGetScreen:(FBRouteRequest *)request;
+@end
 
 @interface FBScreen (FBLookupTesting)
 + (nullable XCUIScreen *)screenWithDisplayID:(long long)displayID device:(id)device error:(NSError **)error;
@@ -299,4 +311,140 @@
   XCTAssertTrue([FBScreen scale] >= 2);
 }
 
+- (NSDictionary *)screenInfoResponse
+{
+  FBRouteRequest *request = [FBRouteRequest routeRequestWithURL:[NSURL URLWithString:@"http://localhost:8100/wda/screen"]
+                                                  parameters:@{}
+                                                   arguments:@{}];
+  RouteResponse *response = [RouteResponse new];
+  [[FBCustomCommands handleGetScreen:request] dispatchWithResponse:response];
+  return [NSJSONSerialization JSONObjectWithData:response.responseData options:0 error:nil][@"value"];
+}
+
+- (void)testScreenInfoFollowsDisplaySelection
+{
+  for (NSDictionary *screen in [FBScreen screensWithError:nil]) {
+    FBConfiguration.sharedInstance.currentDisplayId = screen[@"displayId"];
+    NSDictionary *info = [self screenInfoResponse];
+    XCTAssertNil(info[@"error"]);
+    XCTAssertEqualObjects(info[@"displayId"], screen[@"displayId"]);
+    XCTAssertEqualObjects(info[@"scale"], screen[@"scale"]);
+    double width = [info[@"screenSize"][@"width"] doubleValue];
+    double height = [info[@"screenSize"][@"height"] doubleValue];
+    double scale = [screen[@"scale"] doubleValue];
+    double expectedWidth = [screen[@"bounds"][@"width"] doubleValue] / scale;
+    double expectedHeight = [screen[@"bounds"][@"height"] doubleValue] / scale;
+    XCTAssertEqualWithAccuracy(MIN(width, height), MIN(expectedWidth, expectedHeight), 0.01);
+    XCTAssertEqualWithAccuracy(MAX(width, height), MAX(expectedWidth, expectedHeight), 0.01);
+    double barHeight = [info[@"statusBarSize"][@"height"] doubleValue];
+    XCTAssertGreaterThanOrEqual(barHeight, 0);
+    XCTAssertLessThan(barHeight, height);
+    if (barHeight > 0) {
+      XCTAssertEqualWithAccuracy([info[@"statusBarSize"][@"width"] doubleValue], width, 1);
+    }
+  }
+  // tearDown restores the default display even when an assertion fails.
+}
+
+- (void)testScreenInfoFollowsDisplayReset
+{
+  // Exercise reset independently of the display-selection assertions.
+  FBConfiguration.sharedInstance.currentDisplayId = @([self unknownDisplayID]);
+  FBConfiguration.sharedInstance.currentDisplayId = nil;
+  XCTAssertEqualObjects([self screenInfoResponse][@"displayId"], @([FBScreen displayID]));
+}
+
+- (void)testScreenInfoRejectsUnavailableDisplay
+{
+  FBConfiguration.sharedInstance.currentDisplayId = @([self unknownDisplayID]);
+  NSDictionary *info = [self screenInfoResponse];
+  XCTAssertEqualObjects(info[@"error"], @"invalid argument");
+  XCTAssertTrue([info[@"message"] containsString:@"Available display ids"]);
+}
+
+- (void)testScreenInfoAcrossPortraitAndLandscapeOrientations
+{
+  XCTSkipIf(XCUIDevice.sharedDevice.fb_canAttemptSimulatedHingeAngleInjection,
+            @"Foldable orientations are covered by testScreenInfoAcrossFoldStates");
+  XCUIElement *window = self.testedApplication.windows.firstMatch;
+  (void)window.frame;
+  XCTSkipIf(window.screen.displayID != XCUIScreen.mainScreen.displayID,
+            @"Requires the fixture on the main display");
+  [self addTeardownBlock:^{
+    [[XCUIDevice sharedDevice] fb_setDeviceInterfaceOrientation:UIDeviceOrientationPortrait];
+  }];
+  BOOL expectsVisibleBar = UIDevice.currentDevice.userInterfaceIdiom == UIUserInterfaceIdiomPad;
+  for (NSNumber *orientation in @[@(UIDeviceOrientationPortrait),
+                                   @(UIDeviceOrientationLandscapeLeft),
+                                   @(UIDeviceOrientationLandscapeRight),
+                                   @(UIDeviceOrientationPortrait)]) {
+    XCTAssertTrue([[XCUIDevice sharedDevice] fb_setDeviceInterfaceOrientation:orientation.integerValue]);
+    __block NSDictionary *info = nil;
+    BOOL isPortrait = UIDeviceOrientationIsPortrait(orientation.integerValue);
+    // Include portrait before and after rotation: landscape-native iPad panels
+    // must swap their screen bounds back and retain the visible top status bar.
+    // Wait for rotation rather than accepting a transient zero crop.
+    XCTAssertTrue([[[FBRunLoopSpinner new] timeout:5] spinUntilTrue:^BOOL {
+      info = [self screenInfoResponse];
+      double width = [info[@"screenSize"][@"width"] doubleValue];
+      double height = [info[@"screenSize"][@"height"] doubleValue];
+      double barWidth = [info[@"statusBarSize"][@"width"] doubleValue];
+      double barHeight = [info[@"statusBarSize"][@"height"] doubleValue];
+      if (nil != info[@"error"] || width <= 0 || height <= 0
+          || (isPortrait ? width >= height : width <= height)) {
+        return NO;
+      }
+      if (barHeight == 0) {
+        return !expectsVisibleBar && !isPortrait && barWidth == 0;
+      }
+      return barHeight > 0 && barHeight < height && fabs(barWidth - width) <= 1;
+    }], @"Unexpected screen metadata at orientation %@: %@", orientation, info);
+  }
+}
+
+- (void)testScreenInfoAcrossFoldStates
+{
+  XCUIDevice *device = XCUIDevice.sharedDevice;
+  XCTSkipIf(!device.fb_canAttemptSimulatedHingeAngleInjection, @"Requires a foldable simulator");
+  NSError *error = nil;
+  NSNumber *originalAngle = [device fb_getSimulatedHingeAngle:&error];
+  XCTAssertNotNil(originalAngle, @"%@", error);
+  [self addTeardownBlock:^{
+    if (nil != originalAngle) {
+      [device fb_setSimulatedHingeAngle:originalAngle.doubleValue error:nil];
+    }
+  }];
+  for (NSNumber *angle in @[@0, @90, @180, @0]) {
+    [self.testedApplication terminate];
+    XCTAssertTrue([device fb_setSimulatedHingeAngle:angle.doubleValue error:&error], @"%@", error);
+    [self launchApplication];
+    XCUIElement *window = self.testedApplication.windows.firstMatch;
+    CGRect frame = window.frame;
+    FBConfiguration.sharedInstance.currentDisplayId = @(window.screen.displayID);
+    __block NSDictionary *info = nil;
+    XCTAssertTrue([[[FBRunLoopSpinner new] timeout:5] spinUntilTrue:^BOOL {
+      info = [self screenInfoResponse];
+      double width = [info[@"screenSize"][@"width"] doubleValue];
+      double height = [info[@"screenSize"][@"height"] doubleValue];
+      double barHeight = [info[@"statusBarSize"][@"height"] doubleValue];
+      return nil == info[@"error"] && fabs(width - frame.size.width) <= 1
+        && fabs(height - frame.size.height) <= 1
+        && barHeight >= 0 && barHeight < height
+        && (barHeight == 0 || fabs([info[@"statusBarSize"][@"width"] doubleValue] - width) <= 1)
+        && (angle.doubleValue == 0 || barHeight == 0);
+    }], @"Unexpected screen metadata at hinge angle %@: %@", angle, info);
+  }
+}
+
+- (void)testScreenInfoIncludesTopStatusBarOnSingleDisplay
+{
+  XCTSkipIf([FBScreen screensWithError:nil].count != 1, @"Requires a single-display device");
+  // The integration fixture uses the ordinary visible portrait status bar.
+  // An unresolved XCUIElement has displayID == 0; it must not be filtered out.
+  NSDictionary *info = [self screenInfoResponse];
+  XCTAssertGreaterThan([info[@"statusBarSize"][@"height"] doubleValue], 0);
+  XCTAssertEqualWithAccuracy([info[@"statusBarSize"][@"width"] doubleValue],
+                            [info[@"screenSize"][@"width"] doubleValue], 1);
+}
+
 @end

package/WebDriverAgentTests/IntegrationTests/FBW3CTouchActionsIntegrationTests.m

@@ -9,6 +9,9 @@
 #import <XCTest/XCTest.h>
 
 #import "FBIntegrationTestCase.h"
+#import "FBConfiguration.h"
+#import "FBMathUtils.h"
+#import "FBScreen.h"
 
 #import "XCUIElement.h"
 #import "XCUIDevice.h"
@@ -21,6 +24,7 @@
 #import "XCSynthesizedEventRecord.h"
 #import "XCPointerEventPath.h"
 #import "XCPointerEvent.h"
+#import "XCUIScreen.h"
 
 @interface FBW3CTouchActionsIntegrationTestsPart1 : FBIntegrationTestCase
 @end
@@ -32,9 +36,36 @@
 
 @implementation FBW3CTouchActionsIntegrationTestsPart1
 
+- (void)testDisplayIndependentActionsAfterSelectedDisplayDisappears
+{
+  // setUp already opens the Alerts fixture; relaunching would reset that page
+  // and break the subsequent touch tests that share it.
+  NSNumber *previous = FBConfiguration.sharedInstance.currentDisplayId;
+  [self addTeardownBlock:^{ FBConfiguration.sharedInstance.currentDisplayId = previous; }];
+  NSArray *sequences = @[
+    @{@"id": @"keyboard", @"type": @"key", @"actions": @[@{@"type": @"keyDown", @"value": @"a"}, @{@"type": @"keyUp", @"value": @"a"}]},
+    @{@"id": @"finger", @"type": @"pointer", @"parameters": @{@"pointerType": @"touch"}, @"actions": @[@{@"type": @"pause", @"duration": @10}]}
+  ];
+  for (NSDictionary *sequence in sequences) {
+    for (NSNumber *display in @[@1, @987654]) {
+      FBConfiguration.sharedInstance.currentDisplayId = display;
+      NSError *error = nil;
+      FBW3CActionsSynthesizer *synthesizer = [[FBW3CActionsSynthesizer alloc] initWithActions:@[sequence] forApplication:self.testedApplication elementCache:nil error:&error];
+      XCSynthesizedEventRecord *record = [synthesizer synthesizeWithError:&error];
+      XCTAssertNotNil(record, @"Display-independent %@ should succeed: %@", sequence[@"type"], error);
+    }
+  }
+}
+
 - (void)verifyGesture:(NSArray<NSDictionary<NSString *, id> *> *)gesture orientation:(UIDeviceOrientation)orientation
 {
   [[XCUIDevice sharedDevice] fb_setDeviceInterfaceOrientation:orientation];
+  // XCTest may report the new interface orientation while the Alerts button
+  // still has transposed geometry from the rotation transition. The fixture's
+  // button is wider than it is tall in every settled orientation. Wait for that
+  // layout before resolving the W3C action's element-origin coordinates.
+  XCUIElement *button = self.testedApplication.buttons[FBShowAlertButtonName];
+  FBAssertWaitTillBecomesTrue(CGRectGetWidth(button.frame) > CGRectGetHeight(button.frame));
   NSError *error;
   XCTAssertTrue([self.testedApplication fb_performW3CActions:gesture elementCache:nil error:&error]);
   FBAssertWaitTillBecomesTrue(self.testedApplication.alerts.count > 0);
@@ -53,11 +84,106 @@
 
 - (void)tearDown
 {
+  FBConfiguration.sharedInstance.currentDisplayId = nil;
   [self clearAlert];
   [self resetOrientation];
   [super tearDown];
 }
 
+- (nullable XCSynthesizedEventRecord *)tapRecordWithError:(NSError **)error
+{
+  NSArray *gesture = @[@{
+    @"type": @"pointer", @"id": @"finger", @"parameters": @{@"pointerType": @"touch"},
+    @"actions": @[
+      @{@"type": @"pointerMove", @"x": @100, @"y": @100, @"duration": @0},
+      @{@"type": @"pointerDown", @"button": @0},
+      @{@"type": @"pointerUp", @"button": @0},
+    ],
+  }];
+  FBW3CActionsSynthesizer *synthesizer = [[FBW3CActionsSynthesizer alloc] initWithActions:gesture
+                                                                           forApplication:self.testedApplication
+                                                                             elementCache:nil
+                                                                                    error:error];
+  return [synthesizer synthesizeWithError:error];
+}
+
+- (NSArray<XCPointerEvent *> *)pointerEventsOfRecord:(XCSynthesizedEventRecord *)record
+{
+  XCPointerEventPath *eventPath = record.eventPaths.firstObject;
+  return eventPath.pointerEvents;
+}
+
+- (void)testMainDisplaySettingKeepsDefaultCoordinates
+{
+  for (NSNumber *orientation in @[@(UIDeviceOrientationPortrait),
+                                  @(UIDeviceOrientationLandscapeLeft),
+                                  @(UIDeviceOrientationLandscapeRight)]) {
+    [[XCUIDevice sharedDevice] fb_setDeviceInterfaceOrientation:orientation.integerValue];
+    NSError *error = nil;
+    FBConfiguration.sharedInstance.currentDisplayId = nil;
+    XCSynthesizedEventRecord *baseline = [self tapRecordWithError:&error];
+    FBConfiguration.sharedInstance.currentDisplayId = @([FBScreen displayID]);
+    XCSynthesizedEventRecord *selected = [self tapRecordWithError:&error];
+    XCTAssertNotNil(baseline);
+    XCTAssertNotNil(selected);
+    XCTAssertNil(error);
+    NSArray<XCPointerEvent *> *baselineEvents = [self pointerEventsOfRecord:baseline];
+    NSArray<XCPointerEvent *> *selectedEvents = [self pointerEventsOfRecord:selected];
+    XCTAssertEqual(baselineEvents.count, selectedEvents.count);
+    for (NSUInteger i = 0; i < baselineEvents.count; i++) {
+      XCTAssertTrue(CGPointEqualToPoint(baselineEvents[i].coordinate, selectedEvents[i].coordinate));
+    }
+  }
+}
+
+- (void)testUnavailableDisplaySettingIsRejected
+{
+  long long maxID = 0;
+  for (NSDictionary<NSString *, id> *screen in [FBScreen screensWithError:nil]) {
+    maxID = MAX(maxID, [screen[@"displayId"] longLongValue]);
+  }
+  FBConfiguration.sharedInstance.currentDisplayId = @(maxID + 1);
+  NSError *error = nil;
+  XCTAssertNil([self tapRecordWithError:&error]);
+  XCTAssertNotNil(error);
+}
+
+- (void)testSecondaryDisplaySetting
+{
+  XCUIScreen *secondary = nil;
+  NSError *error = nil;
+  NSArray<NSDictionary<NSString *, id> *> *screens = [FBScreen screensWithError:&error];
+  XCTAssertNotNil(screens);
+  XCTAssertNil(error);
+  for (NSDictionary<NSString *, id> *screen in screens) {
+    long long displayID = [screen[@"displayId"] longLongValue];
+    if (displayID != [FBScreen displayID]) {
+      secondary = [FBScreen screenWithDisplayID:displayID error:&error];
+      XCTAssertNotNil(secondary);
+      XCTAssertNil(error);
+      break;
+    }
+  }
+  if (nil == secondary) {
+    XCTSkip(@"The device has no secondary display");
+  }
+  XCSynthesizedEventRecord *baseline = [self tapRecordWithError:&error];
+  FBConfiguration.sharedInstance.currentDisplayId = @(secondary.displayID);
+  XCSynthesizedEventRecord *selected = [self tapRecordWithError:&error];
+  XCTAssertNotNil(selected);
+  XCTAssertNil(error);
+  XCTAssertEqual(selected.displayID, (unsigned long long)secondary.displayID);
+  XCUIScreen *main = XCUIScreen.mainScreen;
+  CGVector offset = FBDisplayCoordinateOffset(
+    CGSizeMake(main.bounds.size.width / main.scale, main.bounds.size.height / main.scale),
+    CGSizeMake(secondary.bounds.size.width / secondary.scale, secondary.bounds.size.height / secondary.scale),
+    selected.interfaceOrientation);
+  CGPoint expected = [self pointerEventsOfRecord:baseline].firstObject.coordinate;
+  CGPoint actual = [self pointerEventsOfRecord:selected].firstObject.coordinate;
+  XCTAssertEqual(actual.x, expected.x + offset.dx);
+  XCTAssertEqual(actual.y, expected.y + offset.dy);
+}
+
 - (void)testErroneousGestures
 {
   NSArray<NSArray<NSDictionary<NSString *, id> *> *> *invalidGestures =

package/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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium-webdriveragent",
-  "version": "16.14.0",
+  "version": "16.14.2",
   "description": "Package bundling WebDriverAgent",
   "keywords": [
     "Appium",