有没有办法在 Swift XCTest UI 的测试之间重置应用程序？

Question

XCTest 中是否有一个 API 调用可以放入 setUP() 或 tearDown() 以在测试之间重置应用程序？我查看了 XCUIApplication 的点语法，我看到的只是 .launch()

或者有没有办法在 Swift 中调用 shell 脚本？然后我可以在测试方法之间调用 xcrun 来重置模拟器。

Answer 1

此时，Xcode、Simulator 和 Swift Package Manager 提供的 public API 没有出现任何可从 setUp() 和 tearDown() XCText 子类调用到“Reset模拟器的“内容和设置”。

还有其他可能使用公共 API 的方法：

1. 应用程序代码。添加一些myResetApplication() 应用程序代码以将应用程序置于已知状态。但是，设备（模拟器）状态控制受到应用程序沙箱的限制……这在应用程序之外没有太大帮助。这种方法对于清除应用程序可控持久性是可以的。

2. Shell 脚本。从 shell 脚本运行测试。在每次测试运行之间使用xcrun simctl erase all 或xcrun simctl uninstall <device> <app identifier> 或类似名称来重置模拟器（或卸载应用程序）。 see StackOverflow: "How can I reset the iOS Simulator from the command line?"

xcrun simctl --help
# Uninstall a single application
xcrun simctl uninstall --help  
xcrun simctl uninstall <device> <app identifier>

# Erase a device's contents and settings.
xcrun simctl erase <device>
xcrun simctl erase all      # all existing devices

# Grant, revoke, or reset privacy and permissions
simctl privacy <device> <action> <service> [<bundle identifier>]

1. Xcode 架构脚本动作。将xcrun simctl erase all（或xcrun simctl erase <DEVICE_UUID>）或类似命令添加到Xcode Scheme 部分，例如Test 或Build 部分。选择产品 > 方案 > 编辑方案…菜单。展开方案测试部分。选择测试部分下的预操作。单击 (+) 添加“新运行脚本操作”。命令xcrun simctl erase all可以直接输入，不需要任何外部脚本。

---

调用的选项1。应用代码重置应用：

A. 应用程序界面。 [UI 测试] 提供重置按钮或其他用于重置应用程序的 UI 操作。 UI 元素可以通过XCUIApplication 在XCTest 例程setUp()、tearDown() 或testSomething() 中执行。

B. 启动参数。 [UI 测试] 正如 Victor Ronin 所指出的，可以从测试 setUp() 中传递一个参数 ...

class AppResetUITests: XCTestCase {

