import Foundation import 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: 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..= 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..= 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) }