import Foundation import ParcelConfig import Testing @testable import ParcelRealityTests @Suite struct FrameOracleTests { let visible = ScreenRect(x: 0, y: 25, width: 1600, height: 900) @Test(arguments: [false, true], [false, true]) func nativeFocusPromotionUsesTheLargestSideFrameInEitherOrientation(portrait: Bool, reordered: Bool) throws { let primary = portrait ? ScreenRect(x: 16, y: 54, width: 968, height: 680) : ScreenRect(x: 16, y: 54, width: 734, height: 854) let first = portrait ? ScreenRect(x: 16, y: 746, width: 478, height: 680) : ScreenRect(x: 762, y: 54, width: 734, height: 421) let second = portrait ? ScreenRect(x: 506, y: 746, width: 478, height: 680) : ScreenRect(x: 762, y: 487, width: 734, height: 421) let baseline = reordered ? [first, second, primary] : [primary, first, second] let selected = reordered ? 0 : 2 #expect(try NativeFocusFrameOracle.primaryIndex(in: baseline) == (reordered ? 2 : 0)) let expected: [ScreenRect] if portrait { expected = reordered ? [primary, second, first] : [second, first, primary] } else { let promoted = ScreenRect(x: 762, y: 54, width: 734, height: 854) let upper = ScreenRect(x: 16, y: 54, width: 734, height: 421) let lower = ScreenRect(x: 16, y: 487, width: 734, height: 421) expected = reordered ? [promoted, lower, upper] : [lower, upper, promoted] } #expect(try NativeFocusFrameOracle.promotedFrames(baseline, selecting: selected) == expected) #expect( try NativeFocusFrameOracle.promotedFrames(baseline, selecting: reordered ? 2 : 0) == baseline) } @Test func nativeFocusPromotionRejectsMissingInvalidAndAmbiguousBaselines() { let frame = ScreenRect(x: 0, y: 0, width: 600, height: 400) #expect(throws: RealityError.self) { try NativeFocusFrameOracle.primaryIndex(in: []) } #expect(throws: RealityError.self) { try NativeFocusFrameOracle.primaryIndex(in: [frame]) } #expect(throws: RealityError.self) { try NativeFocusFrameOracle.primaryIndex(in: [frame, frame, frame]) } #expect(throws: RealityError.self) { try NativeFocusFrameOracle.primaryIndex(in: [frame, frame, ScreenRect(x: 0, y: 0, width: 0, height: 200)]) } } @Test(arguments: [-1, 3]) func nativeFocusPromotionRejectsAnAbsentSelectedWindow(index: Int) { let baseline = [ ScreenRect(x: 0, y: 0, width: 600, height: 800), ScreenRect(x: 600, y: 0, width: 600, height: 400), ScreenRect(x: 600, y: 400, width: 600, height: 400), ] #expect(throws: RealityError.self) { try NativeFocusFrameOracle.promotedFrames(baseline, selecting: index) } } @Test func decodesOnlyNumericLayerZeroFrames() throws { let data = Data( """ [ {"kCGWindowNumber":11,"kCGWindowOwnerPID":42,"kCGWindowLayer":0, "kCGWindowBounds":{"X":20,"Y":30,"Width":600,"Height":400}, "kCGWindowName":"ignored","kCGWindowIsOnscreen":true,"kCGWindowAlpha":0.9}, {"kCGWindowNumber":12,"kCGWindowOwnerPID":42,"kCGWindowLayer":3, "kCGWindowBounds":{"X":20,"Y":30,"Width":600,"Height":400}}, {"kCGWindowNumber":13,"kCGWindowOwnerPID":42,"kCGWindowLayer":0, "kCGWindowBounds":{"X":20,"Y":30,"Width":0,"Height":400}} ] """.utf8) let windows = try FrameOracle.decode(data) #expect(windows.count == 1) let window = try #require(windows.first) #expect(window.id == 11) #expect(window.pid == 42) #expect(window.onscreen) #expect(window.alpha == 0.9) #expect(window.frame == ScreenRect(x: 20, y: 30, width: 600, height: 400)) let encoded = String(decoding: try JSONEncoder().encode(windows), as: UTF8.self) #expect(!encoded.contains("ignored")) #expect(!encoded.contains("Name")) } @Test(arguments: ["[]", "[{}]", "null", "not-json"]) func emptyOrMalformedMetadata(_ input: String) throws { if input == "[]" { #expect(try FrameOracle.decode(Data(input.utf8)).isEmpty) } else { #expect(throws: (any Error).self) { try FrameOracle.decode(Data(input.utf8)) } } } @Test(arguments: [1, 2, 3, 4], [true, false]) func stripeExpectationsCoverVisibleFrame(count: Int, vertical: Bool) { let frames = FrameOracle.stripes(count: count, visible: visible, vertical: vertical) #expect(frames.count == count) #expect(FrameOracle.tiles(frames, visible: visible)) #expect(FrameOracle.matchesUnordered(frames.reversed(), frames)) } @Test(arguments: [0.5, 0.6, 2.0 / 3.0], [true, false]) func mainSizeOracleMeasuresTheRequestedRealRatio(ratio: Double, vertical: Bool) { let frames = FrameOracle.stripes(count: 2, visible: visible, vertical: vertical, ratio: ratio) #expect(matchesMainRatio(frames, mainIndex: 0, ratio: ratio, visible: visible)) #expect(!matchesMainRatio(frames, mainIndex: 0, ratio: ratio + 0.01, visible: visible)) var widerGap = frames if vertical { widerGap[0].width -= 5 } else { widerGap[0].height -= 5 } #expect(!matchesMainRatio(widerGap, mainIndex: 0, ratio: ratio, visible: visible)) #expect(!matchesMainRatio(Array(frames.prefix(1)), mainIndex: 0, ratio: ratio, visible: visible)) #expect(!matchesMainRatio(frames, mainIndex: 2, ratio: ratio, visible: visible)) #expect(!matchesMainRatio(frames, mainIndex: 0, ratio: .nan, visible: visible)) } @Test(arguments: [0.0, -1512.0]) func balancedRetileColumnsHaveExactWholePointEdges(origin: Double) { let screen = ScreenRect(x: origin, y: 38, width: 1512, height: 886) let expected = [ ScreenRect(x: origin + 16, y: 54, width: 485, height: 854), ScreenRect(x: origin + 513, y: 54, width: 486, height: 854), ScreenRect(x: origin + 1011, y: 54, width: 485, height: 854), ] let actual = FrameOracle.balancedColumns(count: 3, visible: screen) #expect(actual == expected) var drifted = actual drifted[0].x -= 1 #expect(drifted != expected) #expect(actual[1].x - actual[0].maxX == 12) #expect(actual[2].x - actual[1].maxX == 12) } @Test(arguments: [1, 2, 3, 4]) func balancedRetileColumnsCoverTheWholePointUsableArea(count: Int) { let actual = FrameOracle.balancedColumns(count: count, visible: visible) #expect(actual.count == count) #expect(actual.first?.x == 16) #expect(actual.last?.maxX == 1584) #expect(actual.allSatisfy { $0.x.rounded() == $0.x && $0.width.rounded() == $0.width }) #expect(actual.allSatisfy { $0.y == 41 && $0.height == 868 }) } @Test(arguments: [0.0, -1600.0]) func reservedEdgesHaveIndependentAsymmetricExpectedBounds(origin: Double) throws { let bounds = ScreenRect(x: origin, y: 25, width: 1600, height: 900) let shared = try ReservedEdgesRealityOracle.frame( visible: bounds, reserved: ReservedEdges(top: 12, right: 18, bottom: 24, left: 30)) let distinct = try ReservedEdgesRealityOracle.frame( visible: bounds, reserved: ReservedEdges(top: 48, right: 54, bottom: 60, left: 66)) #expect(shared == ScreenRect(x: origin + 46, y: 53, width: 1520, height: 832)) #expect(distinct == ScreenRect(x: origin + 82, y: 89, width: 1448, height: 760)) #expect(!shared.matches(distinct)) let independentTop = try ReservedEdgesRealityOracle.frame( visible: bounds, reserved: ReservedEdges(top: 48, right: 18, bottom: 24, left: 30)) #expect(independentTop.x == shared.x && independentTop.width == shared.width) #expect(independentTop.y == distinct.y && independentTop.maxY == shared.maxY) #expect(!independentTop.matches(shared) && !independentTop.matches(distinct)) } @Test(arguments: [ ReservedEdges(top: -1), ReservedEdges(right: .infinity), ReservedEdges(bottom: .nan), ReservedEdges(left: 1600), ReservedEdges(top: 900), ]) func reservedEdgeOracleRejectsInvalidOrExhaustedInsets(_ reserved: ReservedEdges) { #expect(throws: RealityError.self) { try ReservedEdgesRealityOracle.frame(visible: visible, reserved: reserved) } } @Test func acceptsConfiguredGapsButRejectsUntiledWindows() { let frames = FrameOracle.stripes(count: 3, visible: visible, vertical: true) #expect(FrameOracle.tiles(frames, visible: visible)) #expect(!FrameOracle.tiles([], visible: visible)) #expect(!FrameOracle.tiles([frames[0], frames[0]], visible: visible)) #expect(!FrameOracle.tiles([frames[0]], visible: visible)) #expect(!FrameOracle.tiles([visible], visible: visible)) var wrongGap = frames wrongGap[1].x -= 9 #expect(!FrameOracle.tiles(wrongGap, visible: visible)) var outside = frames outside[0].x -= 10 #expect(!FrameOracle.tiles(outside, visible: visible)) } @Test func unorderedMatchingPreservesMultiplicity() { let frames = FrameOracle.stripes(count: 2, visible: visible, vertical: true) #expect(!FrameOracle.matchesUnordered([frames[0], frames[0]], frames)) #expect(!FrameOracle.matchesUnordered([frames[0]], frames)) } @Test func ratiosHaveIndependentExpectedDimensions() { let frames = FrameOracle.stripes(count: 2, visible: visible, vertical: true, ratio: 0.6) #expect(frames[0].width == (visible.width - 32 - 12) * 0.6) #expect(frames[1].width == (visible.width - 32 - 12) * 0.4) #expect(FrameOracle.tiles(frames, visible: visible)) } @Test func missingOwnedWindowFailsLoudly() { #expect(throws: RealityError.self) { try FrameOracle.frames([], ids: [99]) } } @Test func closeOracleUsesExactSurvivingIdentitiesRegardlessOfCGOrder() throws { let baseline = FrameOracle.stripes(count: 3, visible: visible, vertical: true) let expanded = FrameOracle.stripes(count: 2, visible: visible, vertical: true) let survivors = [OwnedWindow(app: .textEdit, pid: 10, id: 1), OwnedWindow(app: .textEdit, pid: 20, id: 2)] let rows = [closeRow(survivors[1], frame: expanded[1]), closeRow(survivors[0], frame: expanded[0])] #expect( try CloseWindowOracle.expanded( rows, closed: OwnedWindow(app: .textEdit, pid: 30, id: 3), survivors: survivors, before: Array(baseline.prefix(2)))) #expect( try !CloseWindowOracle.expanded( zip(survivors, baseline).map { closeRow($0.0, frame: $0.1) }, closed: OwnedWindow(app: .textEdit, pid: 30, id: 3), survivors: survivors, before: Array(baseline.prefix(2)))) } @Test(arguments: [false, true]) func closeOracleCannotPassWhileTheExactClosedIDRemains(_ onscreen: Bool) throws { let frame = visible.inset(16) let closed = OwnedWindow(app: .textEdit, pid: 30, id: 3) let survivor = OwnedWindow(app: .textEdit, pid: 10, id: 1) let rows = [closeRow(survivor, frame: frame), closeRow(closed, frame: frame, onscreen: onscreen)] #expect( try !CloseWindowOracle.expanded( rows, closed: closed, survivors: [survivor], before: [frame.inset(100)])) } @Test func closeOracleDoesNotTurnMissingSurvivorsIntoAFeaturePass() throws { let frame = visible.inset(16) #expect( try !CloseWindowOracle.expanded( [], closed: OwnedWindow(app: .textEdit, pid: 30, id: 3), survivors: [OwnedWindow(app: .textEdit, pid: 10, id: 1)], before: [frame])) } @Test(arguments: [false, true], [false, true]) func closeOracleStopsOnReusedOrAmbiguousClosedOrSurvivingIDs(closedChanged: Bool, duplicate: Bool) { let frame = visible.inset(16) let closed = OwnedWindow(app: .textEdit, pid: 30, id: 3) let survivor = OwnedWindow(app: .textEdit, pid: 10, id: 1) let target = closedChanged ? closed : survivor let rows = duplicate ? [closeRow(target, frame: frame), closeRow(target, frame: frame)] : [RealWindow(id: target.id, pid: 99, frame: frame, layer: 0, onscreen: true, alpha: 1)] do { _ = try CloseWindowOracle.expanded(rows, closed: closed, survivors: [survivor], before: [frame]) Issue.record("Close oracle accepted changed CG ownership") } catch { #expect(RealityLaneDecision.afterScenario(failures: [error], cleanupFailed: false).stopsLane) } } @Test(arguments: ["empty", "count", "duplicate", "includes-closed", "invalid-frame"]) func closeOracleRejectsAnInvalidBaseline(_ condition: String) { let frame = visible.inset(16) let closed = OwnedWindow(app: .textEdit, pid: 30, id: 3) let survivor = OwnedWindow(app: .textEdit, pid: 10, id: 1) let survivors: [OwnedWindow] = switch condition { case "empty": [] case "duplicate": [survivor, survivor] case "includes-closed": [closed] default: [survivor] } let before: [ScreenRect] = switch condition { case "count": [] case "duplicate": [frame, frame] case "invalid-frame": [ScreenRect(x: .nan, y: 0, width: 0, height: 0)] default: [frame] } #expect(throws: RealityError.self) { try CloseWindowOracle.expanded([], closed: closed, survivors: survivors, before: before) } } private func closeRow(_ window: OwnedWindow, frame: ScreenRect, onscreen: Bool = true) -> RealWindow { RealWindow(id: window.id, pid: window.pid, frame: frame, layer: 0, onscreen: onscreen, alpha: 1) } @Test func geometryToleranceAndValidity() { let frame = visible.inset(16) #expect(frame.matches(frame.inset(1))) #expect(!frame.matches(frame.inset(5))) #expect(visible.contains(frame)) #expect(!frame.contains(visible)) #expect(!ScreenRect(x: .infinity, y: 0, width: 1, height: 1).isValid) #expect(!ScreenRect(x: 0, y: 0, width: -1, height: 1).isValid) } @Test func scenarioNamesAreUniqueAndCoverEveryRealApp() { let names = RealityScenario.all.map(\.name) let unique = Set(names) #expect(unique.count == names.count) let required: Set = [ "launch", "cap-stack", "new-window", "close-window", "swap", "motion-speed", "focus-next-prev", "tab-view", "tab-view-off", "tab-view-latency", "tab-view-voiceover", "tab-view-ignored", "make-primary", "sizes", "float", "always-float", "application-rule", "minimum-size", "position-refusal", "fixed-size", "shortcuts", "voiceover-shortcuts", "modifier-drag", "focus-mode", "no-peek", "clean-space", "automatic-tiling-shortcut", "display-full-swap", "display-full-stack", "pause-resume", "retile", "activity", "relaunch-memory", "language-restart", "setups", "setups-hide", "spaces", "displays", "config-reload", "stack-cycle", "reserved-edges", "tour-rollback", "tour-rollback-paused", ] #expect(required.isSubset(of: unique)) for layout in ["grid", "columns", "rows", "side", "tree", "bsp", "accordion"] { #expect(unique.contains("layout-\(layout)")) #expect(unique.contains("sizes-\(layout)")) if layout != "accordion" { #expect(unique.contains("preset-\(layout)")) #expect(unique.contains("menu-sizes-\(layout)")) } } for app in RealApp.allCases where app != .fixture { #expect(unique.contains("app-\(app.rawValue)")) } #expect(!names.contains("app-fixture")) } @Test func reportIncludesSkipsAndArtifactLocations() { let results = [ RealityResult( scenario: "spaces", feature: "Spaces", status: .skip, evidence: "No setup | yet\nnext", artifactPath: "/tmp/run/spaces") ] let report = RealityMain.markdown(results, root: "/tmp/run") #expect(report.contains("0 pass, 0 fail, 1 skip")) #expect(report.contains("No setup \\| yet next")) #expect(report.contains("/tmp/run/spaces")) #expect(report.contains("not proved their feature broken")) } @Test func scriptQuotingDoesNotAllowCodeInjection() { #expect(RealityProcess.quoted("a\"b\\c\nd") == "\"a\\\"b\\\\c\\nd\"") } @MainActor @Test func ownedSuccessorsPreserveContentsAndAbsenceWithoutRestoringTheSource() throws { let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) .resolvingSymlinksInPath() try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: false) defer { do { try FileManager.default.removeItem(at: directory) } catch { Issue.record(error) } } let storage = try RealityStorage(parent: directory) let absent = try storage.successor() let url = storage.fileURL("workspace-state.json") try Data("initial".utf8).write(to: url) let present = try storage.successor() defer { for owned in [storage, absent, present] { do { try owned.removePreferences() } catch { Issue.record(error) } } } try Data("changed".utf8).write(to: url) #expect(try Data(contentsOf: present.fileURL("workspace-state.json")) == Data("initial".utf8)) #expect(try Data(contentsOf: url) == Data("changed".utf8)) #expect(!FileManager.default.fileExists(atPath: absent.fileURL("workspace-state.json").path)) } @Test @MainActor func refusesUnownedWindowBeforeDriving() async throws { let apps = RealApps(directory: URL(fileURLWithPath: "/tmp"), token: "test") let unowned = OwnedWindow(app: .finder, pid: 1, id: 99) await #expect(throws: RealityError.self) { try await apps.focus(unowned) } await #expect(throws: RealityError.self) { try await apps.close(unowned) } await #expect(throws: RealityError.self) { try await apps.reopen(unowned) } await #expect(throws: RealityError.self) { try await apps.arrange(unowned, frame: visible) } } @Test func processCapturesBothStreamsAndStatus() async throws { let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: false) defer { do { try FileManager.default.removeItem(at: directory) } catch { Issue.record(error) } } let result = try await RealityProcess.run( "/bin/bash", ["-c", "printf output; printf error >&2; exit 7"], directory: directory) #expect(result.status == 7) #expect(result.output == "output") #expect(result.errors == "error") } }