@devicelab/maestro-runner-darwin-x64 1.1.25

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBScreenRecordingPromise.h

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <XCTest/XCTest.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FBScreenRecordingPromise : NSObject
+
+/** Unique identiifier of the video recording, also used as the default file name */
+@property (nonatomic, readonly) NSUUID *identifier;
+/** Native screen recording promise */
+@property (nonatomic, readonly) id nativePromise;
+
+/**
+ Creates a wrapper object for a native screen recording promise
+
+ @param promise Native promise object to be wrapped
+ */
+- (instancetype)initWithNativePromise:(id)promise;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBScreenRecordingPromise.m

@@ -0,0 +1,31 @@
+/**
+ *
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "FBScreenRecordingPromise.h"
+
+@interface FBScreenRecordingPromise ()
+@property (readwrite) id nativePromise;
+@end
+
+@implementation FBScreenRecordingPromise
+
+- (instancetype)initWithNativePromise:(id)promise
+{
+  if ((self = [super init])) {
+    self.nativePromise = promise;
+  }
+  return self;
+}
+
+- (NSUUID *)identifier
+{
+  return (NSUUID *)[self.nativePromise valueForKey:@"_UUID"];
+}
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBScreenRecordingRequest.h

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <XCTest/XCTest.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FBScreenRecordingRequest : NSObject
+
+/** The amount of video FPS */
+@property (readonly, nonatomic) NSUInteger fps;
+/** Codec to use, where 0 is h264, 1 - HEVC */
+@property (readonly, nonatomic) long long codec;
+
+/**
+ Creates a custom wrapper for a screen recording reqeust
+
+ @param fps FPS value, see baove
+ @param codec Codex value, see above
+ */
+- (instancetype)initWithFps:(NSUInteger)fps codec:(long long)codec;
+
+/**
+ Transforms the current wrapper instance to a native object,
+ which is ready to be passed to XCTest APIs
+
+ @param error If there was a failure converting the instance to a native object
+ @returns Native object instance
+ */
+- (nullable id)toNativeRequestWithError:(NSError **)error;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBScreenRecordingRequest.m

