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

package/drivers/ios/WebDriverAgent/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/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests/XCUIApplicationHelperTests.m

@@ -9,15 +9,29 @@
 #import <XCTest/XCTest.h>
 
 #import <mach/mach_time.h>
+#import <math.h>
 
 #import "FBIntegrationTestCase.h"
 #import "FBElement.h"
+#import "FBSession.h"
+#import "FBSessionCommands.h"
 #import "FBMacros.h"
 #import "FBTestMacros.h"
 #import "XCUIApplication.h"
 #import "XCUIApplication+FBHelpers.h"
 #import "XCUIElement+FBIsVisible.h"
 #import "FBXCodeCompatibility.h"
+#import "FBConfiguration.h"
+#import "FBScreen.h"
+#import "FBRunLoopSpinner.h"
+#import "XCUIDevice+FBHinge.h"
+
+// Exercise the session-start resume path without creating a second session.
+@interface FBSessionCommands (FBActivationTests)
++ (id)activateBackgroundApplication:(XCUIApplication *)app
+                          bundleID:(NSString *)bundleID
+                        initialUrl:(nullable NSString *)initialUrl;
+@end
 
 void calculateMaxTreeDepth(NSDictionary *tree, NSNumber *currentDepth, NSNumber** maxDepth) {
   if (nil == maxDepth) {
@@ -83,6 +97,103 @@ void calculateMaxTreeDepth(NSDictionary *tree, NSNumber *currentDepth, NSNumber*
   XCTAssertTrue(self.testedApplication.buttons[@"Alerts"].exists);
 }
 
+- (void)testInputAfterDeactivate
+{
+  [self verifyInputAfterBackgroundWithMode:0];
+}
+
+- (void)testInputAfterSessionActivate
+{
+  [self verifyInputAfterBackgroundWithMode:1];
+}
+
+- (void)testInputAfterSessionLaunch
+{
+  [self verifyInputAfterBackgroundWithMode:2];
+}
+
+- (void)testInputAfterSessionStartActivate
+{
+  [self verifyInputAfterBackgroundWithMode:3];
+}
+
+- (void)verifyInputAfterBackgroundWithMode:(NSUInteger)mode
+{
+  XCTSkipIf(self.class.isRunningInCI, @"Immediate input after activation is unreliable on slow CI hosts");
+  XCUIDevice *device = XCUIDevice.sharedDevice;
+  BOOL canFold = NO;
+#if TARGET_OS_SIMULATOR
+  canFold = device.fb_canAttemptSimulatedHingeAngleInjection;
+#endif
+  NSNumber *originalAngle = canFold ? [device fb_getSimulatedHingeAngle:nil] : nil;
+  NSNumber *originalDisplay = FBConfiguration.sharedInstance.currentDisplayId;
+  if (canFold) {
+    XCTAssertNotNil(originalAngle);
+  }
+  BOOL (^setAngleAndWait)(NSNumber *) = ^BOOL(NSNumber *angle) {
+    if (![device fb_setSimulatedHingeAngle:angle.doubleValue error:nil]) {
+      return NO;
+    }
+    return [[[FBRunLoopSpinner new] timeout:5] spinUntilTrue:^BOOL{
+      NSNumber *reading = [device fb_getSimulatedHingeAngle:nil];
+      return nil != reading && fabs(reading.doubleValue - angle.doubleValue) < 1;
+    }];
+  };
+  FBSession *session = mode != 0 ? [FBSession initWithApplication:self.testedApplication] : nil;
+  @try {
+    for (NSNumber *angle in (canFold ? @[@0, @90, @180] : @[@0])) {
+      if (canFold) {
+        XCTAssertTrue(setAngleAndWait(angle), @"Hinge did not reach %@ degrees", angle);
+        for (NSDictionary *screen in [FBScreen screensWithError:nil]) {
+          if ([screen[@"isMain"] boolValue] == (angle.intValue == 0)) {
+            FBConfiguration.sharedInstance.currentDisplayId = screen[@"displayId"];
+          }
+        }
+      }
+      for (NSNumber *duration in @[@0, @2]) {
+        [self launchApplication];
+        NSError *error = nil;
+        if (mode != 0) {
+          XCTAssertTrue([device fb_goToHomescreenWithError:&error]);
+          XCTAssertTrue([[[FBRunLoopSpinner new] timeout:5] spinUntilTrue:^BOOL{
+            XCUIApplicationState state = self.testedApplication.state;
+            return state == XCUIApplicationStateRunningBackground
+              || state == XCUIApplicationStateRunningBackgroundSuspended;
+          }]);
+          [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:duration.doubleValue]];
+          XCUIApplicationState state = self.testedApplication.state;
+          XCTAssertTrue(state == XCUIApplicationStateRunningBackground
+                        || state == XCUIApplicationStateRunningBackgroundSuspended,
+                        @"Expected a background app before activation (angle %@, duration %@), got %lu",
+                        angle, duration, (unsigned long)state);
+          if (mode == 1) {
+            [session activateApplicationWithBundleId:self.testedApplication.bundleID];
+          } else if (mode == 2) {
+            [session launchApplicationWithBundleId:self.testedApplication.bundleID
+                          shouldWaitForQuiescence:nil arguments:nil environment:nil];
+          } else {
+            XCTAssertNil([FBSessionCommands activateBackgroundApplication:self.testedApplication
+                                                                bundleID:self.testedApplication.bundleID
+                                                              initialUrl:nil]);
+          }
+        } else {
+          XCTAssertTrue([self.testedApplication fb_deactivateWithDuration:duration.doubleValue error:&error]);
+        }
+        XCTAssertNil(error);
+        // Existence/foreground checks alone miss lost input. Do not add a
+        // delay or retry: this first tap must actually open the alerts page.
+        [self.testedApplication.buttons[@"Alerts"] tap];
+        XCTAssertTrue([self.testedApplication.buttons[FBShowAlertButtonName] waitForExistenceWithTimeout:2]);
+      }
+    }
+  } @finally {
+    [session kill];
+    BOOL restored = nil == originalAngle || setAngleAndWait(originalAngle);
+    FBConfiguration.sharedInstance.currentDisplayId = originalDisplay;
+    XCTAssertTrue(restored, @"Hinge did not return to %@ degrees", originalAngle);
+  }
+}
+
 - (void)testActiveApplication
 {
   XCUIApplication *systemApp = XCUIApplication.fb_systemApplication;

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests/XCUIDeviceHelperTests.m

@@ -7,6 +7,7 @@
  */
 
 #import <XCTest/XCTest.h>
+#import <math.h>
 
 #import "FBIntegrationTestCase.h"
 #import "FBImageUtils.h"
@@ -15,6 +16,7 @@
 #import "XCUIApplication.h"
 #import "XCUIApplication+FBHelpers.h"
 #import "XCUIDevice+FBHelpers.h"
+#import "XCUIDevice+FBHinge.h"
 #import "XCUIDevice+FBRotation.h"
 #import "XCUIScreen.h"
 
@@ -104,6 +106,53 @@
   FBAssertWaitTillBecomesTrue([XCUIApplication fb_activeApplication].icons[@"Safari"].exists);
 }
 
+- (void)testHomeButtonBackgroundsApplication
+{
+  XCUIDevice *device = XCUIDevice.sharedDevice;
+  BOOL hasHinge = NO;
+#if TARGET_OS_SIMULATOR
+  hasHinge = device.fb_canAttemptSimulatedHingeAngleInjection;
+#endif
+  NSNumber *originalAngle = hasHinge ? [device fb_getSimulatedHingeAngle:nil] : nil;
+  if (hasHinge && nil == originalAngle) {
+    XCTFail(@"Cannot read the original hinge angle");
+    return;
+  }
+  BOOL (^setAngleAndWait)(NSNumber *) = ^BOOL(NSNumber *angle) {
+    return [device fb_setSimulatedHingeAngle:angle.doubleValue error:nil]
+      && [[[FBRunLoopSpinner new] timeout:5] spinUntilTrue:^BOOL{
+        NSNumber *reading = [device fb_getSimulatedHingeAngle:nil];
+        return nil != reading && fabs(reading.doubleValue - angle.doubleValue) < 1;
+      }];
+  };
+  @try {
+    for (NSNumber *angle in (hasHinge ? @[@0, @180] : @[@0])) {
+      if (hasHinge) {
+        if (!setAngleAndWait(angle)) {
+          XCTFail(@"Hinge angle did not reach %@", angle);
+          return;
+        }
+      }
+      for (NSUInteger attempt = 0; attempt < 2; attempt++) {
+        [self.testedApplication activate];
+        XCTAssertEqual(self.testedApplication.state, XCUIApplicationStateRunningForeground);
+        NSError *error = nil;
+        XCTAssertTrue([device fb_pressButton:@"home" forDuration:nil error:&error]);
+        XCTAssertNil(error);
+        XCTAssertTrue([[[FBRunLoopSpinner new] timeout:5] spinUntilTrue:^BOOL{
+          return self.testedApplication.state == XCUIApplicationStateRunningBackground
+            || self.testedApplication.state == XCUIApplicationStateRunningBackgroundSuspended;
+        }]);
+        XCTAssertTrue([XCUIApplication.fb_activeApplication.bundleID isEqualToString:@"com.apple.springboard"]);
+      }
+    }
+  } @finally {
+    if (nil != originalAngle) {
+      XCTAssertTrue(setAngleAndWait(originalAngle));
+    }
+  }
+}
+
 - (void)testLockUnlockScreen
 {
   XCTAssertFalse([[XCUIDevice sharedDevice] fb_isScreenLocked]);
@@ -116,6 +165,54 @@
   XCTAssertNil(error);
 }
 
+- (void)testRepeatedLockUnlockAcrossHingePoses
+{
+  XCTSkipIf(self.class.isRunningInCI, @"Repeated lock/unlock is unreliable on slow CI hosts");
+  XCUIDevice *device = XCUIDevice.sharedDevice;
+  BOOL hasHinge = NO;
+#if TARGET_OS_SIMULATOR
+  hasHinge = device.fb_canAttemptSimulatedHingeAngleInjection;
+#endif
+  NSNumber *originalAngle = hasHinge ? [device fb_getSimulatedHingeAngle:nil] : nil;
+  if (hasHinge) {
+    XCTAssertNotNil(originalAngle);
+  }
+  BOOL (^setAngleAndWait)(NSNumber *) = ^BOOL(NSNumber *angle) {
+    return [device fb_setSimulatedHingeAngle:angle.doubleValue error:nil]
+      && [[[FBRunLoopSpinner new] timeout:5] spinUntilTrue:^BOOL{
+        NSNumber *reading = [device fb_getSimulatedHingeAngle:nil];
+        return nil != reading && fabs(reading.doubleValue - angle.doubleValue) < 1;
+      }];
+  };
+  @try {
+    for (NSNumber *angle in (hasHinge ? @[@0, @90, @180] : @[@0])) {
+      if (hasHinge) {
+        XCTAssertTrue(setAngleAndWait(angle));
+      }
+      for (NSUInteger attempt = 0; attempt < 3; attempt++) {
+        XCTAssertFalse(device.fb_isScreenLocked);
+        NSError *error = nil;
+        XCTAssertTrue([device fb_lockScreen:&error]);
+        XCTAssertNil(error);
+        XCTAssertTrue(device.fb_isScreenLocked);
+        // Repeating lock must not toggle the screen back to unlocked.
+        XCTAssertTrue([device fb_lockScreen:&error]);
+        XCTAssertTrue(device.fb_isScreenLocked);
+        XCTAssertTrue([device fb_unlockScreen:&error]);
+        XCTAssertNil(error);
+        XCTAssertFalse(device.fb_isScreenLocked);
+        XCTAssertTrue([device fb_unlockScreen:&error]);
+        XCTAssertFalse(device.fb_isScreenLocked);
+      }
+    }
+  } @finally {
+    [device fb_unlockScreen:nil];
+    if (nil != originalAngle) {
+      XCTAssertTrue(setAngleAndWait(originalAngle));
+    }
+  }
+}
+
 - (void)testUrlSchemeActivation
 {
   if (SYSTEM_VERSION_LESS_THAN(@"16.4")) {

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests/XCUIDeviceRotationTests.m

@@ -10,8 +10,13 @@
 #import <UIKit/UIKit.h>
 #import "FBIntegrationTestCase.h"
 #import "XCUIDevice+FBRotation.h"
+#import "XCUIDevice+FBHinge.h"
+#import "FBConfiguration.h"
+#import "FBScreen.h"
+#import "FBSession.h"
 
 @interface XCUIDeviceRotationTests : FBIntegrationTestCase
+@property (nonatomic, strong) FBSession *session;
 
 @end
 
@@ -21,11 +26,13 @@
 {
   [super setUp];
   [self launchApplication];
+  self.session = [FBSession initWithApplication:self.testedApplication];
 }
 
 - (void)tearDown
 {
   [self resetOrientation];
+  [self.session kill];
   [super tearDown];
 }
 
@@ -102,4 +109,50 @@
   XCTAssertEqual(currentRotation, [XCUIDevice sharedDevice].orientation, @"Device doesnt support tilt, should be at previous orientation");
 }
 
+- (void)testRotationOnSelectedDuoDisplay
+{
+#if TARGET_OS_SIMULATOR
+  XCUIDevice *device = XCUIDevice.sharedDevice;
+  XCTSkipIf(!device.fb_supportsHingeAngleReading || !device.fb_canAttemptSimulatedHingeAngleInjection,
+            @"Requires hinge angle reading and injection support");
+  NSNumber *originalDisplay = FBConfiguration.sharedInstance.currentDisplayId;
+  NSNumber *originalAngle = [device fb_getSimulatedHingeAngle:nil];
+  XCTAssertNotNil(originalAngle);
+  @try {
+    for (NSNumber *angle in @[@0, @90, @180]) {
+      XCTAssertTrue([device fb_setSimulatedHingeAngle:angle.doubleValue error:nil]);
+      [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:3]];
+      for (NSDictionary *screen in [FBScreen screensWithError:nil]) {
+        if ([screen[@"isMain"] boolValue] == (angle.intValue == 0)) {
+          FBConfiguration.sharedInstance.currentDisplayId = screen[@"displayId"];
+        }
+      }
+      [self.testedApplication activate];
+      NSArray *orientations = @[@(UIDeviceOrientationLandscapeLeft),
+                                @(UIDeviceOrientationLandscapeRight),
+                                @(UIDeviceOrientationPortrait)];
+      NSArray *labels = @[@"LandscapeRight", @"LandscapeLeft", @"Portrait"];
+      for (NSUInteger i = 0; i < orientations.count; i++) {
+        UIDeviceOrientation orientation = [orientations[i] integerValue];
+        XCTAssertTrue([device fb_setDeviceInterfaceOrientation:orientation]);
+        XCTAssertTrue([self.testedApplication.staticTexts[labels[i]] waitForExistenceWithTimeout:5]);
+        XCTAssertEqual(device.orientation, orientation);
+      }
+      BOOL rotated = [device fb_setDeviceRotation:@{@"x": @0, @"y": @0, @"z": @270}];
+      XCTAssertTrue(rotated);
+      XCTAssertTrue(self.testedApplication.staticTexts[@"LandscapeRight"].exists);
+    }
+  } @finally {
+    [device fb_setSimulatedHingeAngle:0 error:nil];
+    [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:3]];
+    FBConfiguration.sharedInstance.currentDisplayId = nil;
+    [device fb_setDeviceInterfaceOrientation:UIDeviceOrientationPortrait];
+    if (nil != originalAngle) {
+      [device fb_setSimulatedHingeAngle:originalAngle.doubleValue error:nil];
+    }
+    FBConfiguration.sharedInstance.currentDisplayId = originalDisplay;
+  }
+#endif
+}
+
 @end

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests/XCUIElementFBFindTests.m

