import Foundation import ParcelConfig import RealityDriverSupport import Testing @testable import ParcelRealityTests extension RealityOracleTests { @Test(arguments: ["missing", "version", "limit", "negative", "overflow", "valid"]) func frameFittingRequiresBoundedVersionedReceipt(_ condition: String) throws { let json = condition == "missing" ? "{}" : "{\"frame_write\":{\"schemaVersion\":\(condition == "version" ? 2 : 1),\"setterCount\":\(condition == "negative" ? -1 : condition == "overflow" ? 9 : 8),\"setterLimit\":\(condition == "limit" ? 9 : 8),\"limitReached\":true}}" let receipt = try JSONDecoder().decode(RealityFrameWriteReceipt.self, from: Data(json.utf8)) if condition == "valid" { try receipt.requireBounded() } else { #expect(throws: RealityError.self) { try receipt.requireBounded() } } } @Test(arguments: ["bad-display", "bad-space", "valid"]) func settingsBridgeRequiresExactNativeWorkspaceIdentity(_ condition: String) throws { let display = UUID().uuidString let identity = SettingsRealityWorkspace( display: condition == "bad-display" ? "unknown" : display, space: condition == "bad-space" ? "unknown" : "42") if condition == "valid" { let key = try identity.key() #expect(key.display.rawValue == display && key.space.rawValue == 42) } else { #expect(throws: RealityError.self) { try identity.key() } } #expect(RealityScenario.supported.contains { $0.name == "settings-main-size" }) } @Test(arguments: [false, true]) func explicitlyRequestedSupportedSkipsFail(explicit: Bool) { let scenario = RealityScenario(name: "phantom-gap", feature: "") #expect(scenario.skipStatus(explicitlyRequested: explicit) == (explicit ? .fail : .skip)) } @Test(arguments: [ ("Expected FixtureApp pass-through was intercepted", true), ("Expected FixtureApp pass-through was intercepted; native events=[]", true), ("Other failure: Expected FixtureApp pass-through was intercepted", false), ("Expected FixtureApp pass-through was interceptedSomethingElse", false), ("Driver omitted its owned target receipt", false), ]) func onlyExactNativeInterceptionSignalsHaveTheSpecializedType(message: String, intercepted: Bool) { #expect((RealityFixturePassThroughInterception.fromMessage(message) != nil) == intercepted) } @Test(arguments: [false, true]) func onlyTheDeclaredShortcutDeliveryRequirementCanSkipThatHost(explicit: Bool) { let shortcut = RealityScenario(name: "shortcuts-off", feature: "") #expect( shortcut.skipStatus( explicitlyRequested: explicit, unsupportedHostRequirement: .defaultShortcutDelivery) == .unsupportedHost) #expect( RealityScenario(name: "phantom-gap", feature: "").skipStatus( explicitlyRequested: explicit, unsupportedHostRequirement: .defaultShortcutDelivery) == .fail) #expect(RealityScenario.supported.contains { $0.name == "shortcuts-off" }) } @Test(arguments: [false, true]) func editorAdapterOwnershipLimitationRemainsVisibleWithoutClaimingAProductPass(explicit: Bool) throws { let editor = try #require(RealityScenario.selected(named: "app-vscode").first) let unsupported = try #require(editor.unsupportedActuatorRequirement) #expect(unsupported.requirement == .editorLaunchDate) #expect( editor.skipStatus(explicitlyRequested: explicit, unsupportedHostRequirement: unsupported.requirement) == .unsupportedHost) #expect(RealityScenario.selected(named: nil).contains { $0.name == editor.name }) #expect(RealityScenario(name: "app-chromium", feature: "").unsupportedActuatorRequirement == nil) #expect( RealityScenario(name: "mixed-app-churn", feature: "").skipStatus( explicitlyRequested: explicit, unsupportedHostRequirement: unsupported.requirement) == .fail) } @Test(arguments: ["native-tabs", "secure-input-pause"]) func declaredUnsupportedRowsStayOutOfDefaults(_ name: String) { #expect(!RealityScenario.selected(named: nil).contains { $0.name == name }) let explicit = RealityScenario.selected(named: name) #expect(explicit.count == 1) #expect(explicit.first?.skipStatus(explicitlyRequested: true) == .skip) } @Test( arguments: [false, true], [ "displays", "display-full-swap", "display-full-stack", "spaces", "voiceover-shortcuts", "tab-view-voiceover", "no-peek", "clean-space", ]) func environmentalRequirementsAreUnsupportedForDefaultAndExplicitRuns(explicit: Bool, name: String) throws { let scenario = try #require(RealityScenario.selected(named: name).first) #expect(scenario.skipStatus(explicitlyRequested: explicit) == .unsupportedHost) #expect( !RealityLaneDecision.afterScenario( failures: [RealitySkip("Required hardware or opt-in is unavailable")], cleanupFailed: false ).stopsLane) } @Test func unsupportedHostIsDistinctFromFailureAndNotRunInJSONAndMarkdown() throws { let results = [ RealityResult( scenario: "displays", feature: "Displays", status: .unsupportedHost, evidence: "Two displays required", artifactPath: "/private/run/displays"), RealityResult( scenario: "launch", feature: "Launch", status: .pass, evidence: "Real frames converged", artifactPath: "/private/run/launch"), ] let data = try JSONEncoder().encode(results) let decoded = try JSONDecoder().decode([RealityResult].self, from: data) #expect(decoded.map(\.status) == [.unsupportedHost, .pass]) #expect(String(decoding: data, as: UTF8.self).contains("unsupported-host")) let report = RealityMain.markdown(decoded, root: "/private/run") #expect(report.contains("1 pass, 0 fail, 0 skip, 1 unsupported-host")) #expect(report.contains("| unsupported-host | Two displays required")) } @Test(arguments: ["token", "pid", "windowID"]) func droppedDestroyRequiresExactProductReceipt(_ field: String) { let receipt = DroppedDestroyReceipt( token: field == "token" ? "foreign" : "owned", pid: field == "pid" ? 99 : 42, windowID: field == "windowID" ? 999 : 123) #expect(throws: RealityError.self) { try receipt.requireMatch(token: "owned", window: OwnedWindow(app: .textEdit, pid: 42, id: 123)) } } @Test func droppedDestroyReceiptAcceptsOnlyTheClosedNativeIdentity() throws { let receipt = try JSONDecoder().decode( DroppedDestroyReceipt.self, from: Data(#"{"token":"owned","pid":42,"windowID":123}"#.utf8)) try receipt.requireMatch(token: "owned", window: OwnedWindow(app: .textEdit, pid: 42, id: 123)) #expect(throws: DecodingError.self) { try JSONDecoder().decode(DroppedDestroyReceipt.self, from: Data(#"{"token":"owned","pid":42}"#.utf8)) } } @Test(arguments: ["partial", "overlap", "gap", "missing", "invalid"]) func phantomRepairRejectsGrowthWithoutExactTiling(_ failure: String) { let visible = ScreenRect(x: 0, y: 38, width: 1512, height: 886) let gaps = LayoutGaps(inner: 18, outer: 22) var frames = ConfigReloadGeometry(outerGap: gaps.outer, reservedTop: 0, innerGap: gaps.inner) .columns(count: 2, visible: visible) #expect(CoverageOracle.repairedGap(frames, visible: visible, gaps: gaps)) switch failure { case "partial": frames[1].width -= 100 case "overlap": frames[1].x -= 30; frames[1].width += 30 case "gap": frames[0].width -= 20 case "missing": frames.removeLast() case "invalid": frames[0].width = .nan default: preconditionFailure("Unknown phantom regression") } #expect(!CoverageOracle.repairedGap(frames, visible: visible, gaps: gaps)) } @Test func capacityOraclesUseConfiguredNondefaultGaps() throws { let visible = ScreenRect(x: -1600, y: 38, width: 1600, height: 900) let gaps = LayoutGaps(inner: 18, outer: 22) let frames = ConfigReloadGeometry(outerGap: gaps.outer, reservedTop: 0, innerGap: gaps.inner) .columns(count: 2, visible: visible) #expect( CoverageOracle.stacked([frames[0], frames[1], frames[1]], counts: [1, 2], visible: visible, gaps: gaps)) #expect(!CoverageOracle.stacked([frames[0], frames[1], frames[1]], counts: [1, 2], visible: visible)) let geometry = try MinimumStackGeometry(minimumWidths: [500, 500, 500], screen: visible, gaps: gaps) #expect(geometry.gaps == gaps) } @Test func configReloadAllowsOnePointRoundingButNoTwoPointDrift() { let geometry = ConfigReloadGeometry(outerGap: 22, reservedTop: 14, innerGap: 18) let targets = geometry.columns(count: 2, visible: ScreenRect(x: 0.5, y: 38.5, width: 1600, height: 900)) var frames = targets frames[0].x += 1 let increment = ResizeIncrement(width: 7, height: 14, source: "test") #expect(geometry.matches(frames, targets: targets, increment: increment)) frames[0].x += 1 #expect(!geometry.matches(frames, targets: targets, increment: increment)) } @Test func coverageRegistryKeepsAllNineRowsAndReportsUnsupportedActuators() { let names = [ "phantom-gap", "native-tabs", "app-minimum-stack", "float-when-full", "modifier-stack-drag", "edge-resize", "clean-space-sleep", "secure-input-pause", "shortcuts-off", ] for name in names { #expect(RealityScenario.all.filter { $0.name == name }.count == 1) } #expect(Set(RealityScenario.all.map(\.name)).count == RealityScenario.all.count) let blocked = RealityScenario.all.filter { $0.coverageBlocker != nil } #expect( Set(blocked.map(\.name)) == [ "native-tabs", "secure-input-pause", "tour-native-manual", "tour-native-replay-on", "tour-native-replay-off", ]) #expect(blocked.allSatisfy { $0.coverageBlocker?.isEmpty == false }) #expect(RealityScenario(name: "clean-space-sleep", feature: "").coverageBlocker == nil) } @Test(arguments: [[1, 2], [2, 1]]) func stackingUsesRealFrameGroupsNotWindowCount(_ counts: [Int]) { let screen = ScreenRect(x: -1600, y: 38, width: 1600, height: 900) let frames = FrameOracle.stripes(count: 2, visible: screen, vertical: true) #expect(CoverageOracle.stacked([frames[0], frames[1], frames[1]], counts: counts, visible: screen)) #expect(!CoverageOracle.stacked([frames[0], frames[1], frames[1]], counts: [3], visible: screen)) #expect(!CoverageOracle.stacked(frames, counts: counts, visible: screen)) #expect(!CoverageOracle.stacked([frames[0], frames[0], frames[0]], counts: counts, visible: screen)) } @Test(arguments: ["gap", "overflow", "undersized", "invalid", "empty"]) func stackOracleRejectsIncorrectSharedGeometry(_ failure: String) { let screen = ScreenRect(x: 0, y: 38, width: 1600, height: 900) let target = FrameOracle.stripes(count: 2, visible: screen, vertical: true) var frames = [target[0], target[1], target[1]] switch failure { case "gap": frames[2].x += 5 case "overflow": frames[0].x -= 1 case "undersized": frames[1].height -= 40; frames[2] = frames[1] case "invalid": frames[2].width = .nan case "empty": frames = [] default: preconditionFailure("Unknown coverage regression") } #expect(!CoverageOracle.stacked(frames, counts: [1, 2], visible: screen)) } @Test func stackDragRequiresOneFullSizeTileRatherThanAnExchange() { let screen = ScreenRect(x: 0, y: 38, width: 1600, height: 900) let columns = FrameOracle.stripes(count: 2, visible: screen, vertical: true) #expect(!CoverageOracle.stacked(columns.reversed(), counts: [2], visible: screen)) #expect(CoverageOracle.stacked([screen.inset(16), screen.inset(16)], counts: [2], visible: screen)) #expect(!CoverageOracle.stacked([columns[0], columns[0]], counts: [2], visible: screen)) } @Test func minimumGeometryCreatesRoomForTwoButNotThreeMeasuredApps() throws { let screen = ScreenRect(x: -1600, y: 38, width: 1600, height: 900) let geometry = try MinimumStackGeometry(minimumWidths: [500, 500, 500], screen: screen) #expect(geometry.reservedLeft == 150) #expect(geometry.reservedRight == 150) #expect(geometry.visible.inset(16).width == 1268) let frames = FrameOracle.stripes(count: 2, visible: geometry.visible, vertical: true) #expect(CoverageOracle.minimumStack([frames[0], frames[1], frames[1]], geometry: geometry)) #expect(!CoverageOracle.minimumStack([frames[0], frames[1]], geometry: geometry)) #expect(!CoverageOracle.minimumStack([frames[0], frames[0], frames[0]], geometry: geometry)) let three = FrameOracle.stripes(count: 3, visible: geometry.visible, vertical: true) #expect(!CoverageOracle.minimumStack(three, geometry: geometry)) } @Test func minimumGeometryDoesNotInventAStackWhenAllAppsAlreadyFit() { let screen = ScreenRect(x: 0, y: 38, width: 3000, height: 900) #expect(throws: RealitySkip.self) { try MinimumStackGeometry(minimumWidths: [500, 500, 500], screen: screen) } } @Test(arguments: ["valid", "flexible-underfit", "fixed-underfit", "shifted", "over-cap", "unproved-cap"]) func minimumStackRequiresExactIndependentlyMeasuredGrowthCaps(_ condition: String) throws { let screen = ScreenRect(x: 0, y: 38, width: 1512, height: 886) let geometry = try MinimumStackGeometry( minimumWidths: [574, 642, 715], maximumWidths: condition == "unproved-cap" ? nil : [nil, nil, 715], screen: screen) let tiles = FrameOracle.stripes(count: 2, visible: geometry.visible, vertical: true) var frames = [ tiles[0], tiles[0], ScreenRect( x: tiles[1].x, y: tiles[1].y, width: 715, height: tiles[1].height), ] switch condition { case "flexible-underfit": frames[0].width -= 5 case "fixed-underfit": frames[2].width -= 5 case "shifted": frames[2].x += 3 case "over-cap": frames[2].width += 5 default: break } #expect(CoverageOracle.minimumStack(frames, geometry: geometry) == (condition == "valid")) } @Test func nativeStackMembersExcludeAStandaloneFixedWidthWindow() { let frames = [ ScreenRect(x: 16, y: 54, width: 734, height: 854), ScreenRect(x: 16, y: 54, width: 715, height: 854), ScreenRect(x: 762, y: 54, width: 715, height: 854), ] #expect(CoverageOracle.stackMembers(frames) == [0, 1]) #expect(CoverageOracle.stackMembers([frames[0], frames[2]]).isEmpty) } @Test(arguments: [[Double?](), [nil, nil], [.nan, nil, nil], [0, nil, nil], [-1, nil, nil], [500, nil, nil]]) func nativeGrowthBoundsCannotContradictMeasuredMinimums(_ maxima: [Double?]) { #expect(throws: RealityError.self) { try MinimumStackGeometry( minimumWidths: [574, 642, 715], maximumWidths: maxima, screen: ScreenRect(x: 0, y: 38, width: 1512, height: 886)) } } @Test(arguments: [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]]) func minimumStackPreservesMeasuredBoundsAcrossWindowOrder(_ order: [Int]) throws { let screen = ScreenRect(x: -1512, y: 38, width: 1512, height: 886) let tiles = FrameOracle.stripes(count: 2, visible: screen, vertical: true) let minima = [574.0, 642, 715] let maxima: [Double?] = [nil, nil, 715] var frames = [tiles[0], tiles[0], tiles[1]] frames[2].width = 715 let geometry = try MinimumStackGeometry( minimumWidths: order.map { minima[$0] }, maximumWidths: order.map { maxima[$0] }, screen: screen) #expect(CoverageOracle.minimumStack(order.map { frames[$0] }, geometry: geometry)) #expect( Set(CoverageOracle.stackMembers(order.map { frames[$0] })) == Set(order.indices.filter { order[$0] != 2 })) } @Test(arguments: [Double.nan, Double.infinity, 0, -1]) func nativeStackMembersNeverUseInvalidFrames(_ width: Double) { let valid = ScreenRect(x: 16, y: 54, width: 734, height: 854) var invalid = valid invalid.width = width #expect(CoverageOracle.stackMembers([valid, invalid]).isEmpty) } @Test func minimumStackChecksEveryMemberAgainstItsOwnNativeRefusal() throws { let geometry = try MinimumStackGeometry( minimumWidths: [900, 400, 400], screen: ScreenRect(x: 0, y: 38, width: 1600, height: 900)) let half = FrameOracle.stripes(count: 2, visible: geometry.visible, vertical: true) #expect(!CoverageOracle.minimumStack([half[0], half[1], half[1]], geometry: geometry)) let fitting = FrameOracle.stripes(count: 2, visible: geometry.visible, vertical: true, ratio: 0.6) #expect(CoverageOracle.minimumStack([fitting[0], fitting[1], fitting[1]], geometry: geometry)) } @Test(arguments: [ [Double](), [500, 500], [0, 500, 500], [-1, 500, 500], [.nan, 500, 500], [.infinity, 500, 500], ]) func minimumGeometryRejectsMissingOrInvalidMeasurements(_ widths: [Double]) { #expect(throws: RealityError.self) { try MinimumStackGeometry(minimumWidths: widths, screen: ScreenRect(x: 0, y: 38, width: 1600, height: 900)) } } @Test func minimumGeometrySkipsDisplaysWithoutRoomForTwoApps() { #expect(throws: RealitySkip.self) { try MinimumStackGeometry( minimumWidths: [800, 800, 800], screen: ScreenRect(x: 0, y: 38, width: 1600, height: 900)) } } @Test func floatingOverflowMustBeCenteredDistinctAndContained() { let screen = ScreenRect(x: -1600, y: 38, width: 1600, height: 900) let tiles = FrameOracle.stripes(count: 2, visible: screen, vertical: true) let floating = ScreenRect(x: -1100, y: 288, width: 600, height: 400) #expect(CoverageOracle.centeredFloat(floating, tiles: tiles, visible: screen)) var shifted = floating shifted.x += 10 #expect(!CoverageOracle.centeredFloat(shifted, tiles: tiles, visible: screen)) #expect(!CoverageOracle.centeredFloat(tiles[0], tiles: tiles, visible: screen)) #expect(!CoverageOracle.centeredFloat(screen, tiles: tiles, visible: screen)) } @Test(arguments: [80.0, -80.0]) func edgeResizeRequiresEqualOppositeNeighborMovement(_ delta: Double) { let screen = ScreenRect(x: 0, y: 38, width: 1600, height: 900) let baseline = FrameOracle.stripes(count: 2, visible: screen, vertical: true) var resized = baseline resized[0].width += delta resized[1].x += delta resized[1].width -= delta #expect(CoverageOracle.edgeResized(resized, baseline: baseline, visible: screen, delta: delta)) #expect(!CoverageOracle.edgeResized(baseline, baseline: baseline, visible: screen, delta: delta)) #expect(!CoverageOracle.edgeResized(resized, baseline: baseline, visible: screen, delta: -delta)) resized[1] = baseline[1] #expect(!CoverageOracle.edgeResized(resized, baseline: baseline, visible: screen, delta: delta)) } @Test(arguments: [0.0, 1.0, Double.nan, Double.infinity]) func edgeResizeRejectsTrivialOrInvalidStimuli(_ delta: Double) { let screen = ScreenRect(x: 0, y: 38, width: 1600, height: 900) let frames = FrameOracle.stripes(count: 2, visible: screen, vertical: true) #expect(!CoverageOracle.edgeResized(frames, baseline: frames, visible: screen, delta: delta)) #expect(!CoverageOracle.edgeResized([], baseline: frames, visible: screen, delta: delta)) } @Test func stableFrameProofRejectsMissingWindowsAndIdentityReordering() { let frames = [ ScreenRect(x: 16, y: 54, width: 600, height: 400), ScreenRect(x: 628, y: 54, width: 600, height: 400), ] #expect(CoverageOracle.unchanged(frames, baseline: frames)) #expect(!CoverageOracle.unchanged([], baseline: [])) #expect(!CoverageOracle.unchanged(Array(frames.prefix(1)), baseline: frames)) #expect(!CoverageOracle.unchanged(frames.reversed(), baseline: frames)) var bad = frames bad[0].width = .nan #expect(!CoverageOracle.unchanged(bad, baseline: bad)) } @Test func passThroughRequiresTheExactNativeFixtureReceipt() throws { let window = OwnedWindow(app: .fixture, pid: 42, id: 123) let receipt = DriverInputReceipt( target: DriverInputTarget(pid: 42, windowID: 123, fixture: true), outcome: "fixture delivery", virtualKey: 15, delivery: .fixture) try requireFixturePassThrough(DriverResponse(id: 1, input: [receipt]), window: window, virtualKey: 15) for response in [ DriverResponse(id: 1), DriverResponse(id: 1, error: "failed", input: [receipt]), DriverResponse(id: 1, input: []), DriverResponse(id: 1, input: [receipt, receipt]), ] { #expect(throws: RealityError.self) { try requireFixturePassThrough(response, window: window, virtualKey: 15) } } #expect(throws: RealityError.self) { try requireFixturePassThrough(DriverResponse(id: 1, input: [receipt]), window: window, virtualKey: 14) } } @Test(arguments: ["pid", "id", "panel", "document", "intercepted", "missing-delivery"]) func passThroughRejectsChangedOrUnverifiedTargets(_ failure: String) { let receipt = DriverInputReceipt( target: DriverInputTarget( pid: failure == "pid" ? 99 : 42, windowID: failure == "id" ? 999 : 123, fixture: failure != "document", panel: failure == "panel"), outcome: "untrusted free text", virtualKey: 15, delivery: failure == "missing-delivery" ? nil : (failure == "intercepted" ? .intercepted : .fixture)) #expect(throws: RealityError.self) { try requireFixturePassThrough( DriverResponse(id: 1, input: [receipt]), window: OwnedWindow(app: .fixture, pid: 42, id: 123), virtualKey: 15) } } @Test(arguments: ["", "shared.token", "space token", "slash/token", "\n"]) func recoveryHooksRefuseUnscopedOrMalformedTokens(_ token: String) { #expect(throws: RealityError.self) { try RealityRecoveryHooks(kind: .missedDestroy, token: token) } } @MainActor @Test func recoveryHooksNeverInheritAnotherLanesStimuli() throws { let inherited = [ "PARCEL_E2E": "1", "PARCEL_E2E_TOKEN": "foreign", "PARCEL_E2E_DROP_ONE_DESTROYED": "1", "KEEP": "yes", ] let normal = coverageLaunchEnvironment(inherited, hooks: nil) #expect(normal == ["PARCEL_E2E": "0", "KEEP": "yes"]) let sleep = try RealityRecoveryHooks(kind: .simulatedSleep, token: "owned-42") let enabled = coverageLaunchEnvironment(inherited, hooks: sleep) #expect(enabled["PARCEL_E2E_TOKEN"] == "owned-42") #expect(enabled["PARCEL_E2E"] == "1") #expect(enabled["PARCEL_E2E_REAL_APPS"] == "1") #expect(enabled["PARCEL_E2E_DROP_ONE_DESTROYED"] == nil) #expect(sleep.notification.rawValue == "dev.vinnymac.parcel.e2e.owned-42.sleep") let destroy = try RealityRecoveryHooks(kind: .missedDestroy, token: "owned-43") #expect(destroy.environment["PARCEL_E2E_DROP_ONE_DESTROYED"] == "1") #expect(destroy.notification.rawValue == "dev.vinnymac.parcel.e2e.owned-43.wake") let tour = try RealityRecoveryHooks(kind: .tourRollback, token: "owned-44") #expect( coverageLaunchEnvironment(inherited, hooks: tour) == [ "PARCEL_E2E": "1", "PARCEL_E2E_TOKEN": "owned-44", "PARCEL_E2E_REAL_APPS": "1", "KEEP": "yes", ]) } @Test func privacyLifecycleReceiptDoesNotInventAnAbsentReadback() throws { let source = Data(#"{"clean_space_backdrop_count":1,"privacy_panel_count":2}"#.utf8) let receipt = try JSONDecoder().decode(PrivacyLifecycleReceipt.self, from: source) #expect(receipt.backdropCount == 1 && receipt.panelCount == 2) #expect(throws: DecodingError.self) { try JSONDecoder().decode(PrivacyLifecycleReceipt.self, from: Data(#"{"privacy_panel_count":0}"#.utf8)) } } } extension RealityConfigurationTests { @Test func recoveryRejectsNonUUIDBeforeLaunchingParcel() async throws { let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) let session = try RealitySession( directory: root, appURL: URL(fileURLWithPath: "/tmp/nonexistent.app"), visible: ScreenRect(x: 0, y: 38, width: 1600, height: 900), inputBaseline: DriverInputState(heldKeys: [], flags: 0)) defer { do { try FileManager.default.removeItem(at: root) } catch { Issue.record(error) } } let hooks = try RealityRecoveryHooks(kind: .missedDestroy, token: "ParcelReality-old-token") await #expect(throws: RealityError.self) { try await session.start(recoveryHooks: hooks) } #expect(session.parcel == nil && session.driver.host == nil) #expect(session.launchInstant == nil) #expect(!FileManager.default.fileExists(atPath: root.appendingPathComponent("setup-hide-allowlist.json").path)) } @Test func minimumStackConfigUsesBoundedReservedEdgesAndNoForcedCap() throws { let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) let session = try RealitySession( directory: root, appURL: URL(fileURLWithPath: "/tmp/Parcel.app"), visible: ScreenRect(x: 0, y: 38, width: 1600, height: 900), inputBaseline: DriverInputState(heldKeys: [], flags: 0)) defer { do { try FileManager.default.removeItem(at: root) } catch { Issue.record(error) } } try session.configure(minSize: true, reservedLeft: 150, reservedRight: 150) let result = ConfigValidator.validate( try TOMLDocument(parsing: String(contentsOf: session.config, encoding: .utf8))) #expect(result.diagnostics.isEmpty) let config = try #require(result.configuration) #expect(config.layout.global.windowCap == 0) #expect(config.layout.global.whenFull == .stack) #expect(config.layout.global.reserved.left == 150 && config.layout.global.reserved.right == 150) #expect(config.rules.last?.action == .tile) #expect(!config.memory.enabled && !config.motion.enabled) } @Test func fullFloatConfigPreservesTheStackDragDefaults() throws { let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) let session = try RealitySession( directory: root, appURL: URL(fileURLWithPath: "/tmp/Parcel.app"), visible: ScreenRect(x: 0, y: 38, width: 1600, height: 900), inputBaseline: DriverInputState(heldKeys: [], flags: 0)) defer { do { try FileManager.default.removeItem(at: root) } catch { Issue.record(error) } } try session.configure(cap: 2, whenFull: .float) let result = ConfigValidator.validate( try TOMLDocument(parsing: String(contentsOf: session.config, encoding: .utf8))) #expect(result.diagnostics.isEmpty) let config = try #require(result.configuration) #expect(config.layout.global.windowCap == 2) #expect(config.layout.global.whenFull == .float) #expect( RealityInputDefaults.stackFlags == RealityInputDefaults.flags(KeyModifiers(rawValue: config.mouse.stackModifiers.rawValue))) } @Test(arguments: ["native-tabs", "secure-input-pause"]) func unsupportedCoverageSkipsBeforeLaunchingAnyApplication(_ name: String) async throws { let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) let session = try RealitySession( directory: root, appURL: URL(fileURLWithPath: "/tmp/nonexistent.app"), visible: ScreenRect(x: 0, y: 38, width: 1600, height: 900), inputBaseline: DriverInputState(heldKeys: [], flags: 0)) defer { do { try FileManager.default.removeItem(at: root) } catch { Issue.record(error) } } await #expect(throws: RealitySkip.self) { try await RealityScenario(name: name, feature: "").run(session) } #expect(session.parcel == nil && session.driver.host == nil && session.apps.windows.isEmpty) } }