@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "FBScreenRecordingRequest.h"
+
+#import "FBErrorBuilder.h"
+#import "XCUIScreen.h"
+
+@implementation FBScreenRecordingRequest
+
+- (instancetype)initWithFps:(NSUInteger)fps codec:(long long)codec
+{
+  if ((self = [super init])) {
+    _fps = fps;
+    _codec = codec;
+  }
+  return self;
+}
+
+- (nullable id)createVideoEncodingWithError:(NSError **)error
+{
+  Class videoEncodingClass = NSClassFromString(@"XCTVideoEncoding");
+  if (nil == videoEncodingClass) {
+    [[[FBErrorBuilder builder]
+      withDescription:@"Cannot find XCTVideoEncoding class"]
+     buildError:error];
+    return nil;
+  }
+
+  id videoEncodingAllocated = [videoEncodingClass alloc];
+  SEL videoEncodingConstructorSelector = NSSelectorFromString(@"initWithCodec:frameRate:");
+  if (![videoEncodingAllocated respondsToSelector:videoEncodingConstructorSelector]) {
+    [[[FBErrorBuilder builder]
+      withDescription:@"'initWithCodec:frameRate:' contructor is not found on XCTVideoEncoding class"]
+     buildError:error];
+    return nil;
+  }
+
+  NSMethodSignature *videoEncodingContructorSignature = [videoEncodingAllocated methodSignatureForSelector:videoEncodingConstructorSelector];
+  NSInvocation *videoEncodingInitInvocation = [NSInvocation invocationWithMethodSignature:videoEncodingContructorSignature];
+  [videoEncodingInitInvocation setSelector:videoEncodingConstructorSelector];
+  long long codec = self.codec;
+  [videoEncodingInitInvocation setArgument:&codec atIndex:2];
+  double frameRate = self.fps;
+  [videoEncodingInitInvocation setArgument:&frameRate atIndex:3];
+  [videoEncodingInitInvocation invokeWithTarget:videoEncodingAllocated];
+  id __unsafe_unretained result;
+  [videoEncodingInitInvocation getReturnValue:&result];
+  return result;
+}
+
+- (id)toNativeRequestWithError:(NSError **)error
+{
+  Class screenRecordingRequestClass = NSClassFromString(@"XCTScreenRecordingRequest");
+  if (nil == screenRecordingRequestClass) {
+    [[[FBErrorBuilder builder]
+      withDescription:@"Cannot find XCTScreenRecordingRequest class"]
+     buildError:error];
+    return nil;
+  }
+
+  id screenRecordingRequestAllocated = [screenRecordingRequestClass alloc];
+  SEL screenRecordingRequestConstructorSelector = NSSelectorFromString(@"initWithScreenID:rect:preferredEncoding:");
+  if (![screenRecordingRequestAllocated respondsToSelector:screenRecordingRequestConstructorSelector]) {
+    [[[FBErrorBuilder builder]
+      withDescription:@"'initWithScreenID:rect:preferredEncoding:' contructor is not found on XCTScreenRecordingRequest class"]
+     buildError:error];
+    return nil;
+  }
+  id videoEncoding = [self createVideoEncodingWithError:error];
+  if (nil == videoEncoding) {
+    return nil;
+  }
+
+  NSMethodSignature *screenRecordingRequestContructorSignature = [screenRecordingRequestAllocated methodSignatureForSelector:screenRecordingRequestConstructorSelector];
+  NSInvocation *screenRecordingRequestInitInvocation = [NSInvocation invocationWithMethodSignature:screenRecordingRequestContructorSignature];
+  [screenRecordingRequestInitInvocation setSelector:screenRecordingRequestConstructorSelector];
+  long long mainScreenId = XCUIScreen.mainScreen.displayID;
+  [screenRecordingRequestInitInvocation setArgument:&mainScreenId atIndex:2];
+  CGRect fullScreenRect = CGRectNull;
+  [screenRecordingRequestInitInvocation setArgument:&fullScreenRect atIndex:3];
+  [screenRecordingRequestInitInvocation setArgument:&videoEncoding atIndex:4];
+  [screenRecordingRequestInitInvocation invokeWithTarget:screenRecordingRequestAllocated];
+  id __unsafe_unretained result;
+  [screenRecordingRequestInitInvocation getReturnValue:&result];
+  return result;
+}
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBSession-Private.h

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <WebDriverAgentLib/FBSession.h>
+
+@class FBElementCache;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FBSession ()
+@property (nonatomic, copy, readwrite) NSString *identifier;
+@property (nonatomic, strong, readwrite) FBElementCache *elementCache;
+
+/**
+ Sets session as current session
+ */
++ (void)markSessionActive:(FBSession *)session;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBSession.h

