appium-webdriveragent 16.14.1 → 16.14.2

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.1",
+  "version": "16.14.2",
   "description": "Package bundling WebDriverAgent",
   "keywords": [
     "Appium",