Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839import Foundationimport Testing
@testable import ParcelCore
@Suite struct WorkspaceMemoryTests { private let display = DisplayID(rawValue: "memory-display") private let space = SpaceID(rawValue: 11) private var key: WorkspaceKey { WorkspaceKey(display: display, space: space) } private let screen = Rect(x: -1200, y: 80, width: 1200, height: 800)
private func id(_ value: UInt32) -> WindowID { WindowID(rawValue: value) } private let salt = Data(repeating: 1, count: 32)
private func capture( _ state: State, preserving existing: WorkspaceMemory? = nil, now: TimeInterval = 0, pinned: [WindowID: WindowID] = [:], preservingMissing: Set<WindowID> = [] ) throws -> WorkspaceMemory { try WorkspaceMemory.capture( state, preserving: existing ?? WorkspaceMemory(titleSalt: salt), now: now, pinned: pinned, preservingMissing: preservingMissing) }
private func window(_ value: UInt32, title: String? = nil, bundle: String? = nil, floating: Bool = false) -> ManagedWindow { ManagedWindow( id: id(value), app: AppID(pid: Int32(value + 100), bundleID: bundle ?? "app.\(value)"), title: title ?? "Document \(value)", subrole: "AXStandardWindow", isFloating: floating) }
private func original() -> State { var workspace = Workspace( key: key, layout: .tree, ratio: .threeFifths, gaps: Gaps(inner: 7, outer: Insets(8)), reservedEdges: Insets(top: 24, left: 12, bottom: 6, right: 10), windowCap: 4, order: [id(1), id(2), id(3), id(4)], focus: id(3), whenFull: .float) var stack = WindowStack(id(1), others: [id(3)]) stack.select(id(3)) workspace.tree = .partition( axis: .horizontal, fraction: 0.37, first: .tile(stack), second: .tile(WindowStack(id(2)))) workspace.alternateSideTree = .split( axis: .vertical, fraction: 0.62, first: .tile(stack), second: .tile(WindowStack(id(2)))) workspace.openingOrder = [id(2), id(1), id(3), id(4)] workspace.pendingSplitAxis = .vertical return State( displays: [Display(id: display, frame: screen)], activeSpaces: [display: space], workspaces: [key: workspace], windows: [id(1): window(1), id(2): window(2), id(3): window(3), id(4): window(4, floating: true)], focusedWindow: id(3), frames: [id(4): Rect(x: -1080, y: 240, width: 480, height: 240)]) }
private func live(_ values: [UInt32], screen: Rect? = nil) -> State { let windows = values.map { value in ManagedWindow( id: id(value + 100), app: AppID(pid: Int32(value + 900), bundleID: "app.\(value)"), title: "Document \(value)", subrole: "AXStandardWindow") } return State( displays: [Display(id: display, frame: screen ?? self.screen)], activeSpaces: [display: space], workspaces: [key: Workspace(key: key, windowCap: 8, order: windows.map(\.id))], windows: Dictionary(uniqueKeysWithValues: windows.map { ($0.id, $0) })) }
@Test func fullSnapshotCodableRoundTripContainsNoProcessIdentity() throws { let snapshot = try capture(original()) let data = try JSONEncoder().encode(snapshot) #expect(try JSONDecoder().decode(WorkspaceMemory.self, from: data) == snapshot) let text = String(decoding: data, as: UTF8.self) #expect(!text.contains("pid")) #expect(!text.contains("observedFrames")) #expect(!text.contains("activeSpaces")) #expect(!text.contains("Document")) #expect(!text.contains("\"title\"")) #expect(text.contains("titleDigest")) #expect(snapshot.titleSalt == salt) #expect(snapshot.records.first?.lastSeen == 0) let record = try #require(snapshot.records.first) #expect(record.workspace == original().workspaces[key]) #expect(record.windows.last?.normalizedFloatingFrame == Rect(x: 0.1, y: 0.2, width: 0.4, height: 0.3)) }
@Test func identityRemapPreservesSettingsOrderTopologyVisibilityAndFloatingFrame() throws { let memory = try capture(original()) let state = live([2, 4, 3, 1]) let mapping = memory.windowMapping(in: state) #expect(mapping == [id(1): id(101), id(2): id(102), id(3): id(103), id(4): id(104)]) let restored = memory.restoring(state) let expected = try #require(original().workspaces[key]).memoryRemapping(mapping) #expect(restored.workspaces[key] == expected) #expect(restored.windows[id(104)]?.isFloating == true) #expect(restored.frames[id(104)] == original().frames[id(4)]) #expect(restored.activeSpaces == state.activeSpaces) #expect(restored.focusedWindow == state.focusedWindow) }
@Test(arguments: [true, false]) func nativeFocusOverridesRememberedStackVisibility(restoreWindows: Bool) throws { let memory = try capture(original()) var state = live([1, 2, 3]) state.workspaces[key] = try #require(original().workspaces[key]).memoryRemapping( memory.windowMapping(in: state)) state.focusedWindow = id(101) #expect(state.workspaces[key]?.tree?.stacks.first?.visible == id(103)) let restored = memory.restoring(state, restoreWindows: restoreWindows) #expect(restored.focusedWindow == id(101)) #expect(restored.workspaces[key]?.focus == id(101)) #expect(restored.workspaces[key]?.tree?.stacks.first?.visible == id(101)) #expect(restored.visibleWindows.contains(id(101))) #expect(memory.records.first?.workspace.focus == id(3)) #expect(memory.records.first?.workspace.tree?.stacks.first?.visible == id(3)) }
@Test func nestedCustomSplitAndEdgeFractionsSurvive() throws { var state = original() state.windows[id(4)]?.isFloating = false state.workspaces[key]?.tree = .split( axis: .vertical, fraction: 0.28, first: .partition( axis: .horizontal, fraction: 0.73, first: .tile(WindowStack(id(1))), second: .tile(WindowStack(id(4)))), second: .split( axis: .horizontal, fraction: 0.61, first: .tile(WindowStack(id(2))), second: .tile(WindowStack(id(3))))) let memory = try capture(state) let restored = memory.restoring(live([4, 3, 2, 1])) #expect( restored.workspaces[key]?.tree == state.workspaces[key]?.tree?.memoryRemapping(memory.windowMapping(in: restored))) #expect(restored.tileEdges.map(\.fraction) == [0.28, 0.73, 0.61]) }
@Test func settingsRestoreBeforeObservationNeverInjectsSavedIDs() throws { let memory = try capture(original()) let empty = State(displays: [Display(id: display, frame: screen)], activeSpaces: [display: space]) let restored = memory.restoring(empty) let workspace = try #require(restored.workspaces[key]) #expect(workspace.layout == .tree) #expect(workspace.ratio == .threeFifths) #expect(workspace.gaps == original().workspaces[key]?.gaps) #expect(workspace.reservedEdges == original().workspaces[key]?.reservedEdges) #expect(workspace.windowCap == 4) #expect(workspace.whenFull == .float) #expect(workspace.pendingSplitAxis == .vertical) #expect(workspace.order.isEmpty) #expect(workspace.tree == nil) #expect(restored.windows.isEmpty) }
@Test(arguments: Layout.allCases.filter { $0 != .side }) func settingsOnlyPreservesExistingMembersAndCustomLiveTree(layout: Layout) throws { var saved = original() saved.workspaces[key]?.layout = layout let memory = try capture(saved) var state = live([1, 2]) state.workspaces[key]?.layout = layout state.workspaces[key]?.tree = .split( axis: .vertical, fraction: 0.19, first: .tile(WindowStack(id(102))), second: .tile(WindowStack(id(101)))) let restored = memory.restoring(state, restoreWindows: false) #expect(restored.workspaces[key]?.order == state.workspaces[key]?.order) #expect(restored.workspaces[key]?.openingOrder == state.workspaces[key]?.openingOrder) #expect(restored.workspaces[key]?.tree == state.workspaces[key]?.tree) #expect(restored.workspaces[key]?.ratio == saved.workspaces[key]?.ratio) #expect(restored.windows == state.windows) #expect(restored.frames == state.frames) #expect(restored.workspaces[key]?.windowCap == 4) }
@Test func delayedMembersReconstructImmutableOriginalTopology() throws { let memory = try capture(original()) let before = memory var state = memory.restoring(live([1])) #expect(state.workspaces[key]?.tree?.windows == [id(101)]) for value: UInt32 in [2, 3, 4] { let managed = try #require(live([value]).windows[id(value + 100)]) state = reduce(state, .windowAppeared(managed, workspace: key, frame: screen)).0 state = memory.restoring(state) } let mapping = memory.windowMapping(in: state) var expected = try #require(original().workspaces[key]).memoryRemapping(mapping) if let focused = state.focusedWindow { expected.select(focused) } #expect(state.workspaces[key] == expected) #expect(memory == before) }
@Test func normalizedFloatingFrameFollowsDisplayOriginAndSize() throws { let memory = try capture(original()) let resized = Rect(x: 200, y: -100, width: 1800, height: 1000) let restored = memory.restoring(live([4], screen: resized)) #expect(restored.frames[id(104)] == Rect(x: 380, y: 100, width: 720, height: 300)) }
@Test func reconnectRetainsDisconnectedRecordDespiteMigration() throws { let memory = try capture(original()) let otherDisplay = DisplayID(rawValue: "temporary-display") let otherKey = WorkspaceKey(display: otherDisplay, space: space) let source = try #require(original().windows[id(1)]) let migrated = State( displays: [Display(id: otherDisplay, frame: screen)], activeSpaces: [otherDisplay: space], workspaces: [key: Workspace(key: key), otherKey: Workspace(key: otherKey, order: [id(1)])], windows: [id(1): source]) let captured = try capture(migrated, preserving: memory) #expect(captured.records.first { $0.workspace.key == key } == memory.records.first) #expect(captured.records.count == 2) #expect(Set(captured.records.flatMap { $0.windows.map(\.token) }).count == 5) let reconnected = memory.restoring(live([1, 2, 3, 4])) #expect(reconnected.workspaces[key]?.tree?.stacks.first?.visible == id(103)) }
@Test func inactiveRecordsAreNotErasedBeforeTheyAreObserved() throws { let memory = try capture(original()) let inactive = State( displays: [Display(id: display, frame: screen)], activeSpaces: [display: SpaceID(rawValue: 99)], workspaces: [key: Workspace(key: key)]) #expect( try capture(inactive, preserving: memory).records.first { $0.workspace.key == key } == memory.records.first) let absent = State(displays: [Display(id: display, frame: screen)]) #expect(try capture(absent, preserving: memory) == memory) }
@Test func captureRefreshesConnectedActiveWorkspaceAndReusesIdentityTokens() throws { let memory = try capture(original()) var state = live([1, 2, 3, 4]) state.workspaces[key]?.ratio = .twoThirds state.windows[id(104)]?.isFloating = true let tiled = state.workspaces[key]?.tree?.removing(id(104)) state.workspaces[key]?.tree = tiled let captured = try capture(state, preserving: memory) #expect(captured.records.first?.workspace.ratio == .twoThirds) #expect(captured.records.first?.windows.map(\.token) == [id(1), id(2), id(3), id(4)]) #expect(try capture(live([]), preserving: memory).records.first?.windows.isEmpty == true) }
@Test func neverMovesWindowBetweenNativeSpacesButRestoresBothSettings() throws { let memory = try capture(original()) let secondKey = WorkspaceKey(display: display, space: SpaceID(rawValue: 12)) var state = live([1]) state.workspaces[secondKey] = state.workspaces.removeValue(forKey: key).map { Workspace(key: secondKey, order: $0.order) } let restored = memory.restoring(state) #expect(memory.windowMapping(in: state).isEmpty) #expect(restored.workspace(containing: id(101)) == secondKey) #expect(restored.workspaces[key]?.order.isEmpty == true) #expect(restored.workspaces[key]?.layout == .tree) #expect(restored.activeSpaces == state.activeSpaces) }
@Test func sameIdentityOnTwoSpacesIsMatchedWithinEachSpace() throws { let first = original() let secondKey = WorkspaceKey(display: display, space: SpaceID(rawValue: 12)) var state = first state.workspaces[secondKey] = Workspace(key: secondKey, order: [id(5)]) state.windows[id(5)] = window(5, title: "Document 1", bundle: "app.1") let memory = try capture(state) var current = live([1]) current.workspaces[secondKey] = Workspace(key: secondKey, order: [id(105)]) current.windows[id(105)] = ManagedWindow( id: id(105), app: AppID(pid: 2, bundleID: "app.1"), title: "Document 1", subrole: "AXStandardWindow") let mapping = memory.windowMapping(in: current) #expect(mapping[id(1)] == id(101)) #expect(mapping[id(5)] == id(105)) #expect(memory.restoring(current).workspace(containing: id(105)) == secondKey) }
@Test func exactNormalizedTitlesWinBeforeChangedTitleFallback() throws { var source = original() source.windows[id(1)]?.app = AppID(pid: 1, bundleID: "shared.app") source.windows[id(2)]?.app = AppID(pid: 1, bundleID: "shared.app") source.windows[id(1)]?.title = " RÉSUMÉ Document\n" source.windows[id(2)]?.title = "Other" let memory = try capture(source) var state = live([1, 2]) state.windows[id(101)]?.app = AppID(pid: 10, bundleID: "shared.app") state.windows[id(102)]?.app = AppID(pid: 10, bundleID: "shared.app") state.windows[id(101)]?.title = "Changed" state.windows[id(102)]?.title = "re\u{301}sume\u{301} document" #expect(memory.windowMapping(in: state) == [id(1): id(102)]) }
@Test func changedTitleMatchesOnlySingletonIdentity() throws { let memory = try capture(original()) var state = live([1]) state.windows[id(101)]?.title = "A newly opened document" #expect(memory.windowMapping(in: state) == [id(1): id(101)]) }
@Test(arguments: ["", " \n "]) func emptyTitlesNeverGuessEvenWhenLiveNumberIsReused(title: String) throws { var source = original() source.windows[id(1)]?.title = title let memory = try capture(source) #expect(memory.windowMapping(in: source)[id(1)] == nil) var state = live([1]) #expect(memory.windowMapping(in: state)[id(1)] == nil) state.windows[id(101)]?.title = title #expect(memory.windowMapping(in: state)[id(1)] == nil) }
@Test func ambiguousIdenticalTitlesAndChangedGroupsNeverGuess() throws { var source = original() for value: UInt32 in [1, 2] { source.windows[id(value)]?.app = AppID(pid: 1, bundleID: "shared.app") source.windows[id(value)]?.title = "Same" } let memory = try capture(source) var state = live([1, 2]) for value: UInt32 in [101, 102] { state.windows[id(value)]?.app = AppID(pid: 3, bundleID: "shared.app") state.windows[id(value)]?.title = "Same" } #expect(memory.windowMapping(in: state).isEmpty) state.windows[id(101)]?.title = "Changed" state.windows[id(102)]?.title = "Also changed" #expect(memory.windowMapping(in: state).isEmpty) }
@Test(arguments: ["bundle", "role", "subrole", "display"]) func mandatoryIdentityCannotBeOverriddenByLiveNumberOrTitle(component: String) throws { let memory = try capture(original()) var state = original() switch component { case "bundle": state.windows[id(1)]?.app = AppID(pid: 1, bundleID: "unrelated.app") case "role": state.windows[id(1)]?.role = "AXDialog" case "subrole": state.windows[id(1)]?.subrole = nil default: let other = DisplayID(rawValue: "different-display") state.displays = [other: Display(id: other, frame: screen)] } #expect(memory.windowMapping(in: state)[id(1)] == nil) }
@Test func newlyAppearingUnmatchedWindowsAndStacksAreRetained() throws { let memory = try capture(original()) let state = live([1, 2, 3, 4, 8, 9]) let restored = memory.restoring(state) let workspace = try #require(restored.workspaces[key]) var expected = memory.restoring(live([1, 2, 3, 4])) for value: UInt32 in [8, 9] { let window = try #require(state.windows[id(value + 100)]) expected = reduce(expected, .windowAppeared(window, workspace: key, frame: screen)).0 } #expect(workspace == expected.workspaces[key]) #expect(Set(workspace.tree?.windows ?? []) == Set([id(101), id(102), id(103), id(108), id(109)])) #expect(restored.windows.count == state.windows.count) #expect((workspace.tree?.tileCount ?? 0) <= workspace.effectiveWindowCap) }
@Test func classifiedFloatingWindowsStayExcludedFromSavedTiles() throws { let memory = try capture(original()) var state = live([1, 2, 3]) state.windows[id(101)]?.isFloating = true state.windows[id(101)]?.facts = WindowFacts(bundleID: "app.1", isModal: true) let tiled = state.workspaces[key]?.tree?.removing(id(101)) state.workspaces[key]?.tree = tiled state.frames[id(101)] = Rect(x: 12, y: 34, width: 500, height: 300) let restored = memory.restoring(state) #expect(restored.windows[id(101)]?.isFloating == true) #expect(restored.workspaces[key]?.order.contains(id(101)) == true) #expect(restored.workspaces[key]?.tree?.windows.contains(id(101)) == false) #expect(restored.frames[id(101)] == state.frames[id(101)]) }
@Test func duplicateKeysAndTokensAreRejected() throws { let record = try #require(try capture(original()).records.first) #expect(throws: WorkspaceMemoryError.duplicateWorkspace(key)) { try WorkspaceMemory(records: [record, record], titleSalt: salt) } let secondKey = WorkspaceKey(display: display, space: SpaceID(rawValue: 12)) let duplicate = WorkspaceMemory.Record( workspace: Workspace(key: secondKey, order: [id(1)]), windows: [record.windows[0]]) #expect(throws: WorkspaceMemoryError.duplicateWindowToken(id(1))) { try WorkspaceMemory(records: [record, duplicate], titleSalt: salt) } }
@Test(arguments: [ "gaps", "reserved", "size", "fraction", "alternate", "members", "opening", "focus", "floating", "cap", ]) func invalidGeometryMembershipAndCapsAreRejected(component: String) throws { let record = try #require(try capture(original()).records.first) var workspace = record.workspace var windows = record.windows switch component { case "gaps": workspace.gaps.inner = -.infinity case "reserved": workspace.reservedEdges.left = -1 case "size": workspace.displaySize = Size(width: .greatestFiniteMagnitude, height: 1) case "fraction": workspace.tree = .split( axis: .horizontal, fraction: 1.1, first: .tile(WindowStack(id(1))), second: .tile(WindowStack(id(2)))) case "alternate": workspace.alternateSideTree = .tile(WindowStack(id(999))) case "members": workspace.order.append(id(1)) case "opening": workspace.openingOrder = [id(1)] case "focus": workspace.focus = id(999) case "floating": windows[0] = WorkspaceMemory.SavedWindow( token: id(1), bundleID: "app.1", titleDigest: record.windows[0].titleDigest, display: display, isFloating: true) default: workspace.setWindowCap(1) workspace.tree = record.workspace.tree } #expect(throws: WorkspaceMemoryError.self) { try WorkspaceMemory(records: [.init(workspace: workspace, windows: windows)], titleSalt: salt) } }
@Test(arguments: ["bundle", "role", "subrole", "display", "floating-frame", "tiled-frame"]) func invalidSavedIdentityAndNormalizedFramesAreRejected(component: String) throws { let record = try #require(try capture(original()).records.first) let original = record.windows[3] let invalid = WorkspaceMemory.SavedWindow( token: original.token, bundleID: component == "bundle" ? " " : original.bundleID, titleDigest: original.titleDigest, role: component == "role" ? "" : original.role, subrole: component == "subrole" ? "" : original.subrole, display: component == "display" ? DisplayID(rawValue: "other") : display, isFloating: component != "tiled-frame", normalizedFloatingFrame: component == "floating-frame" ? Rect(width: -1, height: 0.2) : original.normalizedFloatingFrame) var windows = record.windows windows[3] = invalid #expect(throws: WorkspaceMemoryError.self) { try WorkspaceMemory(records: [.init(workspace: record.workspace, windows: windows)], titleSalt: salt) } }
@Test func titleDigestsAreKeyedNormalizedAndDeterministic() throws { let memory = WorkspaceMemory(titleSalt: salt) let digest = try #require(try memory.titleDigest(for: " RÉSUMÉ Document\n")) #expect(digest.count == 64) #expect(try memory.titleDigest(for: "re\u{301}sume\u{301} document") == digest) #expect(try memory.titleDigest(for: "Other") != digest) #expect( try WorkspaceMemory(titleSalt: Data(repeating: 2, count: 32)).titleDigest(for: "résumé document") != digest) #expect(try memory.titleDigest(for: " \n ") == nil) #expect( try memory.titleDigest(for: "Document 1") == "bf8ee86414f63bf98548fde7a7d597cdc9a0fdb59d4cbca47ae52e966d9aaf89") let captured = try capture(original()) #expect(try captured.records.first?.windows[0].titleDigest == memory.titleDigest(for: "Document 1")) #expect(try capture(original()) == captured) }
@Test(arguments: [0, 1, 31, 33]) func invalidSaltsCannotCaptureOrHashTitles(length: Int) throws { let invalid = Data(repeating: 1, count: length) #expect(throws: WorkspaceMemoryError.invalidTitleSalt) { try WorkspaceMemory.capture(original(), titleSalt: invalid) } #expect(throws: WorkspaceMemoryError.invalidTitleSalt) { try WorkspaceMemory(titleSalt: invalid).titleDigest(for: "") } let record = try #require(try capture(original()).records.first) #expect(throws: WorkspaceMemoryError.invalidTitleSalt) { try WorkspaceMemory(records: [record], titleSalt: invalid) } }
@Test func captureCannotChangeTheSaltOfRetainedWindowDigests() throws { let memory = try capture(original()) #expect(throws: WorkspaceMemoryError.invalidTitleSalt) { try WorkspaceMemory.capture(original(), preserving: memory, titleSalt: Data(repeating: 2, count: 32)) } let empty = WorkspaceMemory() try empty.validate() #expect(try WorkspaceMemory.capture(State()) == empty) }
@Test(arguments: ["", "short", String(repeating: "G", count: 64), String(repeating: "a", count: 65)]) func malformedTitleDigestsAreRejected(digest: String) throws { let record = try #require(try capture(original()).records.first) let window = record.windows[0] let invalid = WorkspaceMemory.SavedWindow( token: window.token, bundleID: window.bundleID, titleDigest: digest, role: window.role, subrole: window.subrole, display: display) #expect(throws: WorkspaceMemoryError.invalidWindow(window.token)) { try WorkspaceMemory( records: [.init(workspace: record.workspace, windows: [invalid] + record.windows.dropFirst())], titleSalt: salt) } }
@Test func pinnedAssignmentsSurviveTitleSwapsAndEmptyTitles() throws { var source = original() source.windows[id(1)]?.app = AppID(pid: 1, bundleID: "shared.app") source.windows[id(2)]?.app = AppID(pid: 1, bundleID: "shared.app") let memory = try capture(source) var state = live([1, 2]) state.windows[id(101)]?.app = AppID(pid: 2, bundleID: "shared.app") state.windows[id(102)]?.app = AppID(pid: 2, bundleID: "shared.app") let pinned = memory.windowMapping(in: state) let before = memory.restoring(state, pinned: pinned, candidates: []) state.windows[id(101)]?.title = "Document 2" state.windows[id(102)]?.title = "Document 1" #expect(memory.windowMapping(in: state) == [id(1): id(102), id(2): id(101)]) #expect(memory.windowMapping(in: state, pinned: pinned, candidates: []) == pinned) #expect(memory.restoring(state, pinned: pinned, candidates: []).workspaces == before.workspaces) state.windows[id(101)]?.title = "" #expect(memory.windowMapping(in: state, pinned: pinned, candidates: []) == pinned) let captured = try capture(state, preserving: memory, pinned: pinned) #expect(captured.records.first?.windows.map(\.token) == [id(1), id(2)]) #expect(captured.records.first?.windows.first?.titleDigest == nil) }
@Test func onlyCandidateWindowsCanResolveNewTokensAndPinsReserveLiveIDs() throws { let memory = try capture(original()) let state = live([1, 2, 3]) let pinned = [id(1): id(101)] #expect( memory.windowMapping(in: state, pinned: pinned, candidates: [id(103)]) == [id(1): id(101), id(3): id(103)]) #expect(memory.windowMapping(in: state, candidates: []).isEmpty) #expect(memory.windowMapping(in: state, pinned: [id(1): id(102)])[id(1)] == nil) #expect(memory.windowMapping(in: state, pinned: [id(1): id(102)])[id(2)] == nil) var moved = state let otherKey = WorkspaceKey(display: display, space: SpaceID(rawValue: 12)) moved.workspaces[key]?.remove(id(101)) moved.workspaces[otherKey] = Workspace(key: otherKey, order: [id(101)]) moved.windows[id(108)] = ManagedWindow( id: id(108), app: AppID(pid: 2, bundleID: "app.1"), title: "Document 1", subrole: "AXStandardWindow") let movedWindows = moved.windows moved.workspaces[key]?.insert(id(108), floating: false, in: screen, windows: movedWindows) #expect(memory.windowMapping(in: moved, pinned: pinned)[id(1)] == nil) }
@Test func candidateFilteringDoesNotEraseIdentityAmbiguity() throws { let memory = try capture(original()) var state = live([1, 8]) state.windows[id(101)]?.title = "Changed" state.windows[id(108)]?.app = AppID(pid: 2, bundleID: "app.1") state.windows[id(108)]?.title = "Also changed" #expect(memory.windowMapping(in: state, candidates: [id(101)])[id(1)] == nil) }
@Test(arguments: [WhenFull.stack, .float]) func unmatchedWindowsFollowTheNormalCapAndOverflowInsertion(whenFull: WhenFull) throws { var source = live([1, 2]) source.workspaces[key] = Workspace( key: key, layout: .rows, windowCap: 2, order: [id(101), id(102)], whenFull: whenFull) let memory = try capture(source) let all = live([1, 2, 8]) let restored = memory.restoring(all) var expected = memory.restoring(live([1, 2])) expected = reduce(expected, .windowAppeared(try #require(all.windows[id(108)]), workspace: key, frame: screen)).0 #expect(restored.workspaces[key] == expected.workspaces[key]) #expect(restored.windows[id(108)]?.isFloating == (whenFull == .float)) #expect(restored.windows[id(108)]?.managementReason == expected.windows[id(108)]?.managementReason) if whenFull == .float { #expect(restored.frames[id(108)] == expected.frames[id(108)]) } try capture(restored).validate() }
@Test(arguments: [ Rect(x: -8, y: 5, width: 0.4, height: 0.3), Rect(x: 8, y: -5, width: 0.4, height: 0.3), Rect(x: 8, y: 8, width: 4, height: 3), ]) func restoredFloatingFramesStayInsideVisibleDisplay(normalized: Rect) throws { let record = try #require(try capture(original()).records.first) let floating = record.windows[3] let replacement = WorkspaceMemory.SavedWindow( token: floating.token, bundleID: floating.bundleID, titleDigest: floating.titleDigest, role: floating.role, subrole: floating.subrole, display: display, isFloating: true, normalizedFloatingFrame: normalized) let memory = try WorkspaceMemory( records: [.init(workspace: record.workspace, windows: Array(record.windows.prefix(3)) + [replacement])], titleSalt: salt) let frame = try #require(memory.restoring(live([4])).frames[id(104)]) #expect(frame.minX >= screen.minX) #expect(frame.minY >= screen.minY) #expect(frame.maxX <= screen.maxX) #expect(frame.maxY <= screen.maxY) #expect(frame.size.width == min(normalized.size.width * screen.size.width, screen.size.width)) #expect(frame.size.height == min(normalized.size.height * screen.size.height, screen.size.height)) }
@Test(arguments: ["missing-window", "duplicate-member", "foreign-tree-member", "invalid-frame"]) func inconsistentCaptureThrowsInsteadOfDroppingDataOrTrapping(component: String) throws { var state = original() switch component { case "missing-window": state.windows.removeValue(forKey: id(1)) case "duplicate-member": state.workspaces[key]?.order.append(id(1)) case "foreign-tree-member": state.workspaces[key]?.tree = .tile(WindowStack(id(999))) default: state.frames[id(4)] = Rect(x: .nan, y: 0, width: 200, height: 100) } #expect(throws: WorkspaceMemoryError.self) { try capture(state) } }
@Test(arguments: [false, true]) func duplicateLiveWorkspaceMembershipThrowsBeforeMappingInversionCanTrap(preserving: Bool) throws { let otherKey = WorkspaceKey(display: display, space: SpaceID(rawValue: 12)) var source = original() source.workspaces[otherKey] = Workspace(key: otherKey, order: [id(5)]) source.windows[id(5)] = window(5, title: "Document 1", bundle: "app.1") let memory = try capture(source) var state = live([1]) state.workspaces[otherKey] = Workspace(key: otherKey, order: [id(101)]) #expect(throws: WorkspaceMemoryError.invalidWindow(id(101))) { try capture(state, preserving: preserving ? memory : nil) } }
@Test func injectedTimestampsRefreshOnlyObservedRecordsAndPruneOldOnes() throws { let day: TimeInterval = 24 * 60 * 60 let memory = try capture(original(), now: 1) let absent = State(displays: [Display(id: display, frame: screen)]) #expect(try capture(absent, preserving: memory, now: 29 * day).records.first?.lastSeen == 1) #expect(try capture(absent, preserving: memory, now: 31 * day).records.isEmpty) let refreshed = try capture(original(), preserving: memory, now: 31 * day) #expect(refreshed.records.first?.lastSeen == 31 * day) let data = try JSONEncoder().encode(refreshed) #expect(try JSONDecoder().decode(WorkspaceMemory.self, from: data) == refreshed) #expect(try refreshed.pruned(asOf: 61 * day).records.count == 1) #expect(try refreshed.pruned(asOf: 61 * day + 1).records.isEmpty) }
@Test func recordCountPruningKeepsTheNewestAndBreaksTiesByWorkspaceKey() throws { let records = (1...130).map { value in WorkspaceMemory.Record( workspace: Workspace(key: WorkspaceKey(display: display, space: SpaceID(rawValue: UInt64(value)))), lastSeen: value == 130 ? 1 : 2) } let memory = try WorkspaceMemory(records: records.reversed(), titleSalt: salt) let pruned = try memory.pruned(asOf: 2) #expect(pruned.records.count == 128) #expect(pruned.records.last?.workspace.key.space.rawValue == 128) #expect(pruned.titleSalt == salt) #expect(try memory.pruned(asOf: 0, maximumCount: 0).records.isEmpty) #expect(try WorkspaceMemory.capture(State(), preserving: memory, now: 2) == pruned) }
@Test(arguments: [-1.0, Double.nan, .infinity]) func invalidTimestampsAreRejected(timestamp: TimeInterval) throws { #expect(throws: WorkspaceMemoryError.invalidTimestamp) { try capture(original(), now: timestamp) } let record = try #require(try capture(original()).records.first) #expect(throws: WorkspaceMemoryError.invalidTimestamp) { try WorkspaceMemory( records: [.init(workspace: record.workspace, windows: record.windows, lastSeen: timestamp)], titleSalt: salt) } #expect(throws: WorkspaceMemoryError.invalidTimestamp) { try WorkspaceMemory().pruned(asOf: timestamp) } }
@Test func invalidPruningPoliciesAreSurfaced() throws { #expect(throws: WorkspaceMemoryError.invalidPruningPolicy) { try WorkspaceMemory().pruned(asOf: 0, maximumAge: -1) } #expect(throws: WorkspaceMemoryError.invalidPruningPolicy) { try WorkspaceMemory().pruned(asOf: 0, maximumAge: .nan) } #expect(throws: WorkspaceMemoryError.invalidPruningPolicy) { try WorkspaceMemory().pruned(asOf: 0, maximumCount: -1) } }
@Test func unresolvedSavedWindowsMergeWithCurrentSettingsAndSharedStackSlots() throws { let memory = try capture(original(), now: 1) var state = memory.restoring(live([1, 2])) state.workspaces[key]?.changeLayout(.rows) state.workspaces[key]?.changeRatio(.twoThirds) let pinned = memory.windowMapping(in: state) let current = try capture(state, preserving: memory, now: 2, pinned: pinned) let merged = try capture(state, preserving: memory, now: 2, pinned: pinned, preservingMissing: [id(3), id(4)]) let record = try #require(merged.records.first) #expect(record.workspace.layout == .rows) #expect(record.workspace.ratio == .twoThirds) #expect(record.lastSeen == 2) #expect(record.windows.count == 4) #expect(record.workspace.order.contains(id(4))) #expect(record.workspace.tree?.stacks.first?.windows == [id(1), id(3)]) #expect(record.workspace.tree?.windows.contains(id(4)) == false) #expect(record.workspace.focus == current.records.first?.workspace.focus) #expect(record.windows.first { $0.token == id(4) } == memory.records.first?.windows.last) #expect(merged.titleSalt == memory.titleSalt) try merged.validate() #expect( try capture(state, preserving: memory, pinned: pinned, preservingMissing: []).records.first?.windows.count == 2) }
@Test func unresolvedWindowRetentionDoesNotConsumeTheNextLiveSplitAxis() throws { let memory = try capture(original()) let state = memory.restoring(live([2])) #expect(state.workspaces[key]?.pendingSplitAxis == .vertical) let captured = try capture( state, preserving: memory, pinned: memory.windowMapping(in: state), preservingMissing: [id(1)]) #expect(captured.records.first?.workspace.pendingSplitAxis == .vertical) #expect(captured.records.first?.workspace.layout == state.workspaces[key]?.layout) #expect(captured.records.first?.workspace.ratio == state.workspaces[key]?.ratio) #expect(captured.records.first?.workspace.configuredRatio == state.workspaces[key]?.configuredRatio) #expect(captured.records.first?.workspace.gaps == state.workspaces[key]?.gaps) #expect(captured.records.first?.workspace.reservedEdges == state.workspaces[key]?.reservedEdges) try captured.validate() }
@Test func missingMergeRejectsExcessAndCrossWorkspaceInput() throws { let previous = try #require(try capture(original()).records.first) let empty = WorkspaceMemory.Record(workspace: Workspace(key: key)) #expect(throws: WorkspaceMemoryError.invalidWorkspace(key)) { try empty.mergingMissingWindows(from: previous, tokens: [id(1)], maximumCount: 0) } #expect(throws: WorkspaceMemoryError.invalidPruningPolicy) { try empty.mergingMissingWindows(from: previous, tokens: [], maximumCount: -1) } let other = WorkspaceMemory.Record( workspace: Workspace(key: WorkspaceKey(display: display, space: SpaceID(rawValue: 12)))) #expect(throws: WorkspaceMemoryError.invalidWorkspace(key)) { try other.mergingMissingWindows(from: previous, tokens: []) } }
@Test func partiallyIdentifiedOverflowStackRegainsAvailableTiles() throws { let members = (1...13).map { id(UInt32($0)) } let workspace = Workspace(key: key, windowCap: 3, order: members, focus: id(13)) let state = State( displays: [Display(id: display, frame: screen)], activeSpaces: [display: space], workspaces: [key: workspace], windows: Dictionary(uniqueKeysWithValues: (1...13).map { (id(UInt32($0)), window(UInt32($0))) })) let memory = try capture(state) let restored = memory.restoring(live([3, 4, 5, 6])) let partial = try #require(restored.workspaces[key]) #expect(partial.tree?.tileCount == 3) #expect(Set(partial.tree?.windows ?? []) == Set([id(103), id(104), id(105), id(106)])) let persisted = try capture(restored) #expect(persisted.records.first?.workspace.tree?.tileCount == 3) }
@Test func legacySingleTileMemoryRepairsLeastRecentMembersOnLoad() throws { var workspace = Workspace(key: key, windowCap: 3, order: [id(1), id(2), id(3), id(4)], focus: id(4)) var stack = WindowStack(id(1), others: [id(2), id(3), id(4)]) stack.select(id(2)) stack.select(id(4)) workspace.tree = .tile(stack) let state = State( displays: [Display(id: display, frame: screen)], activeSpaces: [display: space], workspaces: [key: workspace], windows: Dictionary(uniqueKeysWithValues: (1...4).map { (id(UInt32($0)), window(UInt32($0))) })) let encoded = try JSONEncoder().encode(try capture(state)) let legacy = String(decoding: encoded, as: UTF8.self) .replacingOccurrences(of: "\"isUserMade\":false,", with: "") .replacingOccurrences(of: ",\"isUserMade\":false", with: "") let decoded = try JSONDecoder().decode(WorkspaceMemory.self, from: Data(legacy.utf8)) let repaired = try #require(decoded.records.first?.workspace) #expect(repaired.tree?.tileCount == 3) #expect(repaired.tree?.stacks.first?.visible == id(4)) #expect(repaired.tree?.stacks.first?.windows == [id(2), id(4)]) #expect(repaired.tree?.stacks.dropFirst().map(\.visible) == [id(3), id(1)]) #expect(repaired.order == workspace.order) #expect(repaired.focus == workspace.focus) }
@Test(arguments: [false, true]) func stackIntentSurvivesLoadAndPartialIdentityRestore(userMade: Bool) throws { var workspace = Workspace(key: key, windowCap: 3, order: (1...4).map { id(UInt32($0)) }, focus: id(4)) var stack = WindowStack(id(1), others: [id(2), id(3), id(4)], isUserMade: userMade) stack.select(id(4)) workspace.tree = .tile(stack) let state = State( displays: [Display(id: display, frame: screen)], activeSpaces: [display: space], workspaces: [key: workspace], windows: Dictionary(uniqueKeysWithValues: (1...4).map { (id(UInt32($0)), window(UInt32($0))) })) let captured = try capture(state) let decoded = try JSONDecoder().decode(WorkspaceMemory.self, from: JSONEncoder().encode(captured)) #expect(decoded.records.first?.workspace.tree?.tileCount == (userMade ? 1 : 3)) #expect(decoded.records.first?.workspace.tree?.firstStack.isUserMade == userMade) let restored = decoded.restoring(live([2, 4])) let partial = try #require(restored.workspaces[key]) #expect(partial.tree?.tileCount == (userMade ? 1 : 2)) #expect(partial.tree?.firstStack.isUserMade == userMade) #expect(partial.focus == id(104)) #expect(partial.order == [id(102), id(104)]) if userMade { #expect(partial.tree?.firstStack.windows == [id(102), id(104)]) } try roundTrip(try capture(restored)) }
@Test func floatingOverflowPolicyDoesNotExpandStoredStacks() throws { var workspace = Workspace(key: key, windowCap: 3, order: [id(1), id(2)], focus: id(2), whenFull: .float) var stack = WindowStack(id(1), others: [id(2)]) stack.select(id(2)) workspace.tree = .tile(stack) let state = State( displays: [Display(id: display, frame: screen)], activeSpaces: [display: space], workspaces: [key: workspace], windows: [id(1): window(1), id(2): window(2)]) let memory = try capture(state) try roundTrip(memory) #expect(memory.restoring(live([1, 2])).workspaces[key]?.tree?.tileCount == 1) }
@Test func stackIdentityRemappingRetainsSurvivorRecencyAndIntent() throws { var stack = WindowStack(id(1), others: [id(2), id(3), id(4)], isUserMade: true) stack.select(id(3)) stack.select(id(2)) let remapped = try #require(stack.memoryRemapping([id(1): id(101), id(3): id(103), id(4): id(104)])) #expect(remapped.isUserMade) #expect(remapped.windows == [id(101), id(103), id(104)]) #expect(remapped.recency == [id(104), id(101), id(103)]) #expect(remapped.visible == id(103)) #expect(try #require(remapped.removing(id(103))).visible == id(101)) #expect(stack.memoryRemapping([:]) == nil) }
@Test(arguments: ["null", "1", "\"true\"", "{}", "[]"]) func presentInvalidStackIntentDoesNotMigrateToAutomatic(intent: String) { let json = "{\"windows\":[1,2],\"visible\":1,\"isUserMade\":\(intent)}" #expect(throws: DecodingError.self) { try JSONDecoder().decode(WindowStack.self, from: Data(json.utf8)) } }
@Test func entirelyMissingUserStackRetainsIntentWhenMergedIntoCurrentMemory() throws { var source = original() var workspace = try #require(source.workspaces[key]) workspace.tree = workspace.tree?.mappingStacks { stack in var marked = stack if stack.windows.contains(id(1)) { marked.isUserMade = true } return marked } source.workspaces[key] = workspace let previous = try capture(source) let partial = previous.restoring(live([2])) let merged = try capture( partial, preserving: previous, pinned: previous.windowMapping(in: partial), preservingMissing: [id(1), id(3)]) let stack = try #require(merged.records.first?.workspace.tree?.stack(containing: id(1))) #expect(stack.isUserMade) #expect(Set(stack.windows) == Set([id(1), id(3)])) try roundTrip(merged) }
@Test func decodingRejectsOutOfBoundsRatioInsteadOfClamping() throws { let data = try JSONEncoder().encode(try capture(original())) let corrupted = String(decoding: data, as: UTF8.self).replacingOccurrences( of: "\"ratio\":0.6", with: "\"ratio\":9") #expect(throws: WorkspaceMemoryError.invalidWorkspace(key)) { try JSONDecoder().decode(WorkspaceMemory.self, from: Data(corrupted.utf8)) } }}