@@ -9,6 +9,7 @@
 #import <XCTest/XCTest.h>
 
 #import "FBIntegrationTestCase.h"
+#import "FBConfiguration.h"
 #import "FBElementUtils.h"
 #import "FBExceptions.h"
 #import "FBTestMacros.h"
@@ -558,3 +559,115 @@
 }
 
 @end
+
+
+@interface XCUIElementFBFindTests_IdentifierSemantics : FBIntegrationTestCase
+@end
+
+@implementation XCUIElementFBFindTests_IdentifierSemantics
+
+- (void)setUp
+{
+  [super setUp];
+  self.testedApplication.launchArguments = @[@"--identifier-lookup-test"];
+  [self.testedApplication launch];
+  XCTAssertTrue([self.testedApplication.otherElements[@"IdentifierLookupFixture"] waitForExistenceWithTimeout:5]);
+}
+
+- (void)tearDown
+{
+  [self.testedApplication terminate];
+  [super tearDown];
+}
+
+- (void)testIdentifierTakesPrecedenceOverLabel
+{
+  NSArray<XCUIElement *> *matches = [self.testedApplication fb_descendantsMatchingIdentifier:@"something"
+                                                              shouldReturnAfterFirstMatch:NO];
+  XCTAssertEqual(matches.count, 4);
+  XCTAssertEqualObjects([matches valueForKey:@"label"], (@[@"other label", @"something", @"something", @"something"]));
+  XCTAssertEqual([self.testedApplication fb_descendantsMatchingIdentifier:@"different" shouldReturnAfterFirstMatch:NO].count, 1);
+  // A matching label must not override a different, nonempty identifier.
+  XCTAssertEqual([self.testedApplication fb_descendantsMatchingIdentifier:@"other label" shouldReturnAfterFirstMatch:NO].count, 0);
+}
+
+- (void)testEmptyIdentifierDoesNotMatchEmptyAccessibilityId
+{
+  // The fixture has an empty identifier with a nonempty label at index 2,
+  // and an empty identifier with an empty label at index 5.
+  XCUIElement *labelFallback = [self.testedApplication.staticTexts elementBoundByIndex:2];
+  XCUIElement *unnamed = [self.testedApplication.staticTexts elementBoundByIndex:5];
+  XCTAssertEqualObjects(labelFallback.identifier, @"");
+  XCTAssertEqualObjects(labelFallback.label, @"something");
+  XCTAssertEqualObjects(unnamed.identifier, @"");
+  XCTAssertEqualObjects(unnamed.label, @"");
+
+  // Regression guard for "identifier != nil AND identifier != ''": the old
+  // wdName lookup used the nonempty label, or nil when both fields were empty.
+  // Thus an empty query matched neither element. Checking only identifier != nil
+  // would instead let identifier == @"" match both, changing existing behavior.
+  BOOL previousFirstMatch = FBConfiguration.sharedInstance.useFirstMatch;
+  @try {
+    for (NSNumber *useFirstMatch in @[@NO, @YES]) {
+      FBConfiguration.sharedInstance.useFirstMatch = useFirstMatch.boolValue;
+      for (NSNumber *firstMatch in @[@NO, @YES]) {
+        XCTAssertEqual([self.testedApplication fb_descendantsMatchingIdentifier:@""
+                                                  shouldReturnAfterFirstMatch:firstMatch.boolValue].count, 0,
+                       @"An empty accessibility ID must not match empty identifiers, even when they are non-nil");
+      }
+    }
+  } @finally {
+    FBConfiguration.sharedInstance.useFirstMatch = previousFirstMatch;
+  }
+}
+
+- (void)testMissingQuotedAndUnicodeIdentifiers
+{
+  for (NSNumber *firstMatch in @[@NO, @YES]) {
+    XCTAssertEqual([self.testedApplication fb_descendantsMatchingIdentifier:@"missing-target" shouldReturnAfterFirstMatch:firstMatch.boolValue].count, 0);
+    XCTAssertEqual([self.testedApplication fb_descendantsMatchingIdentifier:@"quote'\"é" shouldReturnAfterFirstMatch:firstMatch.boolValue].count, 1);
+    XCTAssertEqual([self.testedApplication fb_descendantsMatchingIdentifier:@"日本語" shouldReturnAfterFirstMatch:firstMatch.boolValue].count, 1);
+  }
+}
+
+- (void)testFirstMatchAndParentScopeWithBothBindings
+{
+  BOOL previousBinding = FBConfiguration.sharedInstance.boundElementsByIndex;
+  @try {
+    for (NSNumber *indexed in @[@NO, @YES]) {
+      FBConfiguration.sharedInstance.boundElementsByIndex = indexed.boolValue;
+      // Use the element returned by WDA lookup, as the element-scoped endpoint does.
+      XCUIElement *parent = [self.testedApplication fb_descendantsMatchingIdentifier:@"IdentifierLookupFixture"
+                                                          shouldReturnAfterFirstMatch:YES].firstObject;
+      XCTAssertNotNil(parent);
+      // The HTTP endpoint resolves the parent when registering its element ID.
+      XCTAssertNotNil(parent.fb_uid);
+      NSArray<XCUIElement *> *matches = [parent fb_descendantsMatchingIdentifier:@"something" shouldReturnAfterFirstMatch:NO];
+      NSArray<XCUIElement *> *first = [parent fb_descendantsMatchingIdentifier:@"something" shouldReturnAfterFirstMatch:YES];
+      XCTAssertEqual(matches.count, 4);
+      XCTAssertEqual(first.count, 1);
+      XCTAssertEqualObjects(first.firstObject.fb_uid, matches.firstObject.fb_uid);
+      NSArray<XCUIElement *> *selfMatches = [parent fb_descendantsMatchingIdentifier:@"IdentifierLookupFixture" shouldReturnAfterFirstMatch:NO];
+      XCTAssertEqual(selfMatches.count, 1);
+      XCTAssertEqualObjects(selfMatches.firstObject.fb_uid, parent.fb_uid);
+    }
+  } @finally {
+    FBConfiguration.sharedInstance.boundElementsByIndex = previousBinding;
+  }
+}
+
+- (void)testIdentifierChangesAreObserved
+{
+  NSArray<XCUIElement *> *before = [self.testedApplication fb_descendantsMatchingIdentifier:@"something" shouldReturnAfterFirstMatch:NO];
+  XCTAssertEqual(before.count, 4);
+  NSArray<NSString *> *beforeIds = [before valueForKey:@"fb_uid"];
+  [self.testedApplication.buttons[@"mutateIdentifier"] tap];
+  NSArray<XCUIElement *> *after = [self.testedApplication fb_descendantsMatchingIdentifier:@"something" shouldReturnAfterFirstMatch:NO];
+  NSArray<XCUIElement *> *changed = [self.testedApplication fb_descendantsMatchingIdentifier:@"changed" shouldReturnAfterFirstMatch:NO];
+  XCTAssertEqual(after.count, 3);
+  XCTAssertEqual(changed.count, 1);
+  XCTAssertEqualObjects([after valueForKey:@"fb_uid"], [beforeIds subarrayWithRange:NSMakeRange(1, 3)]);
+  XCTAssertEqualObjects(changed.firstObject.fb_uid, beforeIds.firstObject);
+}
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests_tvOS/FBTVFocusIntegrationTests.m

