Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317import Foundationimport Testing
@testable import ParcelCore
func windowID(_ number: Int) -> WindowID { WindowID(rawValue: UInt32(number)) }let primaryDisplay = DisplayID(rawValue: "00000000-0000-0000-0000-000000000001")let primarySpace = SpaceID(rawValue: 1)let primaryKey = WorkspaceKey(display: primaryDisplay, space: primarySpace)let testScreen = Rect(x: 0, y: 0, width: 1200, height: 800)
func managed(_ number: Int, minimum: Size? = nil, floating: Bool = false) -> ManagedWindow { ManagedWindow( id: windowID(number), app: AppID(pid: Int32(number), bundleID: "test.fixture"), title: "Window \(number)", minimumSize: minimum, isFloating: floating )}
func workspace(_ count: Int, layout: Layout = .grid, gaps: Gaps = Gaps(), cap: Int = 8) -> Workspace { Workspace( key: primaryKey, layout: layout, gaps: gaps, windowCap: cap, order: (1...max(1, count)).prefix(count).map(windowID))}
func layoutTree(_ count: Int, layout: Layout, gaps: Gaps = Gaps()) -> Workspace { var space = workspace(count, layout: layout, gaps: gaps) if !layout.preservesTree { space.layout = .tree } return space}
func populatedTree(_ count: Int, layout: Layout) -> State { stateWithWorkspace(layoutTree(count, layout: layout))}
func stateWithWorkspace(_ space: Workspace, screen: Rect = testScreen) -> State { reduce( State( displays: [Display(id: primaryDisplay, frame: screen)], activeSpaces: [primaryDisplay: primarySpace], workspaces: [primaryKey: space], windows: Dictionary(uniqueKeysWithValues: space.order.map { ($0, managed(Int($0.rawValue))) })), .relayout ).0}
func roundTrip<Value: Codable & Equatable>(_ value: Value) throws { #expect(try JSONDecoder().decode(Value.self, from: JSONEncoder().encode(value)) == value)}
@Test func geometryValues() throws { let point = Point(x: -50, y: 70) let size = Size(width: 400, height: 300) let rect = Rect(origin: point, size: size) #expect(rect.minX == -50) #expect(rect.maxX == 350) #expect(rect.minY == 70) #expect(rect.maxY == 370) #expect(rect.center == Point(x: 150, y: 220)) #expect(rect.contains(Point(x: 350, y: 370))) #expect(!rect.contains(Point(x: 351, y: 370))) try roundTrip(point) try roundTrip(size) try roundTrip(rect) try roundTrip(Insets(3))}
@Test func insetClampsExcessAndNegativeValues() { #expect( testScreen.inset(by: Insets(top: 20, left: 30, bottom: 40, right: 50)) == Rect(x: 30, y: 20, width: 1120, height: 740)) #expect(testScreen.inset(by: Insets(2000)) == Rect(x: 1200, y: 800, width: 0, height: 0)) #expect(testScreen.inset(by: Insets(-10)) == testScreen) #expect(Rect(width: -2, height: -3).inset(by: Insets()) == Rect())}
@Test func roundingUsesEdgesInGlobalCoordinates() { #expect( Rect(x: -0.6, y: 0.6, width: 10.2, height: 10.2).roundedToWholePoints() == Rect(x: -1, y: 1, width: 11, height: 10))}
@Test func identifiersAndWindowMetadata() throws { try roundTrip(windowID(3)) try roundTrip(primaryDisplay) try roundTrip(primarySpace) try roundTrip(primaryKey) var window = managed(1, minimum: Size(width: 300, height: 200), floating: true) window.subrole = "AXStandardWindow" #expect(window.minimum?.schemaVersion == 1) #expect(window.minimumSize == Size(width: 300, height: 200)) try roundTrip(window) window.minimum = nil #expect(window.minimumSize == nil) #expect(windowID(1) < windowID(2)) #expect(primarySpace < SpaceID(rawValue: 2))}
@Test(arguments: [-10.0, 0.2, 0.5, 0.6, 2.0 / 3, 0.8, 10.0])func ratiosClampAndEncode(value: Double) throws { let ratio = MainRatio(value) #expect(ratio.value == min(0.8, max(0.2, value))) try roundTrip(ratio) #expect(try JSONDecoder().decode(MainRatio.self, from: Data("10".utf8)) == MainRatio(0.8)) #expect(MainRatio.half.value == 0.5) #expect(MainRatio.threeFifths.value == 0.6) #expect(MainRatio.twoThirds.value == 2.0 / 3)}
@Test(arguments: [Layout.grid, .columns, .rows, .side], 1...8)func canonicalTreePixels(layout: Layout, count: Int) { var space = layoutTree(count, layout: layout) space.adapt(to: testScreen) let frames = LayoutEngine.arrange(space, in: testScreen).frames #expect(frames.count == count) for index in 0..<count { let expected: Rect switch layout { case .columns: let start = (1200 * Double(index) / Double(count)).rounded() let end = (1200 * Double(index + 1) / Double(count)).rounded() expected = Rect(x: start, y: 0, width: end - start, height: 800) case .rows: let start = (800 * Double(index) / Double(count)).rounded() let end = (800 * Double(index + 1) / Double(count)).rounded() expected = Rect(x: 0, y: start, width: 1200, height: end - start) case .side: if count == 1 { expected = testScreen } else if index == 0 { expected = Rect(x: 0, y: 0, width: 600, height: 800) } else { let start = (800 * Double(index - 1) / Double(count - 1)).rounded() let end = (800 * Double(index) / Double(count - 1)).rounded() expected = Rect(x: 600, y: start, width: 600, height: end - start) } case .grid: let columns = Int(Double(count).squareRoot().rounded(.up)) let rows = (count + columns - 1) / columns let row = index / columns let column = index % columns let rowCount = min(columns, count - row * columns) let left = (1200 * Double(column) / Double(rowCount)).rounded() let right = (1200 * Double(column + 1) / Double(rowCount)).rounded() let top = (800 * Double(row) / Double(rows)).rounded() let bottom = (800 * Double(row + 1) / Double(rows)).rounded() expected = Rect(x: left, y: top, width: right - left, height: bottom - top) case .tree, .bsp, .accordion: preconditionFailure("No canonical pixel formula for \(layout)") } #expect(frames[windowID(index + 1)] == expected) }}
@Test(arguments: Layout.allCases.filter { ![Layout.grid, .columns, .rows, .side].contains($0) }, 1...8)func gapsReservedEdgesAndNegativeOrigins(layout: Layout, count: Int) { var space = layoutTree(count, layout: layout, gaps: Gaps(inner: 12, outer: Insets(8))) space.reservedEdges = Insets(top: 24, left: 10, bottom: 6, right: 20) let screen = Rect(x: -1200, y: -800, width: 1200, height: 800) space.adapt(to: screen) let frames = LayoutEngine.arrange(space, in: screen).frames let area = Rect(x: -1182, y: -768, width: 1154, height: 754) for frame in frames.values { #expect(frame.minX >= area.minX && frame.maxX <= area.maxX) #expect(frame.minY >= area.minY && frame.maxY <= area.maxY) #expect(frame.minX == frame.minX.rounded()) #expect(frame.size.width >= 0 && frame.size.height >= 0) } if count == 1 { #expect(frames[windowID(1)] == area) } if layout == .columns && count > 1 { for number in 1..<count { if let first = frames[windowID(number)], let second = frames[windowID(number + 1)] { #expect(second.minX - first.maxX == 12) } } }}
@Test(arguments: Layout.allCases, 1...8)func excessiveGapsRemainOnScreen(layout: Layout, count: Int) { var space = layoutTree(count, layout: layout, gaps: Gaps(inner: 2000, outer: Insets(2))) let screen = Rect(width: 30, height: 20) space.adapt(to: screen) let frames = LayoutEngine.arrange(space, in: screen).frames #expect(frames.count == count) for frame in frames.values { #expect(frame.size.width >= 0 && frame.size.height >= 0) #expect(frame.minX >= 2 && frame.maxX <= 28) #expect(frame.minY >= 2 && frame.maxY <= 18) }}
@Test(arguments: [MainRatio.half, .threeFifths, .twoThirds], 2...8)func sideRatioPixels(ratio: MainRatio, count: Int) { var space = workspace(count, layout: .side) space.ratio = ratio space.rebuild(stacks: space.tree?.stacks ?? []) space.layout = .tree space.adapt(to: testScreen) let result = LayoutEngine.arrange(space, in: testScreen) #expect(result.frames[windowID(1)] == Rect(width: (1200 * ratio.value).rounded(), height: 800)) #expect(result.cannotFit.isEmpty)}
@Test func minimumSizesShiftDividerWithoutLeavingScreen() { var space = workspace(2, layout: .columns) space.adapt(to: testScreen) let windows = [windowID(1): managed(1, minimum: Size(width: 900, height: 400)), windowID(2): managed(2)] let result = LayoutEngine.arrange(space, in: testScreen, windows: windows) #expect(result.frames[windowID(1)] == Rect(width: 900, height: 800)) #expect(result.frames[windowID(2)] == Rect(x: 900, width: 300, height: 800)) #expect(result.cannotFit.isEmpty)}
@Test(arguments: Layout.allCases)func impossibleMinimumSizesAreReported(layout: Layout) { var space = workspace(3, layout: layout) space.adapt(to: testScreen) let windows = Dictionary( uniqueKeysWithValues: (1...3).map { (windowID($0), managed($0, minimum: Size(width: 1500, height: 900))) }) let result = LayoutEngine.arrange(space, in: testScreen, windows: windows) #expect(result.cannotFit == (1...3).map(windowID)) for frame in result.frames.values { #expect(frame.minX >= 0 && frame.maxX <= 1200) #expect(frame.minY >= 0 && frame.maxY <= 800) }}
@Test(arguments: Layout.allCases, 1...4)func capStacksOverflow(layout: Layout, cap: Int) throws { var space = workspace(8, layout: layout, cap: cap) space.adapt(to: testScreen) let cap = min(cap, layout.capabilities(in: testScreen).maximumWindowCount) #expect(space.tree?.tileCount == cap) #expect(space.tree?.windows == (1...8).map(windowID)) let result = LayoutEngine.arrange(space, in: testScreen) for number in cap...8 { #expect(result.frames[windowID(number)] == result.frames[windowID(cap)]) } #expect(result.visibleWindows.last == windowID(8)) try roundTrip(space)}
@Test func stackMinimumIncludesHiddenMembers() { var space = workspace(3, layout: .columns, cap: 2) space.adapt(to: testScreen) let windows = [windowID(2): managed(2, minimum: Size(width: 850, height: 10))] let result = LayoutEngine.arrange(space, in: testScreen, windows: windows) #expect(result.frames[windowID(2)]?.size.width == 850) #expect(result.frames[windowID(3)] == result.frames[windowID(2)])}
@Test func emptyWorkspaceAndClampedCap() { #expect(LayoutEngine.arrange(workspace(0), in: testScreen) == LayoutResult()) var space = workspace(3, cap: 0) #expect(space.windowCap == 1) space.setWindowCap(2) #expect(space.tree?.tileCount == 2) #expect(space.order == (1...3).map(windowID))}
@Test( arguments: [ Rect(), Rect(width: 1200), Rect(height: 800), Rect(width: -1, height: 800), Rect(width: 1200, height: -1), Rect(x: .nan, width: 1200, height: 800), Rect(y: .infinity, width: 1200, height: 800), Rect(width: .infinity, height: 800), Rect(width: 1200, height: .nan), ])func invalidOrEmptyScreensHaveNoLayoutOrEdges(screen: Rect) { let space = workspace(2, layout: .columns) #expect(LayoutEngine.arrange(space, in: screen) == LayoutResult()) #expect(LayoutEngine.edges(space, in: screen).isEmpty)}
@Test func layoutQueriesUseTheMaterializedTreeAndItsPaths() throws { let screen = Rect(width: 800, height: 1200) var space = workspace(3, layout: .side) space.adapt(to: screen) let tree = try #require(space.tree) let result = LayoutEngine.arrange(space, in: screen) #expect(space.tree == tree) for edge in LayoutEngine.edges(space, in: screen) { #expect(edge.topology == tree) let node = try #require(tree.node(at: edge.path[...])) #expect(node.windows == edge.affectedWindows) #expect(edge.affectedWindows.allSatisfy { result.frames[$0] != nil }) }}
@Test(arguments: [Layout.grid, .columns, .rows, .side])func insertionSplitsOnlyNewestArea(layout: Layout) { var space = workspace(0, layout: layout) space.adapt(to: testScreen) space.insert(windowID(1), floating: false, in: testScreen, windows: [:]) #expect(LayoutEngine.arrange(space, in: testScreen).frames[windowID(1)] == testScreen) space.insert(windowID(2), floating: false, in: testScreen, windows: [:]) let before = LayoutEngine.arrange(space, in: testScreen).frames space.insert(windowID(3), floating: false, in: testScreen, windows: [:]) let after = LayoutEngine.arrange(space, in: testScreen).frames #expect(after[windowID(1)] == before[windowID(1)]) let expected: Rect switch layout { case .columns: expected = Rect(x: 900, width: 300, height: 800) case .rows: expected = Rect(y: 400, width: 1200, height: 400) case .grid, .side: expected = Rect(x: 600, y: 400, width: 600, height: 400) case .tree, .bsp, .accordion: preconditionFailure("No insertion pixel formula for \(layout)") } #expect(after[windowID(3)] == expected) #expect(space.order == (1...3).map(windowID))}
@Test func removingLeafCollapsesItsSplit() { var space = workspace(3, layout: .columns) space.remove(windowID(2)) #expect(space.tree?.tileCount == 2) #expect(space.order == [windowID(1), windowID(3)]) space.adapt(to: testScreen) #expect(LayoutEngine.arrange(space, in: testScreen).frames[windowID(3)] == Rect(x: 400, width: 800, height: 800)) space.remove(windowID(1)) #expect(LayoutEngine.arrange(space, in: testScreen).frames[windowID(3)] == testScreen)}