import Foundation import Testing @testable import ParcelCore @Suite struct AdaptiveWorkspaceMemoryTests { private let display = DisplayID(rawValue: "adaptive-memory") private let space = SpaceID(rawValue: 1) private var key: WorkspaceKey { WorkspaceKey(display: display, space: space) } private let screen = Rect(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) throws -> WorkspaceMemory { try WorkspaceMemory.capture(state, titleSalt: salt) } private func state(offset: UInt32, layout: Layout = .side, cap: Int = 3, count: UInt32 = 3) -> State { let windows = (1...count).map { value in ManagedWindow( id: id(offset + value), app: AppID(pid: Int32(offset + 100), bundleID: "memory.fixture"), title: "Document \(value)") } return State( displays: [Display(id: display, frame: screen)], activeSpaces: [display: space], workspaces: [key: Workspace(key: key, layout: layout, windowCap: cap, order: windows.map(\.id))], windows: Dictionary(uniqueKeysWithValues: windows.map { ($0.id, $0) })) } @Test(arguments: [Layout.side, .columns]) func primaryDesignationAndSideRestoreWithNewWindowIDs(layout: Layout) throws { var before = reduce(state(offset: 100, layout: layout), .relayout).0 before = reduce(before, .commandForWindow(id(103), .makePrimary, workspace: key)).0 let memory = try capture(before) let decoded = try JSONDecoder().decode(WorkspaceMemory.self, from: JSONEncoder().encode(memory)) let restored = reduce(decoded.restoring(state(offset: 200, layout: layout)), .relayout).0 #expect(restored.workspaces[key]?.primaryWindow == id(203)) #expect(restored.workspaces[key]?.layout == layout) for number: UInt32 in 1...3 { #expect(restored.frames[id(200 + number)] == before.frames[id(100 + number)]) } #expect(reduce(restored, .commandForWindow(id(203), .makePrimary, workspace: key)).0.undoHistory == nil) } @Test func capturedAdaptiveTreesUseSavedTokensAndRestoreWithNewLiveIDs() throws { let before = reduce(state(offset: 100), .commandIssued(.setWindowCap(2))).0 let memory = try capture(before) let saved = try #require(memory.records.first?.workspace) #expect(saved.tree?.stacks.map(\.windows) == [[id(1)], [id(2), id(3)]]) #expect(saved.adaptiveTileMemory?.original.windows == [id(1), id(2), id(3)]) #expect(saved.adaptiveTileMemory?.projection.windows == [id(1), id(2), id(3)]) let decoded = try JSONDecoder().decode(WorkspaceMemory.self, from: JSONEncoder().encode(memory)) let restored = decoded.restoring(state(offset: 200)) #expect(restored.workspaces[key]?.adaptiveTileMemory?.original.windows == [id(201), id(202), id(203)]) let expanded = reduce( restored, .workspaceCommandIssued(.setWindowCap(3), workspace: key) ).0 #expect( expanded.workspaces[key]?.tree == .split( axis: .horizontal, fraction: 0.5, first: .tile(WindowStack(id(201))), second: .split( axis: .vertical, fraction: 0.5, first: .tile(WindowStack(id(202))), second: .tile(WindowStack(id(203)))))) #expect(expanded.workspaces[key]?.adaptiveTileMemory == nil) } @Test func unmatchedWindowsDoNotReplaceRememberedTileGroups() throws { let before = reduce(state(offset: 100), .commandIssued(.setWindowCap(2))).0 let memory = try capture(before) let restored = memory.restoring(state(offset: 200, count: 4)) #expect( restored.workspaces[key]?.adaptiveTileMemory?.original.stacks.map(\.windows) == [ [id(201)], [id(202)], [id(203), id(204)], ]) let expanded = reduce(restored, .workspaceCommandIssued(.setWindowCap(3), workspace: key)).0 var expected = memory.restoring(state(offset: 200)) let extra = try #require(state(offset: 200, count: 4).windows[id(204)]) expected = reduce(expected, .windowAppeared(extra, workspace: key, frame: screen)).0 expected = reduce(expected, .workspaceCommandIssued(.setWindowCap(3), workspace: key)).0 #expect(expanded.workspaces[key] == expected.workspaces[key]) #expect( expanded.workspaces[key]?.tree?.stacks.map(\.windows) == [ [id(201)], [id(202)], [id(203), id(204)], ]) try capture(expanded).validate() } @Test func mergingMissingAdaptiveWindowsKeepsTheirExpandableSlotsAndCurrentSettings() throws { let before = reduce(state(offset: 100), .commandIssued(.setWindowCap(2))).0 let memory = try capture(before) var partial = memory.restoring(state(offset: 200, count: 2)) partial.workspaces[key]?.changeRatio(.twoThirds) let pinned = memory.windowMapping(in: partial) let captured = try WorkspaceMemory.capture( partial, preserving: memory, now: 1, pinned: pinned, preservingMissing: [id(3)]) let saved = try #require(captured.records.first?.workspace) #expect(saved.ratio == .twoThirds) #expect(saved.windowCap == 2) #expect(saved.tree?.stacks.map(\.windows) == [[id(1)], [id(2), id(3)]]) #expect(saved.adaptiveTileMemory?.original.stacks.map(\.windows) == [[id(1)], [id(2)], [id(3)]]) let restored = captured.restoring(state(offset: 300)) let expanded = reduce(restored, .workspaceCommandIssued(.setWindowCap(3), workspace: key)).0 #expect(expanded.workspaces[key]?.tree?.stacks.map(\.windows) == [[id(301)], [id(302)], [id(303)]]) #expect(expanded.workspaces[key]?.ratio == .twoThirds) try capture(expanded).validate() } @Test func delayedMatchesPruneBothRememberedTreesWithoutResurrectingMissingWindows() throws { let before = reduce(state(offset: 100), .commandIssued(.setWindowCap(2))).0 let memory = try capture(before) let partial = memory.restoring(state(offset: 200, count: 1)) let workspace = try #require(partial.workspaces[key]) #expect(workspace.order == [id(201)]) #expect(workspace.tree?.windows == [id(201)]) #expect(workspace.adaptiveTileMemory == nil) try capture(partial).validate() let complete = memory.restoring(state(offset: 200)) #expect(complete.workspaces[key]?.tree?.stacks.map(\.windows) == [[id(201)], [id(202), id(203)]]) #expect(complete.workspaces[key]?.adaptiveTileMemory?.original.tileCount == 3) } @Test(arguments: [false, true], [Rect(width: 1200, height: 800), Rect(width: 800, height: 1200)]) func partiallyIdentifiedSideOverflowPromotesANewPrimary(adaptive: Bool, screen: Rect) throws { var before = state(offset: 100) before.displays[display] = Display(id: display, frame: screen) before.workspaces[key]?.adapt(to: screen) before.workspaces[key]?.changeRatio(MainRatio(0.55)) before = reduce(before, .commandIssued(.setWindowCap(2))).0 if !adaptive { before.workspaces[key]?.adaptiveTileMemory = nil } let memory = try JSONDecoder().decode(WorkspaceMemory.self, from: JSONEncoder().encode(capture(before))) var live = state(offset: 200) live.displays[display] = Display(id: display, frame: screen) live.workspaces[key]?.remove(id(201)) live.windows[id(201)] = nil let restored = memory.restoring(live) let workspace = try #require(restored.workspaces[key]) #expect(workspace.layout == .side) #expect(workspace.ratio == MainRatio(0.55)) #expect(workspace.windowCap == 2) #expect(workspace.order == [id(202), id(203)]) #expect(workspace.tree?.tileCount == 2) let frames = LayoutEngine.arrange(workspace, in: screen).frames.values.sorted { screen.size.width > screen.size.height ? $0.minX < $1.minX : $0.minY < $1.minY } let expected = screen.size.width > screen.size.height ? [Rect(width: 660, height: 800), Rect(x: 660, y: 0, width: 540, height: 800)] : [Rect(width: 800, height: 660), Rect(x: 0, y: 660, width: 800, height: 540)] #expect(frames == expected) try capture(restored).validate() let complete = memory.restoring(state(offset: 300)) #expect(complete.workspaces[key]?.tree?.stacks.map(\.windows) == [[id(301)], [id(302), id(303)]]) #expect(complete.workspaces[key]?.mainSizeRatio == 0.55) } @Test func missingSidePrimaryDoesNotSplitAUserMadeSidebar() throws { var before = state(offset: 100, cap: 2) let tree = before.workspaces[key]?.tree before.workspaces[key]?.tree = tree?.mappingStacks { stack in var marked = stack if stack.windows.count > 1 { marked.isUserMade = true } return marked } let memory = try JSONDecoder().decode(WorkspaceMemory.self, from: JSONEncoder().encode(capture(before))) var live = state(offset: 200) live.workspaces[key]?.remove(id(201)) live.windows[id(201)] = nil let restored = memory.restoring(live) let workspace = try #require(restored.workspaces[key]) #expect(workspace.tree?.tileCount == 1) #expect(workspace.tree?.firstStack.isUserMade == true) #expect(workspace.tree?.windows == [id(202), id(203)]) let frames = LayoutEngine.arrange(workspace, in: screen).frames #expect(frames.count == 2) #expect(frames.values.allSatisfy { $0 == screen }) try capture(restored).validate() } @Test func validationAndRestoreUseFullDisplayCapabilities() throws { let usable = Rect(width: 1600, height: 800) let full = Rect(width: 1600, height: 1200) var original = state(offset: 0, layout: .columns, cap: 4, count: 4) original.displays[display] = Display(id: display, frame: usable, fullFrame: full) original.workspaces[key]?.adapt(to: usable, fullFrame: full) let memory = try capture(original) try roundTrip(memory) let saved = try #require(memory.records.first?.workspace) #expect(saved.displaySize == Size(width: 1600, height: 800)) #expect(saved.capabilitySize == Size(width: 1600, height: 1200)) #expect(saved.effectiveWindowCap == 4) var live = state(offset: 200, layout: .columns, cap: 4, count: 4) live.displays[display] = Display(id: display, frame: usable, fullFrame: full) live.workspaces[key]?.adapt(to: usable, fullFrame: full) for restoreWindows in [false, true] { let restored = memory.restoring(live, restoreWindows: restoreWindows) #expect(restored.workspaces[key]?.tree?.tileCount == 4) #expect(restored.workspaces[key]?.effectiveWindowCap == 4) #expect(restored.workspaces[key]?.capabilitySize == Size(width: 1600, height: 1200)) } } @Test func usableAspectRatioDoesNotInvalidateAFullDisplayVariant() throws { var original = state(offset: 0) let usable = Rect(width: 1800, height: 800) let full = Rect(width: 1800, height: 1200) original.displays[display] = Display(id: display, frame: usable, fullFrame: full) original.workspaces[key]?.adapt(to: usable, fullFrame: full) let memory = try capture(original) #expect(memory.records.first?.workspace.layoutVariant == .standard) try roundTrip(memory) let restored = memory.restoring(original) #expect(restored.workspaces[key]?.layoutVariant == .standard) #expect(restored.workspaces[key]?.alternateSideTree == nil) } @Test func alternateSideTopologyCanExceedTheCurrentRequestedCap() throws { var original = state(offset: 0) original.workspaces[key]?.adapt(to: Rect(width: 2400, height: 1000)) original.workspaces[key]?.adapt(to: screen) original = reduce(original, .workspaceCommandIssued(.setWindowCap(2), workspace: key)).0 let memory = try capture(original) #expect(memory.records.first?.workspace.windowCap == 2) #expect(memory.records.first?.workspace.alternateSideTree?.tileCount == 3) try roundTrip(memory) } @Test(arguments: [false, true]) func settingsRestoreKeepsAnExplicitLayoutExplicitBeforeWindowsArrive(restoreWindows: Bool) throws { let memory = try capture(state(offset: 0, layout: .columns)) let portrait = Rect(width: 800, height: 1200) let live = State(displays: [Display(id: display, frame: portrait)], activeSpaces: [display: space]) let restored = memory.restoring(live, restoreWindows: restoreWindows) #expect(restored.workspaces[key]?.layout == .columns) #expect(restored.workspaces[key]?.layoutDefaults == nil) #expect(restored.workspaces[key]?.layoutVariant == .portrait) #expect(restored.workspaces[key]?.order.isEmpty == true) } @Test func settingsOnlyRestoreKeepsSavedDefaultFollowing() throws { var original = state(offset: 0, layout: .columns) original.workspaces[key]?.layoutDefaults = LayoutDefaults(landscape: .columns, portrait: .side) let memory = try capture(original) let portrait = Rect(width: 800, height: 1200) let live = State(displays: [Display(id: display, frame: portrait)], activeSpaces: [display: space]) let restored = memory.restoring(live, restoreWindows: false) #expect(restored.workspaces[key]?.layout == .side) #expect(restored.workspaces[key]?.layoutDefaults == LayoutDefaults(landscape: .columns, portrait: .side)) } @Test(arguments: ["capability-size", "adaptive-original", "adaptive-projection"]) func invalidAdaptiveRecordsAreRejected(component: String) throws { let before = reduce(state(offset: 0), .commandIssued(.setWindowCap(2))).0 let record = try #require(try capture(before).records.first) var workspace = record.workspace switch component { case "capability-size": workspace.capabilitySize = Size(width: .infinity, height: 800) case "adaptive-original": workspace.adaptiveTileMemory?.original = .tile(WindowStack(id(999))) default: workspace.adaptiveTileMemory?.projection = .tile(WindowStack(id(999))) } #expect(throws: WorkspaceMemoryError.invalidWorkspace(key)) { try WorkspaceMemory(records: [.init(workspace: workspace, windows: record.windows)], titleSalt: salt) } } @Test func recordsWithoutAdaptiveFieldsStillDecodeAndRestore() throws { let record = try #require(try capture(state(offset: 0, layout: .columns)).records.first) let legacy = LegacyMemory( titleSalt: salt, records: [LegacyMemory.Record(workspace: LegacyMemory.Workspace(key: key), windows: record.windows)]) let decoded = try JSONDecoder().decode(WorkspaceMemory.self, from: JSONEncoder().encode(legacy)) #expect(decoded.records.first?.workspace.displaySize == nil) #expect(decoded.records.first?.workspace.capabilitySize == nil) #expect(decoded.records.first?.workspace.layoutDefaults == nil) let restored = decoded.restoring(state(offset: 200)) #expect(restored.workspaces[key]?.layout == .columns) #expect(restored.workspaces[key]?.order == [id(201), id(202), id(203)]) #expect(restored.workspaces[key]?.displaySize == Size(width: 1200, height: 800)) #expect(restored.workspaces[key]?.capabilitySize == Size(width: 1200, height: 800)) } } private struct LegacyMemory: Encodable { struct Record: Encodable { let workspace: Workspace let windows: [WorkspaceMemory.SavedWindow] let lastSeen: TimeInterval = 0 } struct Workspace: Encodable { let key: WorkspaceKey let layout = Layout.columns let ratio = MainRatio.half let gaps = Gaps() let reservedEdges = Insets() let windowCap = 3 let order = [WindowID(rawValue: 1), WindowID(rawValue: 2), WindowID(rawValue: 3)] let tree = TileTree.split( axis: .horizontal, fraction: 1.0 / 3, first: .tile(WindowStack(WindowID(rawValue: 1))), second: .split( axis: .horizontal, fraction: 0.5, first: .tile(WindowStack(WindowID(rawValue: 2))), second: .tile(WindowStack(WindowID(rawValue: 3))))) } let titleSalt: Data let records: [Record] }