FREE · REPRODUCIBLE STARTER

Test what survives a transition.

Keep a draft, selection and primary action intact as the available space changes. Start with a disposable fixture, then adapt the assertions to your app.

Four files. One concrete workflow.

The pack contains a SwiftUI example, a navigation-state UI test, a human-assisted display-transition test, and a CSV evidence matrix. It also works as a starting point for iPad resizing.

TransitionFixture.swift AdaptiveTransitionTests.swift transition-matrix.csv README.txt

View or copy the pack if downloads are unavailable

TransitionFixture.swift

import SwiftUI

// Add this view to a disposable sample app. This is not a test of your production app.
struct TransitionFixture: View {
    @State private var draft = ""
    @State private var selection = "None"
    @State private var confirmed = false

    var body: some View {
        NavigationStack {
            ScrollView {
                VStack(alignment: .leading, spacing: 20) {
                    Text("Transition fixture").font(.title)
                    Text("Type a draft, select an item, then change the available space.")
                    TextField("Draft", text: $draft)
                        .textFieldStyle(.roundedBorder)
                        .accessibilityIdentifier("draftField")
                    Button("Select item A") { selection = "Item A" }
                        .accessibilityIdentifier("selectItem")
                    Text(selection).accessibilityIdentifier("selectionValue")
                    NavigationLink("Open details") {
                        Text("Use the system Back button to return to your draft.")
                            .navigationTitle("Details")
                    }.accessibilityIdentifier("openDetails")
                    Button("Confirm transition review") { confirmed = true }
                        .accessibilityIdentifier("confirmTransition")
                    if confirmed {
                        Text("Transition confirmed").accessibilityIdentifier("transitionConfirmation")
                    }
                    Button("Submit draft") { }
                        .accessibilityIdentifier("primaryAction")
                }
                .padding()
                .frame(maxWidth: .infinity, alignment: .leading)
            }
            .navigationTitle("Draft")
        }
    }
}

AdaptiveTransitionTests.swift

import XCTest

// Add to an existing UI-test target. Replace identifiers to exercise your app.
// Run each configured destination/locale/text size separately; these tests do not
// programmatically change Duo pose and cannot certify a full transition matrix.
final class AdaptiveTransitionTests: XCTestCase {
    override func setUpWithError() throws { continueAfterFailure = false }

    func testDraftSurvivesNavigation() throws {
        let app = XCUIApplication()
        app.launch()
        let draft = app.textFields["draftField"]
        XCTAssertTrue(draft.waitForExistence(timeout: 10))
        draft.tap()
        draft.typeText("Draft survives navigation")
        app.buttons["selectItem"].tap()
        app.buttons["openDetails"].tap()
        app.navigationBars["Details"].buttons.element(boundBy: 0).tap()
        XCTAssertEqual(draft.value as? String, "Draft survives navigation")
        XCTAssertEqual(app.staticTexts["selectionValue"].label, "Item A")
        let attachment = XCTAttachment(screenshot: app.screenshot())
        attachment.lifetime = .keepAlways
        add(attachment)
    }

    func testDraftAfterHumanAssistedDisplayTransition() throws {
        let app = XCUIApplication()
        app.launch()
        let draft = app.textFields["draftField"]
        XCTAssertTrue(draft.waitForExistence(timeout: 10))
        draft.tap()
        draft.typeText("Draft survives display transition")
        app.buttons["selectItem"].tap()
        // During this wait, use Device Hub to perform ONE recorded pose/resize
        // transition, inspect keyboard and controls, then tap Confirm transition review.
        // Capture the exact transition in the matrix; confirmation is human supplied.
        XCTAssertTrue(app.staticTexts["transitionConfirmation"].waitForExistence(timeout: 120),
                      "Perform and confirm the recorded transition within 120 seconds.")
        XCTAssertEqual(draft.value as? String, "Draft survives display transition")
        XCTAssertEqual(app.staticTexts["selectionValue"].label, "Item A")
        for _ in 0..<3 {
            if app.buttons["primaryAction"].isHittable { break }
            app.swipeUp()
        }
        XCTAssertTrue(app.buttons["primaryAction"].isHittable)
        let attachment = XCTAttachment(screenshot: app.screenshot())
        attachment.lifetime = .keepAlways
        add(attachment)
    }
}