@@ -0,0 +1,141 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class FBElementCache;
+@class XCUIApplication;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** Bundle identifier of Mobile Safari browser */
+extern NSString* const FB_SAFARI_BUNDLE_ID;
+
+/**
+ Class that represents testing session
+ */
+@interface FBSession : NSObject
+
+/*! Application tested during that session */
+@property (nonatomic, readonly) XCUIApplication *activeApplication;
+
+/*! Session's identifier */
+@property (nonatomic, readonly) NSString *identifier;
+
+/*! Element cache related to that session */
+@property (nonatomic, readonly) FBElementCache *elementCache;
+
+/*! The identifier of the active application */
+@property (nonatomic) NSString *defaultActiveApplication;
+
+/*! The action to apply to unexpected alerts. Either "accept"/"dismiss" or nil/empty string (by default) to do nothing */
+@property (nonatomic, nullable) NSString *defaultAlertAction;
+
+/*! Whether to use the native caching strategy for elements or the custom one: https://discuss.appium.io/t/elements-state-coming-from-xpath-vs-ios-predicate-string/34016 */
+@property (nonatomic) BOOL useNativeCachingStrategy;
+
+/*! Keeps cached visibility values for the current snapshots tree */
+@property (nonatomic, readonly) NSMutableDictionary<NSNumber *, NSMutableDictionary<NSString *, NSNumber *> *> *elementsVisibilityCache;
+
++ (nullable instancetype)activeSession;
+
+/**
+ Fetches session for given identifier.
+ If identifier doesn't match activeSession identifier, will return nil.
+
+ @param identifier Identifier for searched session
+ @return session. Can return nil if session does not exists
+ */
++ (nullable instancetype)sessionWithIdentifier:(NSString *)identifier;
+
+/**
+ Creates and saves new session for application
+
+ @param application The application that we want to create session for
+ @return new session
+ */
++ (instancetype)initWithApplication:(nullable XCUIApplication *)application;
+
+/**
+ Creates and saves new session for application with default alert handling behaviour
+
+ @param application The application that we want to create session for
+ @param defaultAlertAction The default reaction to on-screen alert. Either 'accept' or 'dismiss'
+ @return new session
+ */
++ (instancetype)initWithApplication:(nullable XCUIApplication *)application
+                 defaultAlertAction:(NSString *)defaultAlertAction;
+
+/**
+ Kills application associated with that session and removes session
+ */
+- (void)kill;
+
+/**
+ Launch an application with given bundle identifier in scope of current session.
+ !This method is only available since Xcode9 SDK
+
+ @param bundleIdentifier Valid bundle identifier of the application to be launched
+ @param shouldWaitForQuiescence whether to wait for quiescence on application startup
+ @param arguments The optional array of application command line arguments. The arguments are going to be applied if the application was not running before.
+ @param environment The optional dictionary of environment variables for the application, which is going to be executed. The environment variables are going to be applied if the application was not running before.
+ @return The application instance
+ */
+- (XCUIApplication *)launchApplicationWithBundleId:(NSString *)bundleIdentifier
+                           shouldWaitForQuiescence:(nullable NSNumber *)shouldWaitForQuiescence
+                                         arguments:(nullable NSArray<NSString *> *)arguments
+                                       environment:(nullable NSDictionary <NSString *, NSString *> *)environment;
+
+/**
+ Activate an application with given bundle identifier in scope of current session.
+ !This method is only available since Xcode9 SDK
+
+ @param bundleIdentifier Valid bundle identifier of the application to be activated
+ @return The application instance
+ */
+- (XCUIApplication *)activateApplicationWithBundleId:(NSString *)bundleIdentifier;
+
+/**
+ Terminate an application with the given bundle id. The application should be previously
+ executed by launchApplicationWithBundleId method or passed to the init method.
+
+ @param bundleIdentifier Valid bundle identifier of the application to be terminated
+ @return Either YES if the app has been successfully terminated or NO if it was not running
+ */
+- (BOOL)terminateApplicationWithBundleId:(NSString *)bundleIdentifier;
+
+/**
+ Get the state of the particular application in scope of the current session.
+ !This method is only returning reliable results since Xcode9 SDK
+
+ @param bundleIdentifier Valid bundle identifier of the application to get the state from
+ @return Application state as integer number. See
+         https://developer.apple.com/documentation/xctest/xcuiapplicationstate?language=objc
+         for more details on possible enum values
+ */
+- (NSUInteger)applicationStateWithBundleId:(NSString *)bundleIdentifier;
+
+/**
+ Allows to enable automated session alerts monitoring.
+ Repeated calls are ignored if alerts monitoring has been already enabled.
+
+ @returns YES if the actual alerts monitoring state has been changed
+ */
+- (BOOL)enableAlertsMonitor;
+
+/**
+ Allows to disable automated alerts monitoring
+ Repeated calls are ignored if alerts monitoring has been already disabled.
+
+ @returns YES if the actual alerts monitoring state has been changed
+ */
+- (BOOL)disableAlertsMonitor;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBSession.m

