Was macht UI Testing?
Überblick
Warte auf Bedingungen, nicht auf willkürliche Zeitüberschreitungen. Kernprinzip: Flaky Tests entstehen durch Raten, wie lange Operationen dauern. Bedingungsbasiertes Warten eliminiert Wettlaufsituationen.
NEU in WWDC 2025: Recording UI Automation ermöglicht es, Interaktionen aufzuzeichnen, über Geräte/Sprachen hinweg abzuspielen und Videoaufzeichnungen von Testläufen zu überprüfen.
Beispielhafte Prompts
Dies sind echte Fragen von Entwicklern, die diese Skill-Anleitung beantworten soll:
1. „Meine UI-Tests bestehen lokal auf meinem Mac, schlagen aber in CI fehl. Wie mache ich sie zuverlässiger?“
→ Die Anleitung zeigt bedingungsbasierte Wartemuster, die geräte- und geschwindigkeitsunabhängig funktionieren und CI-Zeitunterschiede eliminieren.
2. „Meine Tests verwenden sleep(2) und sleep(5), sind aber immer noch flaky. Wie ersetze ich willkürliche Timeouts durch echte Bedingungen?“
→ Die Anleitung demonstriert waitForExistence, XCTestExpectation und Polling-Muster für Datenladungen, Netzwerkanfragen und Animationen.
3. „Ich habe gerade einen Test mit Xcode 26’s Recording UI Automation aufgezeichnet. Wie überprüfe ich das Video und debugge Fehler?“
→ Die Anleitung behandelt Video-Debugging-Workflows, um Aufzeichnungen zu analysieren und den genauen Schritt zu finden, bei dem Tests fehlschlagen.
4. „Mein Test schlägt auf iPad fehl, besteht aber auf iPhone. Wie schreibe ich Tests, die über alle Gerätegrößen hinweg funktionieren?“
→ Die Anleitung erklärt Multi-Faktor-Testing-Strategien und geräteunabhängige Prädikate für robustes geräteübergreifendes Testen.
5. „Ich möchte Tests schreiben, die nicht flaky sind. Welche kritischen Muster muss ich kennen?“
→ Die Anleitung liefert bedingungsbasierte Wartevorlagen, barrierefreiheitsorientierte Muster und den Entscheidungsbaum für eine zuverlässige Testarchitektur.
Warnsignale – Testzuverlässigkeitsprobleme
Wenn Sie IRGENDEINES davon sehen, vermuten Sie Timing-Probleme:
- Tests bestehen lokal, schlagen in CI fehl (Timing-Unterschiede)
- Tests bestehen manchmal, schlagen manchmal fehl (Wettlaufsituationen)
- Tests verwenden
sleep()oderThread.sleep()(willkürliche Verzögerungen) - Tests schlagen mit „UI-Element nicht gefunden“ fehl, bestehen beim Wiederholen
- Lange Testlaufzeiten (Warten auf Worst-Case-Szenarien)
Schneller Entscheidungsbaum
Test schlägt fehl?
├─ Element nicht gefunden?
│ └─ Verwende waitForExistence(timeout:) nicht sleep()
├─ Besteht lokal, schlägt in CI fehl?
│ └─ Ersetze sleep() durch Bedingungs-Polling
├─ Animation verursacht Probleme?
│ └─ Warte auf Animationsabschluss, deaktiviere nicht
└─ Netzwerkanfrage-Timing?
└─ Verwende XCTestExpectation oder waitForExistence
Kernmuster: Bedingungsbasiertes Warten
❌ FALSCH (Willkürlicher Timeout):
func testButtonAppears() {
app.buttons["Login"].tap()
sleep(2) // ❌ Raten, dass es 2 Sekunden dauert
XCTAssertTrue(app.buttons["Dashboard"].exists)
}
✅ RICHTIG (Auf Bedingung warten):
func testButtonAppears() {
app.buttons["Login"].tap()
let dashboard = app.buttons["Dashboard"]
XCTAssertTrue(dashboard.waitForExistence(timeout: 5))
}
Häufige UI-Testing-Muster
Muster 1: Auf Elemente warten
// Warten, dass ein Element erscheint
func waitForElement(_ element: XCUIElement, timeout: TimeInterval = 5) -> Bool {
return element.waitForExistence(timeout: timeout)
}
// Verwendung
XCTAssertTrue(waitForElement(app.buttons["Submit"]))
Muster 2: Warten, dass ein Element verschwindet
func waitForElementToDisappear(_ element: XCUIElement, timeout: TimeInterval = 5) -> Bool {
let predicate = NSPredicate(format: "exists == false")
let expectation = XCTNSPredicateExpectation(predicate: predicate, object: element)
let result = XCTWaiter().wait(for: [expectation], timeout: timeout)
return result == .completed
}
// Verwendung
XCTAssertTrue(waitForElementToDisappear(app.activityIndicators["Loading"]))
Muster 3: Warten auf einen bestimmten Zustand
func waitForButton(_ button: XCUIElement, toBeEnabled enabled: Bool, timeout: TimeInterval = 5) -> Bool {
let predicate = NSPredicate(format: "isEnabled == %@", NSNumber(value: enabled))
let expectation = XCTNSPredicateExpectation(predicate: predicate, object: button)
let result = XCTWaiter().wait(for: [expectation], timeout: timeout)
return result == .completed
}
// Verwendung
let submitButton = app.buttons["Submit"]
XCTAssertTrue(waitForButton(submitButton, toBeEnabled: true))
submitButton.tap()
Muster 4: Accessibility-Identifiers
In der App setzen:
Button("Submit") {
// Aktion
}
.accessibilityIdentifier("submitButton")
In Tests verwenden:
func testSubmitButton() {
let submitButton = app.buttons["submitButton"] // Verwendet Identifier, nicht Label
XCTAssertTrue(submitButton.waitForExistence(timeout: 5))
submitButton.tap()
}
Warum: Accessibility-Identifiers ändern sich nicht mit der Lokalisierung und bleiben über UI-Updates hinweg stabil.
Muster 5: Netzwerkanfrage-Verzögerungen
func testDataLoads() {
app.buttons["Refresh"].tap()
// Warten, dass Ladeindikator verschwindet
let loadingIndicator = app.activityIndicators["Loading"]
XCTAssertTrue(waitForElementToDisappear(loadingIndicator, timeout: 10))
// Jetzt überprüfen, ob Daten geladen wurden
XCTAssertTrue(app.cells.count > 0)
}
Muster 6: Animationsbehandlung
func testAnimatedTransition() {
app.buttons["Next"].tap()
// Warten, dass die Zielansicht erscheint
let destinationView = app.otherElements["DestinationView"]
XCTAssertTrue(destinationView.waitForExistence(timeout: 2))
// Optional: Etwas länger warten, bis die Animation abgeschlossen ist
// Nur wenn absolut notwendig
RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.3))
}
Test-Checkliste
Bevor Sie Tests schreiben
- Accessibility-Identifiers für alle interaktiven Elemente verwenden
- Hartcodierte Labels vermeiden (stattdessen Identifiers verwenden)
- Netzwerkverzögerungen und Animationen einplanen
- Angemessene Timeouts wählen (2s UI, 10s Netzwerk)
Beim Schreiben von Tests
-
waitForExistence()stattsleep()verwenden - Prädikate für komplexe Bedingungen verwenden
- Sowohl Erfolgs- als auch Fehlerpfade testen
- Tests unabhängig machen (in beliebiger Reihenfolge ausführbar)
Nach dem Schreiben von Tests
- Tests 10x lokal ausführen (Flakiness erkennen)
- Tests auf dem langsamsten unterstützten Gerät ausführen
- Tests in CI-Umgebung ausführen
- Testdauer prüfen (bei >30s pro Test optimieren)
Xcode UI Testing Tipps
Launch-Argumente für Tests
func testExample() {
let app = XCUIApplication()
app.launchArguments = ["UI-Testing"]
app.launch()
}
Im App-Code:
if ProcessInfo.processInfo.arguments.contains("UI-Testing") {
// Mock-Daten verwenden, Onboarding überspringen, etc.
}
Schnellere Testausführung
override func setUpWithError() throws {
continueAfterFailure = false // Beim ersten Fehler stoppen
}
Fehlschlagende Tests debuggen
func testExample() {
// Screenshot bei Fehler machen
addUIInterruptionMonitor(withDescription: "Alert") { alert in
alert.buttons["OK"].tap()
return true
}
// Elementhierarchie ausgeben
print(app.debugDescription)
}
Häufige Fehler
❌ sleep() für alles verwenden
sleep(5) // ❌ Zeitverschwendung, wenn Vorgang in 1s abgeschlossen ist
❌ Animationen nicht behandeln
app.buttons["Next"].tap()
XCTAssertTrue(app.buttons["Back"].exists) // ❌ Kann während Animation fehlschlagen
❌ Hartcodierte Textlabels
app.buttons["Submit"].tap() // ❌ Bricht mit Lokalisierung
❌ Tests sind voneinander abhängig
// ❌ Test 2 geht davon aus, dass Test 1 zuerst lief
func test1_Login() { /* ... */ }
func test2_ViewDashboard() { /* geht von eingeloggtem Zustand aus */ }
❌ Keine Timeout-Strategie
element.waitForExistence(timeout: 100) // ❌ Zu lang
element.waitForExistence(timeout: 0.1) // ❌ Zu kurz
Angemessene Timeouts verwenden:
- UI-Animationen: 2-3 Sekunden
- Netzwerkanfragen: 10 Sekunden
- Komplexe Vorgänge: maximal 30 Sekunden
Praxisrelevante Auswirkungen
Vorher (mit sleep()):
- Test-Suite: 15 Minuten (Warten auf Worst-Case)
- Flaky Tests: 20% Fehlerrate
- CI-Fehlschläge: 50% erfordern Wiederholung
Nachher (bedingungsbasiertes Warten):
- Test-Suite: 5 Minuten (wartet nur bei Bedarf)
- Flaky Tests: <2% Fehlerrate
- CI-Fehlschläge: <5% erfordern Wiederholung
Kernerkenntnis: Tests werden schneller abgeschlossen UND sind zuverlässiger, wenn auf tatsächliche Bedingungen gewartet wird, anstatt Zeiten zu raten.
Recording UI Automation
Überblick
NEU in Xcode 26: Aufzeichnen, abspielen und überprüfen von UI-Automation-Tests mit Videoaufzeichnungen.
Drei Phasen:
- Aufzeichnen – Interaktionen (Tippen, Wischen, Hardware-Tastendrücke) als Swift-Code erfassen
- Abspielen – Auf mehreren Geräten, Sprachen, Regionen, Ausrichtungen ausführen
- Überprüfen – Videoaufzeichnungen ansehen, Fehler analysieren, UI-Element-Overlays anzeigen
Unterstützte Plattformen: iOS, iPadOS, macOS, watchOS, tvOS, axiom-visionOS (Designed for iPad)
Wie UI-Automation funktioniert
Schlüsselprinzipien:
- UI-Automation interagiert mit Ihrer App wie ein Mensch mit Gesten und Hardware-Ereignissen
- Läuft völlig unabhängig von Ihrer App (App-Modelle/Daten sind nicht direkt zugänglich)
- Nutzt das Accessibility-Framework als zugrunde liegende Technologie
- Teilt dem Betriebssystem mit, welche Gesten ausgeführt werden sollen, und wartet dann synchron eine nach der anderen auf deren Abschluss
Aktionen umfassen:
- Starten Ihrer App
- Interaktion mit Buttons und Navigation
- Systemzustand setzen (Dark Mode, axiom-localization, etc.)
- Simulierten Standort setzen
Accessibility ist die Grundlage
Wichtiges Verständnis: Accessibility stellt Informationen direkt für die UI-Automation bereit.
Was Accessibility sieht:
- Elementtypen (Button, Text, Bild, etc.)
- Labels (sichtbarer Text)
- Werte (aktueller Zustand für Checkboxen, etc.)
- Rahmen (Elementpositionen)
- Identifiers (Accessibility-Identifiers – NICHT lokalisiert)
Best Practice: Eine gute Accessibility-Erfahrung = eine gute UI-Automation-Erfahrung.
Ihre App für die Aufzeichnung vorbereiten
Schritt 1: Accessibility-Identifiers hinzufügen
SwiftUI:
Button("Submit") {
// Aktion
}
.accessibilityIdentifier("submitButton")
// Identifiers instanzspezifisch machen
List(landmarks) { landmark in
LandmarkRow(landmark)
.accessibilityIdentifier("landmark-\(landmark.id)")
}
UIKit:
let button = UIButton()
button.accessibilityIdentifier = "submitButton"
// Index für Tabellenzellen verwenden
cell.accessibilityIdentifier = "cell-\(indexPath.row)"
Gute Identifiers sind:
- ✅ Eindeutig innerhalb der gesamten App
- ✅ Beschreibend für den Elementinhalt
- ✅ Statisch (reagieren nicht auf Inhaltsänderungen)
- ✅ Nicht lokalisiert (gleich in allen Sprachen)
Warum Identifiers wichtig sind:
- Titel/Beschreibungen können sich ändern, Identifiers bleiben stabil
- Funktionieren über lokalisierte Zeichenfolgen hinweg
- Identifizieren Elemente mit dynamischem Inhalt eindeutig
Pro-Tipp: Verwenden Sie den Xcode-Coding-Assistant zum Hinzufügen von Identifiers:
Prompt: „Füge Accessibility-Identifiers zu den relevanten Teilen dieser Ansicht hinzu“
Schritt 2: Accessibility mit dem Accessibility Inspector prüfen
Accessibility Inspector starten:
- Xcode-Menü → Entwickler-Tool öffnen → Accessibility Inspector
- Oder: Über Spotlight starten
Funktionen:
- Element Inspector – Accessibility-Werte für jede Ansicht auflisten
- Eigenschaftsdetails – Auf Eigenschaftsnamen klicken für Dokumentation
- Plattformunterstützung – Funktioniert auf allen Apple-Plattformen
Was zu prüfen ist:
- Elemente haben Labels
- Interaktive Elemente haben Typen (Button, nicht nur Text)
- Werte für zustandsbehaftete Elemente festgelegt (Checkboxen, Toggles)
- Identifiers für Elemente mit dynamischem/lokalisiertem Inhalt festgelegt
Beispielcode-Referenz: Delivering an exceptional accessibility experience
Schritt 3: UI-Testing-Target hinzufügen
- Projekteinstellungen in Xcode öffnen
- „+" unterhalb der Target-Liste klicken
- UI Testing Bundle auswählen
- Auf „Fertig“ klicken
Ergebnis: Neuer UI-Testordner mit Vorlagentests wird zum Projekt hinzugefügt.
Interaktionen aufzeichnen
Aufzeichnung starten (Xcode 26)
- UI-Testquellcodedatei öffnen
- Popover erscheint mit Erklärung, wie die Aufzeichnung gestartet wird (nur beim ersten Mal)
- Auf die Schaltfläche „Aufzeichnung starten“ im Editor-Gutter klicken
- Xcode erstellt und startet die App im Simulator/Gerät
Während der Aufzeichnung:
- Normal mit der App interagieren (Tippen, Wischen, Texteingabe, etc.)
- Code, der die Interaktionen darstellt, erscheint in Echtzeit im Quelleditor
- Die Aufzeichnung wird während der Eingabe aktualisiert (z. B. Texteingaben in Feldern)
Aufzeichnung beenden:
- Auf die Schaltfläche „Run stoppen“ in Xcode klicken
Beispiel einer Aufzeichnungssitzung
func testCreateAustralianCollection() {
let app = XCUIApplication()
app.launch()
// Auf „Collections“-Tab tippen (automatisch aufgezeichnet)
app.tabBars.buttons["Collections"].tap()
// Auf „+" tippen, um neue Sammlung hinzuzufügen
app.navigationBars.buttons["Add"].tap()
// Auf „Edit“-Button tippen
app.buttons["Edit"].tap()
// Sammlungsnamen eingeben
app.textFields.firstMatch.tap()
app.textFields.firstMatch.typeText("Max's Australian Adventure")
// Auf „Edit Landmarks" tippen
app.buttons["Edit Landmarks"].tap()
// Sehenswürdigkeiten hinzufügen
app.tables.cells.containing(.staticText, identifier:"Great Barrier Reef").buttons["Add"].tap()
app.tables.cells.containing(.staticText, identifier:"Uluru").buttons["Add"].tap()
// Auf Häkchen tippen, um zu speichern
app.navigationBars.buttons["Done"].tap()
}
Aufgezeichneten Code überprüfen
Nach der Aufzeichnung Abfragen überprüfen und anpassen:
Mehrere Optionen: Jede Zeile hat ein Dropdown mit alternativen Möglichkeiten, das Element anzusprechen.
Auswahl-Empfehlungen:
- Für lokalisierte Zeichenfolgen (Text, Button-Labels): Accessibility-Identifier wählen, falls verfügbar
- Für tief verschachtelte Ansichten: Kürzeste Abfrage wählen (bleibt stabil, wenn sich die App ändert)
- Für dynamische Inhalte (Zeitstempel, Temperatur): Generische Abfrage oder Identifier verwenden
Beispiel:
// Aufgezeichnete Optionen für Textfeld:
app.textFields["Collection Name"] // ❌ Bricht, wenn Label lokalisiert wird
app.textFields["collectionNameField"] // ✅ Verwendet Identifier
app.textFields.element(boundBy: 0) // ✅ Positionsbasiert
app.textFields.firstMatch // ✅ Generisch, am kürzesten
Aufgezeichnete Tests abspielen
Test auf einem einzelnen Gerät ausführen
Methode 1 – In der Gutter-Leiste:
- Klicken Sie auf die Schaltfläche „Ausführen“ neben der Testfunktion oder -klasse
Methode 2 – Test Navigator:
- Befehl + 6
- Mit der rechten Maustaste auf den Test klicken → „Test ausführen“
Methode 3 – Produktmenü:
- Produkt → Test ausführen (Befehl + U)
Test auf mehreren Geräten ausführen
Lokales Testen:
- Wählen Sie im Xcode-Schema-Menü ein anderes Ziel aus
- Führen Sie den Test auf diesem Ziel aus
- Wiederholen Sie dies für jedes Ziel
Cloud-Testing-Optionen (von Drittanbietern):
- Firebase Test Lab
- Sauce Labs
- BrowserStack
- AWS Device Farm
- Weitere: developer.apple.com
Test auf mehreren Sprachen ausführen
Xcode 16+: Schema bearbeiten → Test → Optionen → „Sprache“-Dropdown im Abschnitt „App-Sprache“
Vor Xcode 16: Launch-Argumente:
app.launchArguments += ["-AppleLanguages", "(de)", "-AppleLocale", "de_DE"]
Hinweis: Das Testen mehrerer Sprachen validiert die Verwendung von Accessibility-Identifiers – wenn app.buttons["submitButton"] in allen Sprachen funktioniert, sind Ihre Identifiers korrekt.
Testfehler überprüfen
Videoaufzeichnungen durchsuchen
Standard-Video-Overlay:
- Hauptfenster: Zeigt die Aufzeichnung der Testausführung
- Suchleiste (unten): Ziehen oder klicken Sie, um durch das Video zu navigieren
- Steuerelemente (unten): Abspielen/Pause, Geschwindigkeit (1x, 2x, 4x, 8x), Beenden
Erweitertes Video-Overlay (nur im Fehlerfall):
- Hauptfenster: Wie oben, Video der Testausführung
- Videomarkierungen: Rote Linien an jedem erkannten Fehler
- Fehlerliste (rechts): Liste der Fehler mit Schritten und Screenshots
- Navigationssteuerelemente: „Fehler überspringen“ (vorheriger/nächster Fehler), ausgewähltes Element hervorheben
Fehleranalyse-Workflow
Im erweiterten Overlay-Fenster:
Option 1: Fehler in der Liste überprüfen:
- Jeder Fehler hat einen zusammenfassenden Text
- Jeder Fehler hat einen Screenshot zum genauen Zeitpunkt des Fehlers
- Fehler können als „behoben“ markiert werden, um sie aus der Liste auszublenden
Option 2: Fehler im Video überprüfen:
- Rote Linien zeigen an, wo Fehler aufgetreten sind
- Ziehen Sie die Suchleiste, um die App zu einem bestimmten Punkt neu zu zeichnen
- Verwenden Sie die Suchleistensteuerelemente, um die App an einem bestimmten Frame anzuzeigen
Option 3: Ausgewähltes Element anzeigen:
- Wählen Sie einen Fehler oder ein UI-Element in der Liste aus
- Das Element wird im Video-Overlay rot hervorgehoben
Barrierefreiheitstests
Warum Barrierefreiheit wichtig ist:
- Zur Einhaltung gesetzlicher Anforderungen und Richtlinien (z. B. WCAG)
- Für inklusives Design – stellt sicher, dass Ihre App von Menschen mit Behinderungen genutzt werden kann
Was zu testen ist:
- VoiceOver-Navigation: Kann ein Benutzer durch Ihre App navigieren, indem er Accessibility-Elemente verwendet?
- Tastaturzugänglichkeit: Kann auf macOS/Tastatur vollständig über die Tastatur auf alle Elemente zugegriffen werden?
- Dynamic Type: Passt sich der Text an die Einstellungen für Dynamic Type an?
- Farbkontrast: Sind Farbkontraste für sehbehinderte Benutzer ausreichend?
So testen Sie mit UI-Automation:
Barrierefreiheits-Identifiers validieren:
func testAccessibilityIdentifiers() {
let app = XCUIApplication()
app.launch()
// Prüfen, ob wichtige Elemente Identifiers haben
XCTAssertTrue(app.buttons["submitButton"].exists)
XCTAssertTrue(app.textFields["emailField"].exists)
XCTAssertTrue(app.buttons["cancelButton"].exists)
}
VoiceOver-Interaktionen testen:
func testVoiceOverNavigation() {
let app = XCUIApplication()
app.launch()
// VoiceOver-Gesten simulieren
app.swipeRight() // Zum nächsten Element
app.swipeLeft() // Zum vorherigen Element
app.doubleTap() // Element aktivieren
}
Pro-Tipps:
- Verwenden Sie die Accessibility-API, um das VoiceOver-Rotor-Verhalten zu testen
- Testen Sie mit verschiedenen Dynamic-Type-Größen
- Validieren Sie, dass alle interaktiven Elemente fokussierbar sind
Häufige Fallstricke bei Recording
❌ Identifiers verwenden sich ändernde Werte
// Schlecht – enthält dynamischen Wert
cell.accessibilityIdentifier = "cell-date-\(Date())"
// Gut – statischer Identifier
cell.accessibilityIdentifier = "cell-date"
❌ Abfragen sind zu spezifisch
// Schlecht – bricht bei Layoutänderungen
app.buttons.element(boundBy: 2).tap()
// Gut – beschreibende Abfrage
app.buttons["submitButton"].tap()
❌ Test ist an ein Gerät gebunden
// Schlecht – nimmt bestimmte Gerätegröße an
XCTAssertEqual(app.buttons["submitButton"].frame.width, 100)
// Gut – testet Vorhandensein, nicht Größe
XCTAssertTrue(app.buttons["submitButton"].exists)
❌ Keine Behandlung von Systemdialogen
// Schlecht – geht davon aus, dass kein Dialog kommt
app.buttons["Allow"].tap()
// Gut – behandelt Dialog
addUIInterruptionMonitor(withDescription: "Berechtigung") { alert in
alert.buttons["Erlauben"].tap()
return true
}
app.buttons["Standort anfordern"].tap()
app.tap() // Erforderlich, um Interruptionsmonitor auszulösen
Leistung der Aufzeichnung optimieren
Debug-Navigator für UI-Tests:
- Öffnen: Befehl + 7
- Wählen Sie den Test aus, den Sie ausführen möchten
- Verwenden Sie das Zeitleisten-Panel zum Anzeigen von:
- Testausführungszeit
- Speichernutzung
- CPU-Auslastung
Optimierungstipps:
- Reduzieren Sie die Anzahl der Screenshots während des Tests
- Verwenden Sie kürzere Timeouts, wo es sinnvoll ist
- Vermeiden Sie unnötige Wartezeiten zwischen Aktionen
- Testen Sie auf der langsamsten unterstützten Hardware für Realitätsnähe
Referenz: XCTest-Funktionen
| Funktion | Zweck | Beispiel |
|---|---|---|
waitForExistence(timeout:) | Auf das Erscheinen eines Elements warten | button.waitForExistence(timeout: 5) |
XCTNSPredicateExpectation(predicate:object:) | Auf eine Bedingung warten | NSPredicate(format: "exists == false") |
XCTWaiter().wait(for:timeout:) | Mehrere Erwartungen erfüllen | XCTWaiter().wait(for: [exp], timeout: 5) |
addUIInterruptionMonitor(withDescription:handler:) | Systemdialoge behandeln | alert.buttons["OK"].tap() |
XCTContext.runActivity(named:block:) | Testausgabe organisieren | XCTContext.runActivity("Schritt 1") { ... } |
Schnellstart-Vorlage
import XCTest
class MyAppUITests: XCTestCase {
let app = XCUIApplication()
override func setUpWithError() throws {
continueAfterFailure = false
app.launchArguments = ["UI-Testing"]
app.launch()
}
func testButtonTap() throws {
let button = app.buttons["myButton"]
XCTAssertTrue(button.waitForExistence(timeout: 5))
button.tap()
// Ergebnis bestätigen
let resultLabel = app.staticTexts["result"]
XCTAssertTrue(resultLabel.exists)
}
func testAsyncOperation() throws {
app.buttons["LoadData"].tap()
let loading = app.activityIndicators["loading"]
let finished = NSPredicate(format: "exists == false")
let expectation = XCTNSPredicateExpectation(predicate: finished, object: loading)
let result = XCTWaiter().wait(for: [expectation], timeout: 10)
XCTAssertEqual(result, .completed)
}
}