Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235import Testing
@testable import ParcelCore
@Suite struct TreeTransformsTests { private func tile(_ number: UInt32) -> TileTree { .tile(WindowStack(WindowID(rawValue: number))) }
private func fixture() -> TileTree { var stack = WindowStack(WindowID(rawValue: 1), others: [WindowID(rawValue: 6)]) stack.select(WindowID(rawValue: 6)) return .split( axis: .horizontal, fraction: 0.25, first: .partition( axis: .vertical, fraction: 0.375, first: .tile(stack), second: .split(axis: .horizontal, fraction: 0.25, first: tile(2), second: tile(3))), second: .partition(axis: .horizontal, fraction: 0.625, first: tile(4), second: tile(5))) }
private func expectEquivalent(_ actual: TileTree, _ expected: TileTree) { switch (actual, expected) { case (.tile(let left), .tile(let right)): #expect(left == right) case ( .split(let leftAxis, let leftFraction, let leftFirst, let leftSecond), .split(let rightAxis, let rightFraction, let rightFirst, let rightSecond) ), ( .partition(let leftAxis, let leftFraction, let leftFirst, let leftSecond), .partition(let rightAxis, let rightFraction, let rightFirst, let rightSecond) ): #expect(leftAxis == rightAxis) #expect(abs(leftFraction - rightFraction) < 1e-14) expectEquivalent(leftFirst, rightFirst) expectEquivalent(leftSecond, rightSecond) default: Issue.record("Tree node kinds differ") } }
@Test func leafTransformationsPreserveTheWholeStack() { var stack = WindowStack(WindowID(rawValue: 1), others: [WindowID(rawValue: 2)]) stack.select(WindowID(rawValue: 2)) let tree = TileTree.tile(stack) #expect(tree.balancedSplits() == tree) #expect(tree.rotatedClockwise() == tree) #expect(tree.mirrored(along: .horizontal) == tree) #expect(tree.mirrored(along: .vertical) == tree) }
@Test func balanceCountsTilesRatherThanWindowsAtEveryNode() { let original = fixture() let stack = original.stacks[0] let expected = TileTree.split( axis: .horizontal, fraction: 3.0 / 5, first: .partition( axis: .vertical, fraction: 1.0 / 3, first: .tile(stack), second: .split(axis: .horizontal, fraction: 0.5, first: tile(2), second: tile(3))), second: .partition(axis: .horizontal, fraction: 0.5, first: tile(4), second: tile(5))) let balanced = original.balancedSplits() #expect(balanced == expected) #expect(balanced.balancedSplits() == balanced) #expect(original == fixture()) #expect(balanced.stacks == original.stacks) #expect(balanced.visibleWindows == original.visibleWindows) }
@Test func clockwiseRotationChangesAxesAndReversesVerticalNodes() { let original = fixture() let expected = TileTree.split( axis: .vertical, fraction: 0.25, first: .partition( axis: .horizontal, fraction: 0.625, first: .split(axis: .vertical, fraction: 0.25, first: tile(2), second: tile(3)), second: .tile(original.stacks[0])), second: .partition(axis: .vertical, fraction: 0.625, first: tile(4), second: tile(5))) #expect(original.rotatedClockwise() == expected) #expect(original == fixture()) }
@Test func horizontalMirrorReversesOnlyHorizontalNodes() { let original = fixture() let expected = TileTree.split( axis: .horizontal, fraction: 0.75, first: .partition(axis: .horizontal, fraction: 0.375, first: tile(5), second: tile(4)), second: .partition( axis: .vertical, fraction: 0.375, first: .tile(original.stacks[0]), second: .split(axis: .horizontal, fraction: 0.75, first: tile(3), second: tile(2)))) #expect(original.mirrored(along: .horizontal) == expected) }
@Test func verticalMirrorReversesOnlyVerticalNodes() { let original = fixture() let expected = TileTree.split( axis: .horizontal, fraction: 0.25, first: .partition( axis: .vertical, fraction: 0.625, first: .split(axis: .horizontal, fraction: 0.25, first: tile(2), second: tile(3)), second: .tile(original.stacks[0])), second: .partition(axis: .horizontal, fraction: 0.625, first: tile(4), second: tile(5))) #expect(original.mirrored(along: .vertical) == expected) }
@Test(arguments: [Axis.horizontal, .vertical], [false, true]) func simpleNodesPreserveTheirKind(axis: Axis, partition: Bool) { let first = tile(1) let second = tile(2) let tree: TileTree = partition ? .partition(axis: axis, fraction: 0.125, first: first, second: second) : .split(axis: axis, fraction: 0.125, first: first, second: second) let rotatedAxis: Axis = axis == .horizontal ? .vertical : .horizontal let reversed = axis == .vertical let rotatedFirst = reversed ? second : first let rotatedSecond = reversed ? first : second let rotatedFraction = reversed ? 0.875 : 0.125 let rotated: TileTree = partition ? .partition(axis: rotatedAxis, fraction: rotatedFraction, first: rotatedFirst, second: rotatedSecond) : .split(axis: rotatedAxis, fraction: rotatedFraction, first: rotatedFirst, second: rotatedSecond) let mirrored: TileTree = partition ? .partition(axis: axis, fraction: 0.875, first: second, second: first) : .split(axis: axis, fraction: 0.875, first: second, second: first) let balanced: TileTree = partition ? .partition(axis: axis, fraction: 0.5, first: first, second: second) : .split(axis: axis, fraction: 0.5, first: first, second: second) #expect(tree.rotatedClockwise() == rotated) #expect(tree.mirrored(along: axis) == mirrored) #expect(tree.mirrored(along: rotatedAxis) == tree) #expect(tree.balancedSplits() == balanced) }
@Test(arguments: [Axis.horizontal, .vertical]) func mirroringTwiceRestoresTree(axis: Axis) { for tree in [fixture(), decimalFractionTree()] { expectEquivalent(tree.mirrored(along: axis).mirrored(along: axis), tree) } }
@Test func fourRotationsRestoreTree() { for tree in [fixture(), decimalFractionTree()] { let rotated = tree.rotatedClockwise().rotatedClockwise().rotatedClockwise().rotatedClockwise() expectEquivalent(rotated, tree) } }
@Test(arguments: [Axis.horizontal, .vertical]) func thousandTileMixedChainsTransformOnWorkerStack(axis: Axis) async { let checks = await onTraversalWorkerStack { let count = 1000 let ids = (1...count).map { WindowID(rawValue: UInt32($0)) } var tree = TileTree.tile(WindowStack(ids[count - 1])) for index in (0..<(count - 1)).reversed() { let first = TileTree.tile(WindowStack(ids[index])) tree = index.isMultiple(of: 2) ? .split(axis: axis, fraction: 0.25, first: first, second: tree) : .partition(axis: axis, fraction: 0.375, first: first, second: tree) } let balanced = tree.balancedSplits() let rotated = tree.rotatedClockwise() let mirrored = tree.mirrored(along: axis) var node = balanced var validFractions = true for remaining in stride(from: count, through: 2, by: -1) { switch node { case .tile: validFractions = false case .split(let balancedAxis, let fraction, let first, let second), .partition(let balancedAxis, let fraction, let first, let second): validFractions = validFractions && balancedAxis == axis && fraction == 1 / Double(remaining) && first.tileCount == 1 node = second } } let restored = rotated.rotatedClockwise().rotatedClockwise().rotatedClockwise() return [ validFractions && node == .tile(WindowStack(ids[count - 1])), balanced.hasSameTopology(as: tree) && balanced.windows == ids && balanced != tree, balanced.balancedSplits() == balanced, restored == tree, mirrored.windows == Array(ids.reversed()) && mirrored.mirrored(along: axis) == tree, tree.mirrored(along: axis == .horizontal ? .vertical : .horizontal) == tree, ] } #expect(checks.count == 6) for (index, passed) in checks.enumerated() { #expect(passed, "Worker-stack transform check \(index) failed") } }
private func decimalFractionTree() -> TileTree { .partition( axis: .vertical, fraction: 0.1, first: tile(1), second: .split(axis: .horizontal, fraction: 0.3, first: tile(2), second: tile(3))) }
private func frames(_ tree: TileTree, width: Double, height: Double) -> [WindowID: Rect] { var workspace = workspace(0, layout: .tree) workspace.tree = tree let screen = Rect(width: width, height: height) workspace.adapt(to: screen) return LayoutEngine.arrangeUnrounded(workspace, in: screen, windows: [:]).frames }
@Test func transformationsMatchSpatialGeometry() throws { let tree = fixture() let original = frames(tree, width: 800, height: 400) let rotated = frames(tree.rotatedClockwise(), width: 400, height: 800) let horizontal = frames(tree.mirrored(along: .horizontal), width: 800, height: 400) let vertical = frames(tree.mirrored(along: .vertical), width: 800, height: 400) #expect(original.count == 6) #expect(rotated.count == original.count) #expect(horizontal.count == original.count) #expect(vertical.count == original.count) for (window, frame) in original { let rotatedFrame = Rect( x: 400 - frame.maxY, y: frame.minX, width: frame.size.height, height: frame.size.width) let horizontalFrame = Rect( x: 800 - frame.maxX, y: frame.minY, width: frame.size.width, height: frame.size.height) let verticalFrame = Rect( x: frame.minX, y: 400 - frame.maxY, width: frame.size.width, height: frame.size.height) #expect(try #require(rotated[window]) == rotatedFrame) #expect(try #require(horizontal[window]) == horizontalFrame) #expect(try #require(vertical[window]) == verticalFrame) } }}