@@ -0,0 +1,295 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "FBSession.h"
+#import "FBSession-Private.h"
+
+#import <objc/runtime.h>
+
+#import "FBXCAccessibilityElement.h"
+#import "FBAlertsMonitor.h"
+#import "FBConfiguration.h"
+#import "FBElementCache.h"
+#import "FBExceptions.h"
+#import "FBMacros.h"
+#import "FBScreenRecordingContainer.h"
+#import "FBScreenRecordingPromise.h"
+#import "FBScreenRecordingRequest.h"
+#import "FBXCodeCompatibility.h"
+#import "FBXCTestDaemonsProxy.h"
+#import "XCUIApplication+FBQuiescence.h"
+#import "XCUIElement.h"
+#import "XCUIElement+FBClassChain.h"
+
+/*!
+ The intial value for the default application property.
+ Setting this value to `defaultActiveApplication` property forces WDA to use the internal
+ automated algorithm to determine the active on-screen application
+ */
+NSString *const FBDefaultApplicationAuto = @"auto";
+
+NSString *const FB_SAFARI_BUNDLE_ID = @"com.apple.mobilesafari";
+
+@interface FBSession ()
+@property (nullable, nonatomic) XCUIApplication *testedApplication;
+@property (nonatomic) BOOL isTestedApplicationExpectedToRun;
+@property (nonatomic) BOOL shouldAppsWaitForQuiescence;
+@property (nonatomic, nullable) FBAlertsMonitor *alertsMonitor;
+@property (nonatomic, readwrite) NSMutableDictionary<NSNumber *, NSMutableDictionary<NSString *, NSNumber *> *> *elementsVisibilityCache;
+@end
+
+@interface FBSession (FBAlertsMonitorDelegate)
+
+- (void)didDetectAlert:(FBAlert *)alert;
+
+@end
+
+@implementation FBSession (FBAlertsMonitorDelegate)
+
+- (void)didDetectAlert:(FBAlert *)alert
+{
+  NSString *autoClickAlertSelector = FBConfiguration.autoClickAlertSelector;
+  if ([autoClickAlertSelector length] > 0) {
+    @try {
+      NSArray<XCUIElement*> *matches = [alert.alertElement fb_descendantsMatchingClassChain:autoClickAlertSelector
+                                                                shouldReturnAfterFirstMatch:YES];
+      if (matches.count > 0) {
+          [[matches objectAtIndex:0] tap];
+      }
+    } @catch (NSException *e) {
+      [FBLogger logFmt:@"Could not click at the alert element '%@'. Original error: %@",
+       autoClickAlertSelector, e.description];
+    }
+    // This setting has priority over other settings if enabled
+    return;
+  }
+
+  if (nil == self.defaultAlertAction || 0 == self.defaultAlertAction.length) {
+    return;
+  }
+
+  NSError *error;
+  if ([self.defaultAlertAction isEqualToString:@"accept"]) {
+    if (![alert acceptWithError:&error]) {
+      [FBLogger logFmt:@"Cannot accept the alert. Original error: %@", error.description];
+    }
+  } else if ([self.defaultAlertAction isEqualToString:@"dismiss"]) {
+    if (![alert dismissWithError:&error]) {
+      [FBLogger logFmt:@"Cannot dismiss the alert. Original error: %@", error.description];
+    }
+  } else {
+    [FBLogger logFmt:@"'%@' default alert action is unsupported", self.defaultAlertAction];
+  }
+}
+
+@end
+
+@implementation FBSession
+
+static FBSession *_activeSession = nil;
+
++ (instancetype)activeSession
+{
+  return _activeSession;
+}
+
++ (void)markSessionActive:(FBSession *)session
+{
+  if (_activeSession) {
+    [_activeSession kill];
+  }
+  _activeSession = session;
+}
+
++ (instancetype)sessionWithIdentifier:(NSString *)identifier
+{
+  if (!identifier) {
+    return nil;
+  }
+  if (![identifier isEqualToString:_activeSession.identifier]) {
+    return nil;
+  }
+  return _activeSession;
+}
+
++ (instancetype)initWithApplication:(XCUIApplication *)application
+{
+  FBSession *session = [FBSession new];
+  session.useNativeCachingStrategy = YES;
+  session.alertsMonitor = nil;
+  session.defaultAlertAction = nil;
+  session.elementsVisibilityCache = [NSMutableDictionary dictionary];
+  session.identifier = [[NSUUID UUID] UUIDString];
+  session.defaultActiveApplication = FBDefaultApplicationAuto;
+  session.testedApplication = nil;
+  session.isTestedApplicationExpectedToRun = nil != application && application.running;
+  if (application) {
+    session.testedApplication = application;
+    session.shouldAppsWaitForQuiescence = application.fb_shouldWaitForQuiescence;
+  }
+  session.elementCache = [FBElementCache new];
+  [FBSession markSessionActive:session];
+  return session;
+}
+
++ (instancetype)initWithApplication:(nullable XCUIApplication *)application
+                 defaultAlertAction:(NSString *)defaultAlertAction
+{
+  FBSession *session = [self.class initWithApplication:application];
+  session.defaultAlertAction = [defaultAlertAction lowercaseString];
+  [session enableAlertsMonitor];
+  return session;
+}
+
+- (BOOL)enableAlertsMonitor
+{
+  if (nil != self.alertsMonitor) {
+    return NO;
+  }
+
+  self.alertsMonitor = [[FBAlertsMonitor alloc] init];
+  self.alertsMonitor.delegate = (id<FBAlertsMonitorDelegate>)self;
+  [self.alertsMonitor enable];
+  return YES;
+}
+
+- (BOOL)disableAlertsMonitor
+{
+  if (nil == self.alertsMonitor) {
+    return NO;
+  }
+
+  [self.alertsMonitor disable];
+  self.alertsMonitor = nil;
+  return YES;
+}
+
+- (void)kill
+{
+  if (nil == _activeSession) {
+    return;
+  }
+
+  [self disableAlertsMonitor];
+
+  FBScreenRecordingPromise *activeScreenRecording = FBScreenRecordingContainer.sharedInstance.screenRecordingPromise;
+  if (nil != activeScreenRecording) {
+    NSError *error;
+    if (![FBXCTestDaemonsProxy stopScreenRecordingWithUUID:activeScreenRecording.identifier error:&error]) {
+      [FBLogger logFmt:@"%@", error];
+    }
+    [FBScreenRecordingContainer.sharedInstance reset];
+  }
+
+  if (nil != self.testedApplication
+      && FBConfiguration.shouldTerminateApp
+      && self.testedApplication.running
+      && ![self.testedApplication fb_isSameAppAs:XCUIApplication.fb_systemApplication]) {
+    @try {
+      [self.testedApplication terminate];
+    } @catch (NSException *e) {
+      [FBLogger logFmt:@"%@", e.description];
+    }
+  }
+
+  _activeSession = nil;
+}
+
+- (XCUIApplication *)activeApplication
+{
+  BOOL isAuto = [self.defaultActiveApplication isEqualToString:FBDefaultApplicationAuto];
+  NSString *defaultBundleId = isAuto ? nil : self.defaultActiveApplication;
+
+  if (nil != defaultBundleId && [self applicationStateWithBundleId:defaultBundleId] >= XCUIApplicationStateRunningForeground) {
+    return [self makeApplicationWithBundleId:defaultBundleId];
+  }
+
+  if (nil != self.testedApplication) {
+    XCUIApplicationState testedAppState = self.testedApplication.state;
+    if (testedAppState >= XCUIApplicationStateRunningForeground) {
+      NSPredicate *searchPredicate = [NSPredicate predicateWithFormat:@"%K == %@ OR %K IN {%@, %@}",
+                                      @"elementType", @(XCUIElementTypeAlert), 
+                                      // To look for `SBTransientOverlayWindow` elements. See https://github.com/appium/WebDriverAgent/pull/946
+                                      @"identifier", @"SBTransientOverlayWindow",
+                                      // To look for 'criticalAlertSetting' elements https://developer.apple.com/documentation/usernotifications/unnotificationsettings/criticalalertsetting
+                                      // See https://github.com/appium/appium/issues/20835
+                                      @"NotificationShortLookView"];
+      if ([FBConfiguration shouldRespectSystemAlerts]
+          && [[XCUIApplication.fb_systemApplication descendantsMatchingType:XCUIElementTypeAny]
+              matchingPredicate:searchPredicate].count > 0) {
+        return XCUIApplication.fb_systemApplication;
+      }
+      return (XCUIApplication *)self.testedApplication;
+    }
+    if (self.isTestedApplicationExpectedToRun && testedAppState <= XCUIApplicationStateNotRunning) {
+      NSString *description = [NSString stringWithFormat:@"The application under test with bundle id '%@' is not running, possibly crashed", self.testedApplication.bundleID];
+      @throw [NSException exceptionWithName:FBApplicationCrashedException reason:description userInfo:nil];
+    }
+  }
+
+  return [XCUIApplication fb_activeApplicationWithDefaultBundleId:defaultBundleId];
+}
+
+- (XCUIApplication *)launchApplicationWithBundleId:(NSString *)bundleIdentifier
+                           shouldWaitForQuiescence:(nullable NSNumber *)shouldWaitForQuiescence
+                                         arguments:(nullable NSArray<NSString *> *)arguments
+                                       environment:(nullable NSDictionary <NSString *, NSString *> *)environment
+{
+  XCUIApplication *app = [self makeApplicationWithBundleId:bundleIdentifier];
+  if (nil == shouldWaitForQuiescence) {
+    // Iherit the quiescence check setting from the main app under test by default
+    app.fb_shouldWaitForQuiescence = nil != self.testedApplication && self.shouldAppsWaitForQuiescence;
+  } else {
+    app.fb_shouldWaitForQuiescence = [shouldWaitForQuiescence boolValue];
+  }
+  if (!app.running) {
+    app.launchArguments = arguments ?: @[];
+    app.launchEnvironment = environment ?: @{};
+    [app launch];
+  } else {
+    [app activate];
+  }
+  if ([app fb_isSameAppAs:self.testedApplication]) {
+    self.isTestedApplicationExpectedToRun = YES;
+  }
+  return app;
+}
+
+- (XCUIApplication *)activateApplicationWithBundleId:(NSString *)bundleIdentifier
+{
+  XCUIApplication *app = [self makeApplicationWithBundleId:bundleIdentifier];
+  [app activate];
+  return app;
+}
+
+- (BOOL)terminateApplicationWithBundleId:(NSString *)bundleIdentifier
+{
+  XCUIApplication *app = [self makeApplicationWithBundleId:bundleIdentifier];
+  if ([app fb_isSameAppAs:self.testedApplication]) {
+    self.isTestedApplicationExpectedToRun = NO;
+  }
+  if (app.running) {
+    [app terminate];
+    return YES;
+  }
+  return NO;
+}
+
+- (NSUInteger)applicationStateWithBundleId:(NSString *)bundleIdentifier
+{
+  return [self makeApplicationWithBundleId:bundleIdentifier].state;
+}
+
+- (XCUIApplication *)makeApplicationWithBundleId:(NSString *)bundleIdentifier
+{
+  return nil != self.testedApplication && [bundleIdentifier isEqualToString:(NSString *)self.testedApplication.bundleID]
+    ? self.testedApplication
+    : [[XCUIApplication alloc] initWithBundleIdentifier:bundleIdentifier];
+}
+
+@end