@@ -7,6 +7,8 @@
  */
 
 #import <XCTest/XCTest.h>
+#import "XCUIApplication+FBHelpers.h"
+#import "XCUIDevice+FBHelpers.h"
 
 #if TARGET_OS_TV
 
@@ -79,6 +81,25 @@
   XCTAssertFalse(disabled.hasFocus);
 }
 
+- (void)testHomeAndInputAfterDeactivate
+{
+  NSError *error = nil;
+  XCTAssertTrue([XCUIDevice.sharedDevice fb_goToHomescreenWithError:&error], @"%@", error);
+  XCTAssertNotEqual(self.app.state, XCUIApplicationStateRunningForeground);
+  XCTAssertEqual(XCUIApplication.fb_systemApplication.state, XCUIApplicationStateRunningForeground);
+  [self.app activate];
+  for (NSNumber *duration in @[@0, @2]) {
+    [self.app launch];
+    XCTAssertTrue([self.app fb_deactivateWithDuration:duration.doubleValue error:&error], @"%@", error);
+    XCTAssertEqual(self.app.state, XCUIApplicationStateRunningForeground);
+    XCTAssertTrue([self.app.buttons[@"cell_1_2"] fb_selectWithError:&error], @"%@", error);
+    XCTNSPredicateExpectation *updated = [[XCTNSPredicateExpectation alloc]
+        initWithPredicate:[NSPredicate predicateWithFormat:@"label == %@", @"cell_1_2"]
+        object:self.app.staticTexts[@"lastSelectedLabel"]];
+    [self waitForExpectations:@[updated] timeout:5];
+  }
+}
+
 @end
 
 #endif

package/drivers/ios/WebDriverAgent/WebDriverAgentTests/IntegrationTests_watchOS/WDAAppLifecycleIntegrationTests.swift

@@ -34,4 +34,16 @@ final class WDAAppLifecycleIntegrationTests: WDAWatchInProcessTestCase {
     app.activate()
     XCTAssertEqual(app.state, .runningForeground)
   }
+  func testHomeAndDeactivate() throws {
+    try XCUIDevice.shared.fb_goToHomescreen()
+    XCTAssertNotEqual(app.state, .runningForeground)
+    try XCUIDevice.shared.fb_goToHomescreen()
+    XCTAssertNotEqual(app.state, .runningForeground)
+    for duration in [0.0, 2.0] {
+      app.activate()
+      try app.fb_deactivate(withDuration: duration)
+      XCTAssertEqual(app.state, .runningForeground)
+    }
+  }
+
 }