appium-webdriveragent 16.13.6 → 16.14.1

package/WebDriverAgentLib/Utilities/FBMjpegServer.m

@@ -16,6 +16,7 @@
 #import "FBConfiguration.h"
 #import "FBLogger.h"
 #import "FBScreenshot.h"
+#import "FBScreen.h"
 #import "FBImageProcessor.h"
 #import "FBImageUtils.h"
 #import "XCUIScreen.h"
@@ -42,7 +43,6 @@ static NSUInteger FBNormalizedMjpegFramerate(NSUInteger framerate)
 @property (nonatomic, readonly) dispatch_queue_t backgroundQueue;
 @property (nonatomic, readonly) NSMutableArray<nw_connection_t> *listeningClients;
 @property (nonatomic, readonly) FBImageProcessor *imageProcessor;
-@property (nonatomic, readonly) long long mainScreenID;
 @property (nonatomic, assign) NSUInteger consecutiveScreenshotFailures;
 @property (atomic, assign) BOOL isStreaming;
 @property (nonatomic, assign) NSUInteger sentFramesCount;
@@ -67,7 +67,6 @@ static NSUInteger FBNormalizedMjpegFramerate(NSUInteger framerate)
     _pendingFrameCounts = [NSMapTable mapTableWithKeyOptions:(NSPointerFunctionsOptions)(NSMapTableObjectPointerPersonality | NSMapTableStrongMemory)
                                                 valueOptions:(NSPointerFunctionsOptions)NSMapTableStrongMemory];
     _imageProcessor = [[FBImageProcessor alloc] init];
-    _mainScreenID = [XCUIScreen.mainScreen displayID];
     dispatch_queue_attr_t queueAttributes = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, QOS_CLASS_UTILITY, 0);
     _backgroundQueue = dispatch_queue_create(QUEUE_NAME, queueAttributes);
     __weak typeof(self) weakSelf = self;
@@ -116,7 +115,8 @@ static NSUInteger FBNormalizedMjpegFramerate(NSUInteger framerate)
   NSError *error;
   CGFloat compressionQuality = MAX(FBMinCompressionQuality,
                                    MIN(FBMaxCompressionQuality, (double)FBConfiguration.sharedInstance.mjpegServerScreenshotQuality / 100.0));
