Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207import Testing
@testable import ParcelCore
struct AdaptiveCommandIntegrationTests { private static let screens = [ Rect(width: 1200, height: 800), Rect(width: 1080, height: 1920), Rect(width: 2560, height: 1080), ]
@Test(arguments: Layout.allCases, screens) func capCommandsKeepRequestsAndClampOnlyEffectiveLimits(layout: Layout, screen: Rect) throws { var state = makeState(layout: layout, screen: screen) for cap in [1, 100, 0] { let result = command(.setWindowCap(cap), in: state) let workspace = try #require(result.0.workspaces[primaryKey]) let requested = cap == 0 ? Int.max : cap let effective = cap == 0 ? Int.max : min(cap, layout.capabilities(in: screen).maximumWindowCount) #expect(workspace.windowCap == requested) #expect(workspace.effectiveWindowCap == effective) #expect(workspace.tree?.tileCount == min(5, effective)) #expect(workspace.tree?.windows == (1...5).map(windowID)) #expect(workspace.openingOrder == (1...5).map(windowID)) #expect(result.1.contains(.announce(.windowCapChanged(cap)))) #expect( result.1.contains(.report(.layoutCapabilityLimit(layout: layout, maximum: effective))) == (effective < requested)) #expect(command(.setWindowCap(cap), in: result.0).1.isEmpty) state = result.0 } let appeared = reduce(state, .windowAppeared(managed(6), workspace: primaryKey, frame: Rect())) #expect(appeared.0.workspaces[primaryKey]?.tree?.tileCount == 6) #expect(appeared.0.windows[windowID(6)]?.isFloating == false) }
@Test(arguments: screens, [MainRatio.threeFifths, .twoThirds]) func resetSizesRestoresConfiguredRatioAndAdaptiveSecondaryDividers(screen: Rect, ratio: MainRatio) throws { let original = makeState(layout: .side, screen: screen, ratio: ratio) var resized = original for path in original.tileEdges.map(\.path) { let edge = try #require(resized.tileEdges.first { $0.path == path }) resized = reduce(resized, .tileEdgeResized(edge, delta: 20)).0 } let result = command(.resetSizes, in: resized) let workspace = try #require(result.0.workspaces[primaryKey]) let path: [TileEdge.Child] = screen.size.width / screen.size.height >= 2 ? [.first] : [] #expect(workspace.ratio == ratio) #expect(workspace.tree?.stacks == original.workspaces[primaryKey]?.tree?.stacks) #expect(workspace.order == original.workspaces[primaryKey]?.order) #expect(workspace.openingOrder == original.workspaces[primaryKey]?.openingOrder) #expect(workspace.alternateSideTree == nil) for edge in result.0.tileEdges { let node = try #require(workspace.tree?.node(at: edge.path[...])) let expected = edge.path == path ? ratio.value : (edge.path.isEmpty ? 0.75 : LayoutEngine.balancedFraction(node)) #expect(edge.fraction == expected) } #expect(result.1.contains(.announce(.sizesReset))) #expect(reduce(result.0, .relayout).0 == result.0) #expect(command(.resetSizes, in: result.0).0 == result.0) let expanded = command(.setWindowCap(0), in: result.0).0 #expect(expanded.workspaces[primaryKey]?.tree?.tileCount == 5) #expect(expanded.workspaces[primaryKey]?.tree?.windows == workspace.tree?.windows) #expect(expanded.workspaces[primaryKey]?.ratio == ratio) }
@Test(arguments: screens, [MainRatio.threeFifths, .twoThirds]) func resettingMainEdgeUsesConfiguredRatioWithoutResettingSecondaryEdges(screen: Rect, ratio: MainRatio) throws { var state = makeState(layout: .side, screen: screen, ratio: ratio) let path: [TileEdge.Child] = screen.size.width / screen.size.height >= 2 ? [.first] : [] let secondary = try #require(state.tileEdges.first { $0.path != path }) state = reduce(state, .tileEdgeResized(secondary, delta: 20)).0 let customFraction = try #require(state.tileEdges.first { $0.path == secondary.path }).fraction state = command(.setRatio(.half), in: state).0 let main = try #require(state.tileEdges.first { $0.path == path }) let result = reduce(state, .tileEdgeReset(main)) #expect(result.0.workspaces[primaryKey]?.ratio == ratio) #expect(result.0.tileEdges.first { $0.path == path }?.fraction == ratio.value) #expect(result.0.tileEdges.first { $0.path == secondary.path }?.fraction == customFraction) }
@Test(arguments: [Layout.columns, .side]) func increasingCapUnstacksAFittingMemberInsteadOfTheOldestConstrainedMember(layout: Layout) throws { let screen = Rect(width: 1512, height: 886) var workspace = Workspace(key: primaryKey, layout: layout, windowCap: 2, order: (1...4).map(windowID)) workspace.adapt(to: screen) var stack = WindowStack(windowID(1), others: [windowID(2), windowID(3)]) stack.select(windowID(3)) workspace.tree = .split( axis: .horizontal, fraction: 0.5, first: .tile(stack), second: .tile(WindowStack(windowID(4)))) workspace.focus = windowID(3) let windows = Dictionary( uniqueKeysWithValues: [ managed(1, minimum: Size(width: 890, height: 552)), managed(2, minimum: Size(width: 840, height: 620)), managed(3, minimum: Size(width: 100, height: 100)), managed(4, minimum: Size(width: 100, height: 100)), ].map { ($0.id, $0) }) let before = reduce( State( displays: [Display(id: primaryDisplay, frame: screen)], activeSpaces: [primaryDisplay: primarySpace], workspaces: [primaryKey: workspace], windows: windows, focusedWindow: windowID(3)), .relayout ).0 let result = command(.setWindowCap(3), in: before) let expanded = try #require(result.0.workspaces[primaryKey]) #expect(expanded.tree?.tileCount == 3) #expect(expanded.tree?.stack(containing: windowID(1))?.windows == [windowID(1), windowID(2)]) #expect(expanded.tree?.stack(containing: windowID(3))?.windows == [windowID(3)]) #expect(expanded.primaryWindow == windowID(1)) #expect(expanded.order == workspace.order) #expect(result.0.cannotFit.isEmpty) #expect(result.0.frames[windowID(1)]?.size.width ?? 0 >= 890) #expect(result.0.frames[windowID(2)]?.size.height ?? 0 >= 620) let restored = command(.undo, in: result.0).0 #expect(restored.workspaces[primaryKey]?.tree == before.workspaces[primaryKey]?.tree) #expect(restored.workspaces[primaryKey]?.windowCap == 2) }
@Test func impossibleCapExpansionKeepsAutomaticMembersTogetherAndReportsTheRefusal() { let screen = Rect(width: 1512, height: 886) var workspace = Workspace(key: primaryKey, layout: .columns, windowCap: 2, order: (1...3).map(windowID)) workspace.adapt(to: screen) workspace.tree = .split( axis: .horizontal, fraction: 0.5, first: .tile(WindowStack(windowID(1), others: [windowID(2)])), second: .tile(WindowStack(windowID(3)))) let windows = Dictionary( uniqueKeysWithValues: (1...3).map { (windowID($0), managed($0, minimum: Size(width: 700, height: 200))) }) let accepted = workspace.setWindowCap(3, in: screen, windows: windows) #expect(!accepted) #expect(workspace.windowCap == 3) #expect(workspace.tree?.tileCount == 2) #expect(LayoutEngine.arrange(workspace, in: screen, windows: windows).cannotFit.isEmpty) }
@Test func minimumAwareCapExpansionNeverSplitsAUserStack() { let screen = Rect(width: 1512, height: 886) var workspace = Workspace(key: primaryKey, layout: .columns, windowCap: 2, order: (1...3).map(windowID)) workspace.adapt(to: screen) workspace.tree = .split( axis: .horizontal, fraction: 0.5, first: .tile(WindowStack(windowID(1), others: [windowID(2)], isUserMade: true)), second: .tile(WindowStack(windowID(3)))) let tree = workspace.tree let accepted = workspace.setWindowCap(3, in: screen, windows: [:]) #expect(accepted) #expect(workspace.tree == tree) }
@Test(arguments: [false, true]) func retileRecoversThreeColumnsAroundHiddenWideMembers(learnMinimum: Bool) throws { let screen = Rect(width: 1512, height: 886) var workspace = Workspace(key: primaryKey, layout: .columns, windowCap: 3, order: (1...4).map(windowID)) workspace.adapt(to: screen) workspace.tree = .split( axis: .horizontal, fraction: 0.5, first: .tile(WindowStack(windowID(1), others: [windowID(2), windowID(3)])), second: .tile(WindowStack(windowID(4)))) var state = State( displays: [Display(id: primaryDisplay, frame: screen)], activeSpaces: [primaryDisplay: primarySpace], workspaces: [primaryKey: workspace], windows: Dictionary( uniqueKeysWithValues: [ managed(1, minimum: Size(width: 890, height: 552)), managed(2, minimum: Size(width: 840, height: 620)), managed(3, minimum: Size(width: 100, height: 100)), managed(4, minimum: Size(width: 100, height: 100)), ].map { ($0.id, $0) })) if learnMinimum { // A new constraint invalidates the current grouping, although three columns still fit. state.workspaces[primaryKey]?.tree = TileTree.balanced( [ WindowStack(windowID(1)), WindowStack(windowID(2), others: [windowID(3)]), WindowStack(windowID(4)), ], layout: .columns) state.windows[windowID(2)]?.minimum = nil state = reduce(state, .relayout).0 state = reduce( state, .minimumSizeChanged(windowID(2), minimum: LearnedMinimumSize(size: Size(width: 840, height: 620))) ).0 } else { state = command(.retile, in: reduce(state, .relayout).0).0 } let recovered = try #require(state.workspaces[primaryKey]) #expect(recovered.tree?.tileCount == 3) #expect(recovered.tree?.stack(containing: windowID(1))?.windows.contains(windowID(2)) == true) #expect(state.cannotFit.isEmpty) #expect(reduce(state, .relayout).0 == state) }
private func makeState(layout: Layout, screen: Rect, ratio: MainRatio = .half) -> State { let workspace = Workspace( key: primaryKey, layout: layout, ratio: ratio, windowCap: 100, order: (1...5).map(windowID)) return reduce( State( displays: [Display(id: primaryDisplay, frame: screen)], activeSpaces: [primaryDisplay: primarySpace], workspaces: [primaryKey: workspace], windows: Dictionary(uniqueKeysWithValues: (1...5).map { (windowID($0), managed($0)) })), .relayout ).0 }}