  override func setUp() {
    // ...
    let app = XCUIApplication()
    app.launchArguments = ["MY_UI_TEST_MODE"]
    app.launch()

...由AppDelegate接收...

class AppDelegate: UIResponder, UIApplicationDelegate {

  func application( …didFinishLaunchingWithOptions… ) -> Bool {
    // ...
    let args = ProcessInfo.processInfo.arguments
    if args.contains("MY_UI_TEST_MODE") {
      myResetApplication()
    }

C. Xcode 方案参数。 [UI 测试，单元测试] 选择 Product > Scheme > Edit Scheme... 菜单。展开方案运行部分。 (+) 添加一些参数，如MY_UI_TEST_MODE。该参数将在ProcessInfo.processInfo 中提供。

// ... in application
let args = ProcessInfo.processInfo.arguments
if args.contains("MY_UI_TEST_MODE") {
    myResetApplication()
}

D. 直接调用。 [单元测试] 单元测试包被注入到正在运行的应用程序中，可以直接调用应用程序中的一些myResetApplication() 例程。警告：默认单元测试在主屏幕加载后运行。 see Test Load Sequence 但是，UI 测试包作为被测应用程序外部的进程运行。因此，在单元测试中有效的方法在 UI 测试中会出现链接错误。

class AppResetUnitTests: XCTestCase {

  override func setUp() {
    // ... Unit Test: runs.  UI Test: link error.
    myResetApplication() // visible code implemented in application

Answer 2

您可以要求您的应用自行“清理”

• 您使用XCUIApplication.launchArguments 设置一些标志

• 在 AppDelegate 中检查

  如果 NSProcessInfo.processInfo().arguments.contains("YOUR_FLAG_NAME_HERE") { // 在这里进行清理 }

Answer 3

您可以在测试目标中添加“运行脚本”阶段来构建阶段，以便在对其运行单元测试之前卸载应用程序，不幸的是，这不是在测试用例之间。

/usr/bin/xcrun simctl uninstall booted com.mycompany.bundleId

更新

---

在测试之间，您可以在 tearDown 阶段通过 Springboard 删除应用。虽然，这确实需要使用 XCTest 的私有标头。 （标头转储可从Facebook's WebDriverAgent here 获得。）

以下是 Springboard 类中的一些示例代码，用于通过长按从 Springboard 中删除应用：

#Swift 4：

import XCTest

class Springboard {

    static let springboard = XCUIApplication(bundleIdentifier: "com.apple.springboard")
    
    /**
     Terminate and delete the app via springboard
     */
    class func deleteMyApp() {
        XCUIApplication().terminate()
        
         // Force delete the app from the springboard
        let icon = springboard.icons["Citizen"]
        if icon.exists {
            let iconFrame = icon.frame
            let springboardFrame = springboard.frame
            icon.press(forDuration: 1.3)
        
            // Tap the little "X" button at approximately where it is. The X is not exposed directly
            springboard.coordinate(withNormalizedOffset: CGVector(dx: (iconFrame.minX + 3) / springboardFrame.maxX, dy: (iconFrame.minY + 3) / springboardFrame.maxY)).tap()
        
            springboard.alerts.buttons["Delete"].tap()
        }
    }
 }

#Swift 3-:

import XCTest

class Springboard {

    static let springboard = XCUIApplication(privateWithPath: nil, bundleID: "com.apple.springboard")
    
    /**
     Terminate and delete the app via springboard
     */
    class func deleteMyApp() {
        XCUIApplication().terminate()
        
        // Resolve the query for the springboard rather than launching it
        springboard.resolve()
        
        // Force delete the app from the springboard
        let icon = springboard.icons["MyAppName"]
        if icon.exists {
            let iconFrame = icon.frame
            let springboardFrame = springboard.frame
            icon.pressForDuration(1.3)
            
            if #available(iOS 13.0, *) {
                springboard.buttons["Remove App"].tap()
                springboard.alerts.buttons["Delete App"].tap()
                springboard.alerts.buttons["Delete"].tap()
            } else {
            
                // Tap the little "X" button at approximately where it is. The X is not exposed directly
                let xPosition = CGVector(dx: (iconFrame.minX + 3) / springboardFrame.maxX,
                                     dy: (iconFrame.minY + 3) / springboardFrame.maxY)
                springboard.coordinate(withNormalizedOffset: xPosition).tap()
                springboard.alerts.buttons["Delete"].tap()
            }
        }
    }
 }

然后：

override func tearDown() {
    Springboard.deleteMyApp()
    super.tearDown()
}

私有标头被导入到 Swift 桥接头中。您需要导入：

// Private headers from XCTest
#import "XCUIApplication.h"
#import "XCUIElement.h"

注意：从 Xcode 10 开始，XCUIApplication(bundleIdentifier:) 现已被 Apple 公开，并且 不再需要私有标头。

Answer 4

我使用了@Chase Holland answer 并按照相同的方法更新了 Springboard 类，以使用设置应用程序重置内容和设置。这在您需要重置权限对话框时很有用。

import XCTest

class Springboard {
    static let springboard = XCUIApplication(privateWithPath: nil, bundleID: "com.apple.springboard")
    static let settings = XCUIApplication(privateWithPath: nil, bundleID: "com.apple.Preferences")

    /**
     Terminate and delete the app via springboard
     */
    class func deleteMyApp() {
        XCUIApplication().terminate()

        // Resolve the query for the springboard rather than launching it
        springboard.resolve()

        // Force delete the app from the springboard
        let icon = springboard.icons["MyAppName"]
        if icon.exists {
            let iconFrame = icon.frame
            let springboardFrame = springboard.frame
            icon.pressForDuration(1.3)

            // Tap the little "X" button at approximately where it is. The X is not exposed directly
            springboard.coordinateWithNormalizedOffset(CGVectorMake((iconFrame.minX + 3) / springboardFrame.maxX, (iconFrame.minY + 3) / springboardFrame.maxY)).tap()

            springboard.alerts.buttons["Delete"].tap()

            // Press home once make the icons stop wiggling
            XCUIDevice.sharedDevice().pressButton(.Home)
            // Press home again to go to the first page of the springboard
            XCUIDevice.sharedDevice().pressButton(.Home)
            // Wait some time for the animation end
            NSThread.sleepForTimeInterval(0.5)

            let settingsIcon = springboard.icons["Settings"]
            if settingsIcon.exists {
                settingsIcon.tap()
                settings.tables.staticTexts["General"].tap()
                settings.tables.staticTexts["Reset"].tap()
                settings.tables.staticTexts["Reset Location & Privacy"].tap()
                settings.buttons["Reset Warnings"].tap()
                settings.terminate()
            }
        }
    }
}

Answer 5

为 swift 3.1 / xcode 8.3 更新

在测试目标中创建桥接头：

#import <XCTest/XCUIApplication.h>
#import <XCTest/XCUIElement.h>

@interface XCUIApplication (Private)
- (id)initPrivateWithPath:(NSString *)path bundleID:(NSString *)bundleID;
- (void)resolve;
@end

更新的跳板类

class Springboard {
   static let springboard = XCUIApplication(privateWithPath: nil, bundleID: "com.apple.springboard")!
   static let settings = XCUIApplication(privateWithPath: nil, bundleID: "com.apple.Preferences")!

/**
Terminate and delete the app via springboard
*/

class func deleteMyApp() {
   XCUIApplication().terminate()

// Resolve the query for the springboard rather than launching it

   springboard.resolve()

// Force delete the app from the springboard
   let icon = springboard.icons["{MyAppName}"] /// change to correct app name
   if icon.exists {
     let iconFrame = icon.frame
     let springboardFrame = springboard.frame
     icon.press(forDuration: 1.3)

  // Tap the little "X" button at approximately where it is. The X is not exposed directly

    springboard.coordinate(withNormalizedOffset: CGVector(dx: (iconFrame.minX + 3) / springboardFrame.maxX, dy: (iconFrame.minY + 3) / springboardFrame.maxY)).tap()

     springboard.alerts.buttons["Delete"].tap()

     // Press home once make the icons stop wiggling

     XCUIDevice.shared().press(.home)
     // Press home again to go to the first page of the springboard
     XCUIDevice.shared().press(.home)
     // Wait some time for the animation end
     Thread.sleep(forTimeInterval: 0.5)

      let settingsIcon = springboard.icons["Settings"]
      if settingsIcon.exists {
       settingsIcon.tap()
       settings.tables.staticTexts["General"].tap()
       settings.tables.staticTexts["Reset"].tap()
       settings.tables.staticTexts["Reset Location & Privacy"].tap()
       settings.buttons["Reset Warnings"].tap()
       settings.terminate()
      }
     }
    }
   }

Answer 6

我使用了@ODManswer，但对其进行了修改以适用于 Swift 4。注意：一些 S/O 答案没有区分 Swift 版本，它们有时具有相当基本的差异。我已经在 iPhone 7 模拟器和 iPad Air 模拟器上进行了纵向测试，它适用于我的应用。

斯威夫特 4

import XCTest
import Foundation

class Springboard {

let springboard = XCUIApplication(bundleIdentifier: "com.apple.springboard")
let settings = XCUIApplication(bundleIdentifier: "com.apple.Preferences")


/**
 Terminate and delete the app via springboard
 */
func deleteMyApp() {
    XCUIApplication().terminate()

    // Resolve the query for the springboard rather than launching it
    springboard.activate()

    // Rotate back to Portrait, just to ensure repeatability here
    XCUIDevice.shared.orientation = UIDeviceOrientation.portrait
    // Sleep to let the device finish its rotation animation, if it needed rotating
    sleep(2)

    // Force delete the app from the springboard
    // Handle iOS 11 iPad 'duplication' of icons (one nested under "Home screen icons" and the other nested under "Multitasking Dock"
    let icon = springboard.otherElements["Home screen icons"].scrollViews.otherElements.icons["YourAppName"]
    if icon.exists {
        let iconFrame = icon.frame
        let springboardFrame = springboard.frame
        icon.press(forDuration: 2.5)

        // Tap the little "X" button at approximately where it is. The X is not exposed directly
        springboard.coordinate(withNormalizedOffset: CGVector(dx: ((iconFrame.minX + 3) / springboardFrame.maxX), dy:((iconFrame.minY + 3) / springboardFrame.maxY))).tap()
        // Wait some time for the animation end
        Thread.sleep(forTimeInterval: 0.5)

        //springboard.alerts.buttons["Delete"].firstMatch.tap()
        springboard.buttons["Delete"].firstMatch.tap()

        // Press home once make the icons stop wiggling
        XCUIDevice.shared.press(.home)
        // Press home again to go to the first page of the springboard
        XCUIDevice.shared.press(.home)
        // Wait some time for the animation end
        Thread.sleep(forTimeInterval: 0.5)

        // Handle iOS 11 iPad 'duplication' of icons (one nested under "Home screen icons" and the other nested under "Multitasking Dock"
        let settingsIcon = springboard.otherElements["Home screen icons"].scrollViews.otherElements.icons["Settings"]
        if settingsIcon.exists {
            settingsIcon.tap()
            settings.tables.staticTexts["General"].tap()
            settings.tables.staticTexts["Reset"].tap()
            settings.tables.staticTexts["Reset Location & Privacy"].tap()
            // Handle iOS 11 iPad difference in error button text
            if UIDevice.current.userInterfaceIdiom == .pad {
                settings.buttons["Reset"].tap()
            }
            else {
                settings.buttons["Reset Warnings"].tap()
            }
            settings.terminate()
        }
    }
  }
}

Answer 7

对于 iOS 11 sims an up，我做了一个非常轻微的修改，点击“x”图标，我们点击了 @Code Monkey 建议的修复。修复适用于 10.3 和 11.2 电话 sims。作为记录，我使用的是 swift 3。我想我会通过一些代码来复制和粘贴以更容易地找到修复程序。 :)

import XCTest

class Springboard {

    static let springboard = XCUIApplication(privateWithPath: nil, bundleID: "com.apple.springboard")

    class func deleteMyApp() {
        XCUIApplication().terminate()

        // Resolve the query for the springboard rather than launching it
        springboard!.resolve()

        // Force delete the app from the springboard
        let icon = springboard!.icons["My Test App"]
        if icon.exists {
            let iconFrame = icon.frame
            let springboardFrame = springboard!.frame
            icon.press(forDuration: 1.3)

            springboard!.coordinate(withNormalizedOffset: CGVector(dx: (iconFrame.minX + 3 * UIScreen.main.scale) / springboardFrame.maxX, dy: (iconFrame.minY + 3 * UIScreen.main.scale) / springboardFrame.maxY)).tap()

            springboard!.alerts.buttons["Delete"].tap()
        }
    }
}

Answer 8

更新 Craig Fishers 对 Swift 4 的回答。为 iPad 横向更新，可能仅适用于横向左侧。

导入 XCTest

类跳板{

static let springboard = XCUIApplication(bundleIdentifier: "com.apple.springboard")

class func deleteMyApp(name: String) {        
    // Force delete the app from the springboard
    let icon = springboard.icons[name]
    if icon.exists {
        let iconFrame = icon.frame
        let springboardFrame = springboard.frame
        icon.press(forDuration: 2.0)

        var portaitOffset = 0.0 as CGFloat
        if XCUIDevice.shared.orientation != .portrait {
            portaitOffset = iconFrame.size.width - 2 * 3 * UIScreen.main.scale
        }

        let coord = springboard.coordinate(withNormalizedOffset: CGVector(dx: (iconFrame.minX + portaitOffset + 3 * UIScreen.main.scale) / springboardFrame.maxX, dy: (iconFrame.minY + 3 * UIScreen.main.scale) / springboardFrame.maxY))
        coord.tap()

        let _ = springboard.alerts.buttons["Delete"].waitForExistence(timeout: 5)
        springboard.alerts.buttons["Delete"].tap()

        XCUIDevice.shared.press(.home)
    }
}

}

Answer 9

这似乎适用于 iOS 12.1 和模拟器

class func deleteApp(appName: String) {
    XCUIApplication().terminate()

    // Force delete the app from the springboard
    let icon = springboard.icons[appName]
    if icon.exists {
        icon.press(forDuration: 2.0)

        icon.buttons["DeleteButton"].tap()
        sleep(2)
        springboard.alerts["Delete “\(appName)”?"].buttons["Delete"].tap()
        sleep(2)

        XCUIDevice.shared.press(.home)
    }
}

Answer 10

这是上述删除应用程序和重置警告的答案的 Objective C 版本（在 iOS 11 和 12 上测试）：

- (void)uninstallAppNamed:(NSString *)appName {

    [[[XCUIApplication alloc] init] terminate];

    XCUIApplication *springboard = [[XCUIApplication alloc] initWithBundleIdentifier:@"com.apple.springboard"];
    [springboard activate];
    XCUIElement *icon = springboard.otherElements[@"Home screen icons"].scrollViews.otherElements.icons[appName];

    if (icon.exists) {
        [icon pressForDuration:2.3];
        [icon.buttons[@"DeleteButton"] tap];
        sleep(2);
        [[springboard.alerts firstMatch].buttons[@"Delete"] tap];
        sleep(2);
        [[XCUIDevice sharedDevice] pressButton:XCUIDeviceButtonHome];
        sleep(2);
    }
}

..

- (void)resetWarnings {

    XCUIApplication *settings = [[XCUIApplication alloc] initWithBundleIdentifier:@"com.apple.Preferences"];
    [settings activate];
    sleep(2);
    [settings.tables.staticTexts[@"General"] tap];
    [settings.tables.staticTexts[@"Reset"] tap];
    [settings.tables.staticTexts[@"Reset Location & Privacy"] tap];

    if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
        [settings.buttons[@"Reset"] tap];
    } else {
        [settings.buttons[@"Reset Warnings"] tap];
    }
    sleep(2);
    [settings terminate];
}

Answer 11

iOS 13.1/Swift 5.1 基于 UI 的删除

static let springboard = XCUIApplication(privateWithPath: nil, bundleID: "com.apple.springboard")!

class func deleteApp() {
    XCUIApplication().terminate()
    XCUIDevice.shared.press(.home)
    XCUIDevice.shared.press(.home)

    let icon = springboard.icons["YourApplication"]
    if !icon.exists { return }

    springboard.swipeLeft()
    springboard.activate()
    Thread.sleep(forTimeInterval: 1.0)

    icon.press(forDuration: 1.3)
    springboard.buttons["Rearrange Apps"].eventuallyExists().tap()

    icon.buttons["DeleteButton"].eventuallyExists().tap()
    springboard.alerts.buttons["Delete"].eventuallyExists().tap()

    XCUIDevice.shared.press(.home)
    XCUIDevice.shared.press(.home)
}

Answer 12

这适用于所有操作系统版本（iOS11、12 和 13）

static let springboard = XCUIApplication(bundleIdentifier: "com.apple.springboard")

    func deleteApp() {
        XCUIApplication().terminate()
        springboard.activate()

        let icon = springboard.icons[appName]

        if icon.exists {
            icon.firstMatch.press(forDuration: 5)
            icon.buttons["DeleteButton"].tap()

            let deleteConfirmation = springboard.alerts["Delete “\(appName)”?"].buttons["Delete"]
            XCTAssertTrue(deleteConfirmation.waitForExistence(timeout: 5), "Delete confirmation not shown")
            deleteConfirmation.tap()
        }
    }

Answer 13

iOS 13.2 解决方案

final class Springboard {

    private static var springboardApp = XCUIApplication(bundleIdentifier: "com.apple.springboard")

    class func deleteApp(name: String) {
        XCUIApplication().terminate()

        springboardApp.activate()

        sleep(1)

        let appIcon = springboardApp.icons.matching(identifier: name).firstMatch
        appIcon.press(forDuration: 1.3)

        sleep(1)

        springboardApp.buttons["Delete App"].tap()

        let deleteButton = springboardApp.alerts.buttons["Delete"].firstMatch
        if deleteButton.waitForExistence(timeout: 5) {
            deleteButton.tap()
        }
    }
}

Answer 14

我在您的测试的setUp 或tearDown 中看到很多卸载您的应用程序的答案。

但您可以通过在测试目标中添加运行脚本阶段，在启动测试之前轻松卸载您的应用。

这样做：

1. 选择应用程序的 Xcode 项目
2. 选择您的测试目标
3. 选择“构建阶段”
4. 点击“+”和“新建运行脚本阶段”

然后，用命令替换占位符# Type a script or drag a script file from your workspace to insert its path.：

xcrun simctl boot ${TARGET_DEVICE_IDENTIFIER}
xcrun simctl uninstall ${TARGET_DEVICE_IDENTIFIER} YOUR_APP_BUNDLE

Answer 15

从 Xcode 11.4 开始，如果您只想重置权限，您可以在 XCUIApplication 的实例上使用 resetAuthorizationStatus(for:)，请参阅 https://developer.apple.com/documentation/xctest/xcuiapplication/3526066-resetauthorizationstatusforresou

如果需要也可以使用simctl，引用自Xcode 11.4 Release Notes：

simctl 现在支持修改隐私权限。您可以修改隐私权限以创建已知状态以进行测试。例如，允许示例应用在没有任何提示的情况下访问照片库：
xcrun simctl privacy <device> grant photos com.example.app

要将所有权限重置为默认值，就像以前从未安装过该应用一样：
xcrun simctl privacy <device> reset all com.example.app。

Answer 16

适用于 iOS14 的工作解决方案

final class Springboard {

    private static var springboardApp = XCUIApplication(bundleIdentifier: "com.apple.springboard")

    class func deleteApp(name: String) {
        XCUIApplication().terminate()

        springboardApp.activate()

        sleep(1)

        let appIcon = springboardApp.icons.matching(identifier: name).firstMatch
        appIcon.press(forDuration: 1.3)

        sleep(1)

        springboardApp.buttons["Remove App"].tap()

        let deleteButton = springboardApp.alerts.buttons["Delete App"].firstMatch
        if deleteButton.waitForExistence(timeout: 5) {
            deleteButton.tap()
            springboardApp.alerts.buttons["Delete"].tap()
        }
    }
}

Answer 17

经过一些实验，我已经完成了一个涵盖不同 iOS 版本的更清晰的解决方案：

import XCTest

private enum Constants {
  static let springboardBundleIdentifier = "com.apple.springboard"
  static let appIconName = "Your App Name"
  static let appIconPressShortDuration: TimeInterval = 2.0
  static let appIconPressLongDuration: TimeInterval = 3.0
  static let deleteAppButton = "Delete App"
  static let removeAppButton = "Remove App"
  static let deleteButton = "Delete"
  static let deleteButtonVectorOffset: CGFloat = 3.0
}

final class SpringboardManager {

  private static let springboard = XCUIApplication(bundleIdentifier: Constants.springboardBundleIdentifier)

  static func deleteApp(_ app: XCUIApplication) {
    if app.exists && app.isHittable {
      XCUIDevice.shared.press(.home)
    }

    app.terminate()

    self.deleteAppIfNeeded(with: Constants.appIconName)
    sleep(1)
  }

  private static func deleteAppIfNeeded(with iconName: String) {
    let appIcon = self.springboard.icons[iconName]

    guard appIcon.exists else {
      return
    }

    appIcon.press(forDuration: Constants.appIconPressShortDuration)

    if let deleteListButton = self.deleteListButton() {
      deleteListButton.tap()
      self.pressDeleteAlertButtons()
    } else {
      appIcon.press(forDuration: Constants.appIconPressLongDuration)
      self.pressDeleteTopLeftButton(for: appIcon)
      self.pressDeleteAlertButtons()
    }
  }

}

private extension SpringboardManager {

  static func pressDeleteAlertButtons() {
    self.pressDeleteAlertButton(self.deleteAppAlertButton())
    self.pressDeleteAlertButton(self.deleteAlertButton())
  }

  static func pressDeleteAlertButton(_ button: XCUIElement?) {
    guard let button = button else {
      return
    }

    button.tap()
  }

  static func pressDeleteTopLeftButton(for appIcon: XCUIElement) {
    let iconFrame = appIcon.frame
    let springboardFrame = self.springboard.frame

    let deleteButtonVector = CGVector(
      dx: (iconFrame.minX + Constants.deleteButtonVectorOffset) / springboardFrame.maxX,
      dy: (iconFrame.minY + Constants.deleteButtonVectorOffset) / springboardFrame.maxY)

    let deleteButtonCoordinate = self.springboard.coordinate(withNormalizedOffset: deleteButtonVector)
    deleteButtonCoordinate.tap()
  }

}

private extension SpringboardManager {

  static func deleteListButton() -> XCUIElement? {
    sleep(1)
    
    let removeListButton = self.springboard.buttons[Constants.removeAppButton]
    let deleteListButton = self.springboard.buttons[Constants.deleteAppButton]

    if removeListButton.exists {
      return removeListButton
    } else if deleteListButton.exists {
      return deleteListButton
    }

    return nil
  }

  static func deleteAppAlertButton() -> XCUIElement? {
    sleep(1)

    let deleteAppButton = self.springboard.alerts.buttons[Constants.deleteAppButton]

    if deleteAppButton.exists {
      return deleteAppButton
    }

    return nil
  }

  static func deleteAlertButton() -> XCUIElement? {
    sleep(1)

    let deleteButton = self.springboard.alerts.buttons[Constants.deleteButton]

    if deleteButton.exists {
      return deleteButton
    }

    return nil
  }

}

Answer 18

答案有很多变体，甚至不确定我是否应该补充，但万一有人需要通用解决方案：

iOS 14.6 和 15 测试版

    class func deleteApp() {
    XCUIApplication().terminate()
    
    // Force delete the app from the springboard
    let icon = springboard.icons["APP_NAME"]
    if icon.exists {
        icon.press(forDuration: 1.3)
        
        springboard.buttons["Remove App"].tap()
        springboard.alerts.buttons["Delete App"].tap()
        springboard.alerts.buttons["Delete"].tap()
        
        // Press home once to make the icons stop wiggling
        XCUIDevice.shared.press(.home)
    }
}