Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535import Foundationimport ParcelConfigimport RealityDriverSupportimport 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) }}