transition-matrix.csv

case,commit,xcode_build,runtime,destination,start_state,transition,text_size,locale,expected,observed,status,artifact
draft-outer-inner,,,,,draft with keyboard,outer to inner,default,en,draft and selection preserved,,not_run,
draft-inner-outer,,,,,draft with keyboard,inner to outer,default,en,draft and selection preserved,,not_run,
split-left,,,,,selected item,enter left Split View,default,en,selection and controls reachable,,not_run,
split-right,,,,,selected item,enter right Split View,default,en,selection and asymmetric insets respected,,not_run,
large-text,,,,,form open,resize to narrow,largest accessibility,en,text and primary action reachable,,not_run,
rtl,,,,,form open,resize to narrow,default,ar,leading trailing layout and draft preserved,,not_run,
navigation,,,,,draft and selected item,details then back,default,en,draft and selection preserved,,not_run,

README.txt

# DuoReady adaptive transition starter pack

Status: example source and recommendations, NOT executed or compiled on macOS by DuoReady.

1. Create a disposable SwiftUI iOS sample app in Xcode with a UI-test target. Set its root view to TransitionFixture(). The fixture requires iOS 16 or newer.
2. Add TransitionFixture.swift to the app target and AdaptiveTransitionTests.swift to its UI-test target. Build locally and resolve any differences in your Xcode/runtime's accessibility element representation.
3. Run testDraftSurvivesNavigation. It checks state in the fixture, not your app.
4. Run testDraftAfterHumanAssistedDisplayTransition interactively. During its 120-second wait, perform one transition using Device Hub and tap Confirm transition review. This is a human-assisted test, not automated pose control. Do not run this test unattended.
5. Adapt the flow, identifiers and assertions to your own app. Add automatic UI tests for the journeys you can reproduce. Configure supported languages and text sizes in Xcode's test-plan editor, then repeat on the actual destinations installed on your Mac.
6. Fill transition-matrix.csv with the exact source commit, Xcode build, runtime, destination, starting pose and transition. Mark blocked/unavailable cases skipped, with a reason; never convert skipped cases into passes.
7. Inspect screenshots for clipping, asymmetric safe areas, keyboard coverage and meaningful RTL behavior. isHittable and screenshots alone do not prove visual correctness, accessibility or a transition actually occurred.
8. Keep xcresult and screenshots private. The current DuoReady Mac runner can import a suite summary at the matching commit; it does not attest individual matrix rows or execute these examples for you.

For iPad/resizable Apple UI, use the same assertions with supported window changes. Camera optics, real display timing and hardware behavior require device evidence.

Sources:
https://developer.apple.com/videos/play/tech-talks/111461/
https://developer.apple.com/documentation/xcode/organizing-tests-to-improve-feedback
https://developer.apple.com/documentation/xctest/xcuiapplication

Example source has not been compiled or run on a Mac by DuoReady. The display-transition example requires a person to change the pose and confirm it; it is unsuitable for unattended CI. No test is marked passed by downloading this pack.

Draft & selection

Enter text and select an item. Navigate away and back; verify both values.

Transition & keyboard

Record one outer/inner or Split View transition with the keyboard open. Check state and access to actions.

Text & localization

Repeat at accessibility text sizes and supported right-to-left locales. Record failures and skipped cases separately.

Turn results into release history.

Save a source baseline in the workspace, compare the next commit, and import matching Mac suite evidence. Individual matrix rows remain separate from suite summaries.

Open the workspace Mac runner setup Simulator checklist