-  NSData *screenshotData = [FBScreenshot takeInOriginalResolutionWithScreenID:self.mainScreenID
+  XCUIScreen *screen = [FBScreen currentScreenWithError:&error];
+  NSData *screenshotData = nil == screen ? nil : [FBScreenshot takeInOriginalResolutionWithScreenID:screen.displayID
                                                            compressionQuality:compressionQuality
                                                                           uti:UTTypeJPEG
                                                                       timeout:FRAME_TIMEOUT

package/WebDriverAgentLib/Utilities/FBScreen.m

@@ -13,12 +13,26 @@
 #import "FBXCodeCompatibility.h"
 #import "XCUIDevice.h"
 #import "XCUIScreen.h"
+#import <objc/message.h>
+
+static NSArray<XCUIScreen *> *FBScreensForDevice(id device, NSError **error)
+{
+  SEL selector = NSSelectorFromString(@"screensOrError:");
+  if ([device respondsToSelector:selector]) {
+    return ((NSArray<XCUIScreen *> *(*)(id, SEL, NSError **))objc_msgSend)(device, selector, error);
+  }
+  // Older XCTest versions expose screens on XCUIScreen instead of XCUIDevice.
+  if ([XCUIScreen respondsToSelector:NSSelectorFromString(@"screens")]) {
+    return XCUIScreen.screens;
+  }
+  return @[XCUIScreen.mainScreen];
+}
 
 @implementation FBScreen
 
 + (nullable NSArray<NSDictionary<NSString *, id> *> *)screensWithError:(NSError **)error
 {
-  NSArray<XCUIScreen *> *screens = [XCUIDevice.sharedDevice screensOrError:error];
+  NSArray<XCUIScreen *> *screens = FBScreensForDevice(XCUIDevice.sharedDevice, error);
   if (nil == screens) {
     return nil;
   }
@@ -42,27 +56,56 @@
   return result.copy;
 }
 
-+ (nullable XCUIScreen *)screenWithDisplayID:(long long)displayID error:(NSError **)error
+// Kept separate from sharedDevice so legacy lookup behavior can be tested.
++ (nullable XCUIScreen *)screenWithDisplayID:(long long)displayID
+                                    device:(XCUIDevice *)device
+                                     error:(NSError **)error
 {
-  NSArray<XCUIScreen *> *screens = [XCUIDevice.sharedDevice screensOrError:error];
+  SEL lookupSelector = NSSelectorFromString(@"screenWithDisplayID:orError:");
+  BOOL hasNativeLookup = [device respondsToSelector:lookupSelector];
+  BOOL needsEnumeratedLookup = !hasNativeLookup;
+  NSError *lookupError = nil;
+  if (hasNativeLookup) {
+    XCUIScreen *screen = ((XCUIScreen *(*)(id, SEL, long long, NSError **))objc_msgSend)(
+      device, lookupSelector, displayID, &lookupError);
+    if ([screen respondsToSelector:NSSelectorFromString(@"bounds")] && !CGRectIsEmpty(screen.bounds)) {
+      return screen;
+    }
+    // XCTest may return a zero-sized placeholder for an inactive wireless
+    // display which screensOrError: omits. Confirm its availability by listing.
+    needsEnumeratedLookup = nil != screen;
+  }
+  // Enumerate only for legacy/placeholder lookups or to enrich a lookup error.
+  NSError *enumerationError = nil;
+  NSArray<XCUIScreen *> *screens = FBScreensForDevice(device, &enumerationError);
   if (nil == screens) {
+    if (NULL != error) {
+      *error = lookupError ?: enumerationError;
+    }
     return nil;
   }
+  NSMutableArray<NSNumber *> *availableIDs = [NSMutableArray arrayWithCapacity:screens.count];
   for (XCUIScreen *screen in screens) {
-    if (screen.displayID == displayID) {
+    if (needsEnumeratedLookup && screen.displayID == displayID) {
       return screen;
     }
-  }
-  NSMutableArray<NSNumber *> *availableIDs = [NSMutableArray arrayWithCapacity:screens.count];
-  for (XCUIScreen *screen in screens) {
     [availableIDs addObject:@(screen.displayID)];
   }
-  [[FBErrorBuilder.builder withDescriptionFormat:@"No display with id %lld is available. Available display ids: [%@]",
-    displayID, [availableIDs componentsJoinedByString:@", "]]
-   buildError:error];
+  FBErrorBuilder *builder = [FBErrorBuilder.builder withDescriptionFormat:
+    @"No display with id %lld is available. Available display ids: [%@]",
+    displayID, [availableIDs componentsJoinedByString:@", "]];
+  if (nil != lookupError) {
+    [builder withInnerError:lookupError];
+  }
+  [builder buildError:error];
   return nil;
 }
 
++ (nullable XCUIScreen *)screenWithDisplayID:(long long)displayID error:(NSError **)error
+{
+  return [self screenWithDisplayID:displayID device:XCUIDevice.sharedDevice error:error];
+}
+
 + (nullable XCUIScreen *)currentScreenWithError:(NSError **)error
 {
   NSNumber *displayID = FBConfiguration.sharedInstance.currentDisplayId;

package/WebDriverAgentLib/WebDriverAgentLib.h

@@ -47,6 +47,7 @@ FOUNDATION_EXPORT const unsigned char WebDriverAgentLib_VersionString[];
 #import <WebDriverAgentLib/XCTIssue+FBPatcher.h>
 #import <WebDriverAgentLib/XCUIApplication+FBHelpers.h>
 #import <WebDriverAgentLib/XCUIDevice+FBHelpers.h>
+#import <WebDriverAgentLib/XCUIDevice+FBHinge.h>
 #import <WebDriverAgentLib/XCUIDevice+FBRotation.h>
 #import <WebDriverAgentLib/XCUIDevice+FBVoiceOver.h>
 #import <WebDriverAgentLib/XCUIElement.h>

package/WebDriverAgentTests/IntegrationApp/Classes/ViewController.m

@@ -9,6 +9,10 @@
 #import "ViewController.h"
 #import "FBCoordinateProbeViewController.h"
 
+#if !TARGET_OS_TV
+#import <WebKit/WebKit.h>
+#endif
+
 @interface ViewController ()
 @property (weak, nonatomic) IBOutlet UILabel *orentationLabel;
 @property (weak, nonatomic) IBOutlet UIButton *button;
@@ -19,6 +23,17 @@
 - (void)viewDidLoad
 {
   [super viewDidLoad];
+
+#if !TARGET_OS_TV
+  if ([NSProcessInfo.processInfo.arguments containsObject:@"--webview-fixture"]) {
+    WKWebView *webView = [[WKWebView alloc] initWithFrame:self.view.bounds];
+    webView.autoresizingMask = UIViewAutoresizingFlexibleWidth
+      | UIViewAutoresizingFlexibleHeight;
+    [self.view addSubview:webView];
+    [webView loadHTMLString:@"<!doctype html><html><body>"
+      "<p>WebContent snapshot fixture</p></body></html>" baseURL:nil];
+  }
+#endif
   
   UIAccessibilityCustomAction *action1 =
   [[UIAccessibilityCustomAction alloc] initWithName:@"Custom Action 1"

package/WebDriverAgentTests/IntegrationTests/FBConfigurationTests.m

@@ -12,6 +12,9 @@
 #import "FBConfiguration.h"
 #import "FBRuntimeUtils.h"
 #import "FBTestMacros.h"
+#import "FBXCAccessibilityElement.h"
+#import "FBXCAXClientProxy.h"
+#import "XCUIApplication.h"
 #import "XCUIElement.h"
 #import "XCUIElement+FBIsVisible.h"
 
@@ -68,4 +71,53 @@
   }
 }
 
+- (void)testAccessibilityDeadlineAllowsResponsiveNativeAppSnapshots
+{
+  [self launchApplication];
+  NSTimeInterval previousDeadline = FBConfiguration.sharedInstance.accessibilityDeadline;
+  @try {
+    FBConfiguration.sharedInstance.accessibilityDeadline = 3;
+    NSError *error = nil;
+    XCTAssertNotNil([self.testedApplication snapshotWithError:&error]);
+    XCTAssertNil(error);
+  } @finally {
+    FBConfiguration.sharedInstance.accessibilityDeadline = previousDeadline;
+    [self.testedApplication terminate];
+  }
+}
+
+- (void)testAccessibilityDeadlineAllowsWebContentSnapshots
+{
+  NSTimeInterval previousDeadline = FBConfiguration.sharedInstance.accessibilityDeadline;
+  @try {
+    // Resolve the remote AX element before enabling the guard so the test
+    // exercises a WebContent-owned snapshot, not just the host app's tree.
+    FBConfiguration.sharedInstance.accessibilityDeadline = 0;
+    self.testedApplication.launchArguments = @[@"--webview-fixture"];
+    [self.testedApplication launch];
+    XCUIElement *text = self.testedApplication.webViews.staticTexts[
+      @"WebContent snapshot fixture"];
+    XCTAssertTrue([text waitForExistenceWithTimeout:15]);
+    NSError *error = nil;
+    id<FBXCElementSnapshot> initial = [text snapshotWithError:&error];
+    XCTAssertNotNil(initial);
+    XCTAssertNil(error);
+    id<FBXCAccessibilityElement> element = initial.accessibilityElement;
+    XCTAssertNotEqual(element.processIdentifier, self.testedApplication.processID);
+
+    FBConfiguration.sharedInstance.accessibilityDeadline = 3;
+    for (NSUInteger i = 0; i < 3; i++) {
+      error = nil;
+      id<FBXCElementSnapshot> snapshot = [FBXCAXClientProxy.sharedClient
+        snapshotForElement:element attributes:@[] inDepth:YES error:&error];
+      XCTAssertNotNil(snapshot);
+      XCTAssertNil(error);
+    }
+    XCTAssertTrue(text.exists);
+  } @finally {
+    FBConfiguration.sharedInstance.accessibilityDeadline = previousDeadline;
+    [self.testedApplication terminate];
+  }
+}
+
 @end

package/WebDriverAgentTests/IntegrationTests/FBScreenTests.m

@@ -11,8 +11,69 @@
 #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;
+@end
+
+@interface FBEmptyScreenDouble : NSObject
+@property (nonatomic) CGRect bounds;
+@end
+@implementation FBEmptyScreenDouble
+@end
+
+@interface FBScreenDeviceDouble : NSObject
+@property (nonatomic) BOOL nativeLookupAvailable;
+@property (nonatomic) BOOL enumerationUnavailable;
+@property (nonatomic) NSUInteger enumerationCount;
+@property (nonatomic, strong) XCUIScreen *nativeScreen;
+@property (nonatomic, strong) NSArray<XCUIScreen *> *screens;
+@property (nonatomic, strong) NSError *lookupError;
+@property (nonatomic, strong) NSError *enumerationError;
+@end
+
+@implementation FBScreenDeviceDouble
+- (BOOL)respondsToSelector:(SEL)selector
+{
+  if (selector == NSSelectorFromString(@"screensOrError:") && self.enumerationUnavailable) {
+    return NO;
+  }
+  return selector == @selector(screenWithDisplayID:orError:)
+    ? self.nativeLookupAvailable : [super respondsToSelector:selector];
+}
+- (XCUIScreen *)screenWithDisplayID:(long long)displayID orError:(NSError **)error
+{
+  if (NULL != error) {
+    *error = self.lookupError;
+  }
+  return self.nativeScreen;
+}
+- (NSArray<XCUIScreen *> *)screensOrError:(NSError **)error
+{
+  self.enumerationCount++;
+  if (NULL != error) {
+    *error = self.enumerationError;
+  }
+  return self.screens;
+}
+@end
 
 @interface FBScreenTests : FBIntegrationTestCase
 @end
@@ -62,9 +123,13 @@
 - (void)testScreenWithDisplayID
 {
   NSError *error = nil;
-  XCUIScreen *screen = [FBScreen screenWithDisplayID:[FBScreen displayID] error:&error];
-  XCTAssertNil(error);
-  XCTAssertEqual(screen.displayID, [FBScreen displayID]);
+  for (NSDictionary<NSString *, id> *entry in [FBScreen screensWithError:&error]) {
+    long long displayID = [entry[@"displayId"] longLongValue];
+    XCUIScreen *screen = [FBScreen screenWithDisplayID:displayID error:&error];
+    XCTAssertNotNil(screen);
+    XCTAssertNil(error);
+    XCTAssertEqual(screen.displayID, displayID);
+  }
 
   XCTAssertNil([FBScreen screenWithDisplayID:[self unknownDisplayID] error:&error]);
   XCTAssertNotNil(error);
@@ -77,6 +142,84 @@
   XCTAssertTrue([error.localizedDescription containsString:availableDisplays]);
 }
 
+- (void)testNativeScreenLookupDoesNotEnumerateOnSuccess
+{
+  FBScreenDeviceDouble *device = [FBScreenDeviceDouble new];
+  device.nativeLookupAvailable = YES;
+  device.nativeScreen = XCUIScreen.mainScreen;
+  NSError *error = nil;
+  XCTAssertEqualObjects([FBScreen screenWithDisplayID:device.nativeScreen.displayID device:device error:&error],
+                        device.nativeScreen);
+  XCTAssertNil(error);
+  XCTAssertEqual(device.enumerationCount, 0UL);
+}
+
+- (void)testNativeScreenPlaceholderMustBeAvailable
+{
+  FBScreenDeviceDouble *device = [FBScreenDeviceDouble new];
+  device.nativeLookupAvailable = YES;
+  device.nativeScreen = (id)[FBEmptyScreenDouble new];
+  device.screens = @[XCUIScreen.mainScreen];
+  NSError *error = nil;
+  XCTAssertNil([FBScreen screenWithDisplayID:-1 device:device error:&error]);
+  XCTAssertNotNil(error);
+  XCTAssertEqual(device.enumerationCount, 1UL);
+}
+
+- (void)testNativeScreenLookupFailureIncludesAvailableIDs
+{
+  FBScreenDeviceDouble *device = [FBScreenDeviceDouble new];
+  device.nativeLookupAvailable = YES;
+  device.screens = @[XCUIScreen.mainScreen];
+  device.lookupError = [NSError errorWithDomain:@"NativeLookup" code:1 userInfo:nil];
+  NSError *error = nil;
+  XCTAssertNil([FBScreen screenWithDisplayID:-1 device:device error:&error]);
+  XCTAssertEqual(device.enumerationCount, 1UL);
+  XCTAssertTrue([error.localizedDescription containsString:@"Available display ids"]);
+  XCTAssertEqualObjects(error.userInfo[NSUnderlyingErrorKey], device.lookupError);
+}
+
+- (void)testNativeScreenLookupErrorSurvivesEnumerationFailure
+{
+  FBScreenDeviceDouble *device = [FBScreenDeviceDouble new];
+  device.nativeLookupAvailable = YES;
+  device.lookupError = [NSError errorWithDomain:@"NativeLookup" code:1 userInfo:nil];
+  device.enumerationError = [NSError errorWithDomain:@"Enumeration" code:2 userInfo:nil];
+  NSError *error = nil;
+  XCTAssertNil([FBScreen screenWithDisplayID:-1 device:device error:&error]);
+  XCTAssertEqualObjects(error, device.lookupError);
+}
+
+- (void)testScreenLookupWithoutNativeSelector
+{
+  FBScreenDeviceDouble *device = [FBScreenDeviceDouble new];
+  device.screens = @[XCUIScreen.mainScreen];
+  NSError *error = nil;
+  XCTAssertEqualObjects([FBScreen screenWithDisplayID:XCUIScreen.mainScreen.displayID device:device error:&error],
+                        XCUIScreen.mainScreen);
+  XCTAssertNil(error);
+  XCTAssertEqual(device.enumerationCount, 1UL);
+  XCTAssertNil([FBScreen screenWithDisplayID:-1 device:device error:&error]);
+  XCTAssertTrue([error.localizedDescription containsString:@"Available display ids"]);
+  device.screens = nil;
+  device.enumerationError = [NSError errorWithDomain:@"Enumeration" code:2 userInfo:nil];
+  XCTAssertNil([FBScreen screenWithDisplayID:-1 device:device error:&error]);
+  XCTAssertEqualObjects(error, device.enumerationError);
+}
+
+- (void)testScreenLookupWithoutDeviceScreenSelectors
+{
+  FBScreenDeviceDouble *device = [FBScreenDeviceDouble new];
+  device.enumerationUnavailable = YES;
+  NSError *error = nil;
+  XCTAssertEqualObjects([FBScreen screenWithDisplayID:XCUIScreen.mainScreen.displayID device:device error:&error],
+                        XCUIScreen.mainScreen);
+  XCTAssertNil(error);
+  XCTAssertNil([FBScreen screenWithDisplayID:-1 device:device error:&error]);
+  XCTAssertNotNil(error);
+  XCTAssertEqual(device.enumerationCount, 0UL);
+}
+
 - (void)testCurrentScreenDefaultsToMainScreen
 {
   NSError *error = nil;
@@ -108,6 +251,52 @@
   XCTAssertNil(FBConfiguration.sharedInstance.currentDisplayId);
 }
 
+- (void)testSecondaryDisplayDoesNotHitTestMainDisplay
+{
+  NSArray<NSDictionary<NSString *, id> *> *screens = [FBScreen screensWithError:nil];
+  BOOL testedSecondaryDisplay = NO;
+  for (NSDictionary<NSString *, id> *screen in screens) {
+    if ([screen[@"isMain"] boolValue]) {
+      continue;
+    }
+    testedSecondaryDisplay = YES;
+    FBConfiguration.sharedInstance.currentDisplayId = screen[@"displayId"];
+    XCTAssertNil(FBActiveAppDetectionPoint.sharedInstance.axElement);
+  }
+  XCTSkipIf(!testedSecondaryDisplay, @"Requires a secondary display");
+}
+
+- (void)testActiveAppDetectionRejectsUnavailableDisplay
+{
+  FBConfiguration.sharedInstance.currentDisplayId = @([self unknownDisplayID]);
+  XCTAssertThrowsSpecificNamed(FBActiveAppDetectionPoint.sharedInstance.axElement,
+                               NSException, FBInvalidArgumentException);
+}
+
+- (void)testRecordingUsesSelectedDisplay
+{
+  XCTSkipIf(nil == NSClassFromString(@"XCTScreenRecordingRequest"), @"Screen recording is unavailable");
+  FBScreenRecordingRequest *request = [[FBScreenRecordingRequest alloc] initWithFps:10 codec:0];
+  NSError *error = nil;
+  id defaultRequest = [request toNativeRequestWithError:&error];
+  XCTAssertNotNil(defaultRequest);
+  XCTAssertNil(error);
+  XCTAssertEqualObjects([defaultRequest valueForKey:@"screenID"], @([FBScreen displayID]));
+
+  for (NSDictionary<NSString *, id> *screen in [FBScreen screensWithError:nil]) {
+    FBConfiguration.sharedInstance.currentDisplayId = screen[@"displayId"];
+    id nativeRequest = [request toNativeRequestWithError:&error];
+    XCTAssertNotNil(nativeRequest);
+    XCTAssertNil(error);
+    XCTAssertEqualObjects([nativeRequest valueForKey:@"screenID"], screen[@"displayId"]);
+  }
+
+  FBConfiguration.sharedInstance.currentDisplayId = @([self unknownDisplayID]);
+  XCTAssertNil([request toNativeRequestWithError:&error]);
+  XCTAssertNotNil(error);
+  XCTAssertTrue([error.localizedDescription containsString:@"Available display ids"]);
+}
+
 - (long long)unknownDisplayID
 {
   long long maxID = 0;
@@ -122,4 +311,134 @@
   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)testScreenInfoInBothLandscapeOrientations
+{
+  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 @[@(UIDeviceOrientationLandscapeLeft), @(UIDeviceOrientationLandscapeRight)]) {
+    XCTAssertTrue([[XCUIDevice sharedDevice] fb_setDeviceInterfaceOrientation:orientation.integerValue]);
+    __block NSDictionary *info = nil;
+    // iPad keeps its top status bar in landscape. Wait for rotation to finish
+    // rather than accepting a transient zero crop as a successful result.
+    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 <= height || height <= 0) {
+        return NO;
+      }
+      if (barHeight == 0) {
+        return !expectsVisibleBar && barWidth == 0;
+      }
+      return barHeight > 0 && barHeight < height && fabs(barWidth - width) <= 1;
+    }], @"Unexpected landscape screen metadata: %@", 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/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/package.json

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