Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537import Foundationimport ParcelConfigimport ParcelCoreimport Testing
@testable import ParcelEngine
@MainActorstruct WorkspaceTransactionTests { @Test(arguments: [ "login", "highlight", "width", "motion", "mouse", "swap", "stack", "hover", "accessibility", "privacy", "shortcuts", ]) func configurationOnlyEditDoesNotScheduleLayout(field: String) async throws { let harness = try EngineHarness() try await harness.start() try harness.add([1, 2]) let passes = harness.engine.layoutPassCount let scheduled = harness.scheduler.scheduledCount let writes = harness.world.allWrites.count let state = harness.engine.snapshot.state var config = harness.engine.configuration switch field { case "login": config.general.launchAtLogin.toggle() case "highlight": config.motion.highlight = .glow case "width": config.motion.highlightWidth = 5 case "motion": config.motion.enabled.toggle() case "mouse": config.mouse.enabled.toggle() case "swap": config.mouse.swapModifiers = .control case "stack": config.mouse.stackModifiers = .shift case "hover": config.hoverBar.enabled.toggle() case "accessibility": config.accessibility.announceLayoutChanges.toggle() case "privacy": config.focusModes.noPeekLevel = 0.3 case "shortcuts": config.keybindings.removeAll() default: Issue.record("Unknown configuration fixture") } try harness.engine.applyConfiguration(config) #expect(harness.engine.configuration == config) #expect(harness.engine.snapshot.state == state) #expect(harness.engine.layoutPassCount == passes) #expect(harness.scheduler.scheduledCount == scheduled) #expect(harness.world.allWrites.count == writes) #expect(harness.engine.isIdle) await harness.engine.stop() }
@Test func idleMouseCancellationDoesNotScheduleLayout() async throws { let harness = try EngineHarness() try await harness.start() try harness.add([1, 2]) let before = harness.engine.snapshot let passes = harness.engine.layoutPassCount let scheduled = harness.scheduler.scheduledCount let writes = harness.world.allWrites.count harness.engine.cancelMouseGesture() #expect(harness.engine.snapshot == before) #expect(harness.engine.layoutPassCount == passes) #expect(harness.scheduler.scheduledCount == scheduled) #expect(harness.world.allWrites.count == writes) #expect(harness.engine.isIdle) await harness.engine.stop() }
@Test(arguments: [false, true]) func acceptsEngineClampedReadback(grid: Bool) async throws { let harness = try EngineHarness() harness.world.behaviors[engineApp] = grid ? FakeEngineWorld.Behavior(widthMultiple: 7) : FakeEngineWorld.Behavior(minimumSize: Size(width: 1300, height: 900)) try await harness.start() try harness.add([1, 2]) #expect(!harness.engine.frameAdjustments.isEmpty) for _ in 0..<8 where harness.scheduler.pendingCount > 0 { try harness.scheduler.runNext() } try #require(harness.engine.isIdle, "Clamped read-back confirmation must finish before awaiting settlement") let scheduled = harness.scheduler.scheduledCount try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) #expect(harness.scheduler.scheduledCount == scheduled) await harness.engine.stop() }
@Test func waitsForWriteReceiptWithoutPolling() async throws { let harness = try EngineHarness() try await harness.start() harness.world.deferWrites = true try harness.add([1]) let scheduled = harness.scheduler.scheduledCount let wait = Task { try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) } while harness.engine.workspaceWaiters.isEmpty { await Task.yield() } #expect(harness.scheduler.scheduledCount == scheduled + 1) try harness.world.completeNextWrite() try await wait.value #expect(harness.engine.workspaceWaiters.isEmpty) #expect(harness.scheduler.pendingCount == 0) await harness.engine.stop() }
@Test func reportsSpecificFailedWindow() async throws { let harness = try EngineHarness() try await harness.start() harness.world.behaviors[engineApp] = FakeEngineWorld.Behavior(timesOut: true) try harness.add([1]) await #expect(throws: EngineWorkspaceFailure.unsettled([WindowID(rawValue: 1)])) { try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) } await harness.engine.stop() }
@Test(arguments: ["timeout", "cancel", "stop", "space", "automaticTilingOff"]) func pendingWaitTerminates(reason: String) async throws { let harness = try EngineHarness() try await harness.start() harness.world.deferWrites = true try harness.add([1]) let wait = Task { try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace, timeout: .seconds(1)) } while harness.engine.workspaceWaiters.isEmpty { await Task.yield() } switch reason { case "timeout": try harness.scheduler.advance(by: 1) case "cancel": wait.cancel() case "stop": await harness.engine.stop() case "space": harness.engine.send(.activeSpaceChanged(display: engineDisplay, space: SpaceID(rawValue: 10))) try harness.scheduler.runReady() case "automaticTilingOff": harness.engine.setAutomaticTilingEnabled(false) default: Issue.record("Unknown wait fixture") } do { try await wait.value Issue.record("The pending wait should fail") } catch { switch reason { case "timeout": #expect(error as? EngineWorkspaceFailure == .unsettled([WindowID(rawValue: 1)])) case "cancel": #expect(error is CancellationError) case "stop": #expect(error as? EngineError == .stopped) case "space": #expect(error as? EngineWorkspaceFailure == .workspaceUnavailable) case "automaticTilingOff": #expect(error as? EngineWorkspaceFailure == .automaticTilingDisabled) default: break } } #expect(harness.engine.workspaceWaiters.isEmpty) await harness.engine.stop() }
@Test func unchangedTourRollbackDoesNotWriteOrWaitForReadback() async throws { let harness = try EngineHarness() try await harness.start() try harness.add([1, 2]) try harness.finishMotion() harness.engine.setWaitingForTour(true) let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) let writes = harness.world.allWrites.count harness.engine.setWaitingForTour(false) #expect(!harness.engine.workspaceNeedsFrameRestoration(point)) try await harness.engine.restoreWorkspace(point) #expect(harness.engine.workspaceWaiters.isEmpty) #expect(harness.world.allWrites.count == writes) try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) await harness.engine.stop() }
@Test func unchangedRollbackPreservesOtherDisplayReadback() async throws { let harness = try EngineHarness(initialState: engineInitialState(twoDisplays: true)) try await harness.start() try harness.add([1, 2]) let other = WorkspaceKey(display: secondEngineDisplay, space: SpaceID(rawValue: 2)) try harness.add([3], app: secondEngineApp, workspace: other) try harness.finishMotion() let readbacks = harness.engine.snapshot.readbackFrames let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) try await harness.engine.restoreWorkspace(point) #expect(harness.engine.snapshot.readbackFrames == readbacks) try await harness.engine.awaitWorkspaceSettled(in: other) await harness.engine.stop() }
@Test(arguments: [false, true]) func unchangedFloatingSiblingCannotExemptAnUnknownOrMovedTiledWrite(moved: Bool) async throws { let harness = try EngineHarness() try await harness.start() try harness.add([1]) var floating = engineWindow(2) floating.isFloating = true harness.world.appear(floating) try harness.scheduler.runReady() try harness.finishMotion() harness.engine.setAutomaticTilingEnabled(false) let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) let tiled = WindowID(rawValue: 1) harness.engine.workspaceWriteAttempts[tiled, default: 0] += 1 harness.engine.snapshot.readbackFrames[tiled] = nil if moved { harness.engine.actualFrames[tiled] = initialEngineFrame } harness.engine.receive(.appResponsivenessChanged(engineApp, isResponsive: false)) #expect(harness.engine.workspaceUnmovedApplications(point, among: [engineApp]).isEmpty) await #expect(throws: EngineWorkspaceFailure.unsettled([tiled])) { try await driveTour(harness) { try await harness.engine.restoreWorkspace(point) } } await harness.engine.stop() }
@Test func queuedDiscoveryIsCapturedWithoutMovingWindows() async throws { let harness = try EngineHarness() try await harness.start() harness.engine.setWaitingForTour(true) harness.engine.send( .windowAppeared( ManagedWindow(id: WindowID(rawValue: 1), app: engineApp), workspace: engineWorkspace, frame: Rect(x: 70, y: 90, width: 400, height: 300))) try harness.engine.flushTourDiscovery() let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) #expect(harness.engine.snapshot.state.windows.count == 1) #expect(!harness.engine.workspaceNeedsFrameRestoration(point)) #expect(harness.world.allWrites.isEmpty) await harness.engine.stop() }
@Test(arguments: [false, true]) func unchangedExplicitWriteNeedsRecoveryOnlyWhenReadbackIsUnknown(failsReadback: Bool) async throws { let harness = try EngineHarness() try await harness.start() try harness.add([1, 2]) try harness.finishMotion() harness.engine.setWaitingForTour(true) let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) let original = harness.world.frames let layout = try #require(harness.engine.snapshot.state.workspaces[engineWorkspace]?.layout) harness.world.behaviors[engineApp] = FakeEngineWorld.Behavior(timesOut: failsReadback) harness.engine.setWaitingForTour(false) harness.engine.send(.workspaceCommandIssued(.setLayout(layout), workspace: engineWorkspace)) try harness.scheduler.runReady() try harness.finishMotion() #expect(harness.world.frames == original) #expect(harness.engine.workspaceNeedsFrameRestoration(point) == failsReadback) if failsReadback { await #expect(throws: EngineWorkspaceFailure.self) { try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) } } else { try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) } await harness.engine.stop() }
@Test func failedReadbackStillRequiresRestorationAfterDispatch() async throws { let harness = try EngineHarness() try await harness.start() try harness.add([1, 2]) try harness.finishMotion() harness.engine.setWaitingForTour(true) let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) harness.world.behaviors[engineApp] = FakeEngineWorld.Behavior(timesOut: true) harness.engine.setWaitingForTour(false) harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) try harness.scheduler.runReady() try harness.finishMotion() #expect(harness.engine.workspaceNeedsFrameRestoration(point)) await harness.engine.stop() }
@Test func knownUnresponsiveAppIsLeftAloneWhileHealthyWindowsSettle() async throws { let harness = try EngineHarness() try await harness.start() try harness.add([1]) try harness.add([2], app: secondEngineApp) try harness.finishMotion() let skipped = harness.world.frames[WindowID(rawValue: 1)] let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) harness.engine.receive(.appResponsivenessChanged(engineApp, isResponsive: false)) harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) try harness.scheduler.runReady() try harness.finishMotion() #expect(harness.world.frames[WindowID(rawValue: 1)] == skipped) let unmoved = harness.engine.workspaceUnmovedApplications(point, among: [engineApp]) #expect(unmoved == [engineApp]) try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace, excludingApplications: unmoved) await #expect(throws: EngineWorkspaceFailure.self) { try await driveTour(harness) { try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) } } harness.engine.receive(.appResponsivenessChanged(engineApp, isResponsive: true)) try harness.scheduler.runReady() try harness.finishMotion() try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) await harness.engine.stop() }
@Test func manualTidyDoesNotReleaseAnotherDisplayBeforeSuccess() async throws { let harness = try EngineHarness(initialState: engineInitialState(twoDisplays: true)) try await harness.start() try harness.add([1, 2]) let other = WorkspaceKey(display: secondEngineDisplay, space: SpaceID(rawValue: 2)) try harness.add([3], app: secondEngineApp, workspace: other) try harness.finishMotion() harness.engine.setWaitingForTour(true) let before = harness.world.frames[WindowID(rawValue: 3)] let writes = harness.world.allWrites.count harness.engine.setWaitingForTour(false) harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) try harness.scheduler.runReady() try harness.finishMotion() #expect(!harness.engine.isAutomaticTilingEnabled) #expect(harness.world.frames[WindowID(rawValue: 3)] == before) #expect(!harness.world.allWrites.dropFirst(writes).contains { $0.window == WindowID(rawValue: 3) }) await harness.engine.stop() }
@Test func restorePreservesOtherDisplayAndNewWindows() async throws { let harness = try EngineHarness(initialState: engineInitialState(twoDisplays: true)) try await harness.start() try harness.add([1, 2]) let otherKey = WorkspaceKey(display: secondEngineDisplay, space: SpaceID(rawValue: 2)) try harness.add([3, 4], app: secondEngineApp, workspace: otherKey) let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) let original = harness.engine.snapshot.state.workspaces[engineWorkspace] harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) harness.engine.send(.workspaceCommandIssued(.setLayout(.side), workspace: otherKey)) try harness.scheduler.runReady() try harness.add([5]) harness.world.disappear(WindowID(rawValue: 2)) try harness.scheduler.runReady() let other = harness.engine.snapshot.state.workspaces[otherKey] try await restore(point, using: harness) #expect(harness.engine.snapshot.state.workspaces[engineWorkspace]?.layout == original?.layout) #expect( Set(harness.engine.snapshot.state.workspaces[engineWorkspace]?.order ?? []) == [ WindowID(rawValue: 1), WindowID(rawValue: 5), ]) #expect(harness.engine.snapshot.state.workspaces[otherKey] == other) #expect(harness.world.frames == harness.engine.snapshot.state.frames) await harness.engine.stop() }
@Test func restoringManualWorkspaceRestoresHandPlacedFramesWithoutMovingOtherDisplay() async throws { let harness = try EngineHarness(initialState: engineInitialState(twoDisplays: true)) try await harness.start() try harness.add([1, 2]) let otherKey = WorkspaceKey(display: secondEngineDisplay, space: SpaceID(rawValue: 2)) try harness.add([3], app: secondEngineApp, workspace: otherKey) harness.engine.setAutomaticTilingEnabled(false) let handPlaced = Rect(x: 80, y: 90, width: 380, height: 290) harness.world.userFrame(WindowID(rawValue: 1), frame: handPlaced) try harness.scheduler.runReady() let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) harness.engine.setAutomaticTilingEnabled(true) harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) try harness.scheduler.runReady() let otherFrame = harness.world.frames[WindowID(rawValue: 3)] let writes = harness.world.allWrites.count try await restore(point, using: harness) #expect(!harness.engine.isAutomaticTilingEnabled) #expect(harness.world.frames[WindowID(rawValue: 1)] == handPlaced) #expect(harness.world.frames[WindowID(rawValue: 3)] == otherFrame) #expect(!harness.world.allWrites.dropFirst(writes).contains { $0.window == WindowID(rawValue: 3) }) await harness.engine.stop() }
@Test(arguments: [false, true]) func tourRollbackPreservesReadbackWhenHeldTargetsAreRecomputed(paused: Bool) async throws { let harness = try EngineHarness() try await harness.start() do { try harness.add([1, 2, 3]) try harness.finishMotion() if paused { harness.engine.setAutomaticTilingEnabled(false) harness.world.userFrame(WindowID(rawValue: 1), frame: Rect(x: 80, y: 90, width: 380, height: 290)) try harness.scheduler.runReady() } harness.engine.setWaitingForTour(true) let original = harness.world.frames let workspace = harness.engine.snapshot.state.workspaces[engineWorkspace] let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) #expect(!point.isAutomaticTilingEnabled) harness.engine.setWaitingForTour(false) harness.engine.setAutomaticTilingEnabled(true) harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) try harness.scheduler.runReady() try harness.finishMotion() #expect(harness.world.frames != original) try await restore(point, using: harness) harness.engine.setWaitingForTour(true) let writes = harness.world.allWrites.count harness.engine.send(.relayout) try harness.scheduler.runReady() #expect(harness.engine.isWaitingForTour) #expect(!harness.engine.isAutomaticTilingEnabled) #expect(harness.engine.snapshot.state.workspaces[engineWorkspace] == workspace) #expect(harness.world.frames == original) #expect(harness.engine.actualFrames == original) #expect(harness.world.allWrites.count == writes) if paused { #expect(harness.engine.snapshot.state.frames != original) } } catch { await harness.engine.stop() throw error } await harness.engine.stop() }
@Test(arguments: [false, true], [false, true]) func rollbackSupersedesManualLayoutTargets(paused: Bool, queued: Bool) async throws { let harness = try EngineHarness() try await harness.start() do { try harness.add([1, 2, 3]) if paused { harness.engine.setAutomaticTilingEnabled(false) } harness.engine.setWaitingForTour(true) let original = harness.world.frames let workspace = harness.engine.snapshot.state.workspaces[engineWorkspace] let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) harness.engine.setWaitingForTour(false) harness.engine.setAutomaticTilingEnabled(true) harness.world.deferWrites = true harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) if !queued { try harness.scheduler.runReady() harness.engine.setAutomaticTilingEnabled(false) harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) try harness.scheduler.runReady() } let rollback = Task { try await harness.engine.restoreWorkspace(point) } if queued { try await rollback.value #expect(harness.engine.workspaceWaiters.isEmpty) } else { for _ in 0..<100 where harness.engine.workspaceWaiters.isEmpty { await Task.yield() } try #require(!harness.engine.workspaceWaiters.isEmpty) } #expect(harness.engine.manualCommandFrames.isEmpty) harness.world.deferWrites = false for _ in 0..<100 where harness.world.pendingWriteCount > 0 { try harness.world.completeNextWrite() try harness.scheduler.runReady() } try harness.finishMotion() try await rollback.value #expect(harness.engine.snapshot.state.workspaces[engineWorkspace] == workspace) #expect(harness.world.frames == original) #expect(harness.engine.actualFrames == original) #expect(!harness.engine.isAutomaticTilingEnabled) } catch { await harness.engine.stop() throw error } await harness.engine.stop() }
@Test(arguments: [false, true]) func rollbackRewritesSavedFramesAfterAnInFlightLayoutWrite(paused: Bool) async throws { let harness = try EngineHarness() try await harness.start() do { try harness.add([1, 2, 3]) if paused { harness.engine.setAutomaticTilingEnabled(false) } harness.engine.setWaitingForTour(true) let original = harness.world.frames let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) harness.engine.setWaitingForTour(false) harness.engine.setAutomaticTilingEnabled(true) harness.world.deferWrites = true harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) try harness.scheduler.runReady() try harness.scheduler.advance(by: 0.02) try #require(harness.world.pendingWriteCount > 0) #expect(harness.engine.actualFrames == original) let rollback = Task { try await harness.engine.restoreWorkspace(point) } for _ in 0..<100 where harness.engine.workspaceWaiters.isEmpty { await Task.yield() } try #require(!harness.engine.workspaceWaiters.isEmpty) harness.world.deferWrites = false try harness.world.completeNextWrite() try harness.scheduler.runReady() try harness.finishMotion() try await rollback.value #expect(harness.world.frames == original) #expect(harness.engine.actualFrames == original) #expect(!harness.engine.isAutomaticTilingEnabled) } catch { await harness.engine.stop() throw error } await harness.engine.stop() }
@Test func rollbackDrainsQueuedManualCommandsBeforeRestoringHandPlacements() async throws { let harness = try EngineHarness() try await harness.start() do { try harness.add([1, 2, 3]) harness.engine.setAutomaticTilingEnabled(false) harness.world.userFrame(WindowID(rawValue: 1), frame: Rect(x: 80, y: 90, width: 380, height: 290)) try harness.scheduler.runReady() let original = harness.world.frames let workspace = harness.engine.snapshot.state.workspaces[engineWorkspace] let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) harness.engine.send(.workspaceCommandIssued(.setLayout(.side), workspace: engineWorkspace)) try await restore(point, using: harness) #expect(harness.engine.snapshot.state.workspaces[engineWorkspace] == workspace) #expect(harness.world.frames == original) #expect(harness.engine.actualFrames == original) #expect(harness.engine.manualCommandFrames.isEmpty) } catch { await harness.engine.stop() throw error } await harness.engine.stop() }
private func restore(_ point: EngineWorkspaceRestorePoint, using harness: EngineHarness) async throws { var finished = false let task = Task { defer { finished = true } try await harness.engine.restoreWorkspace(point) } for _ in 0..<100 where !finished { await Task.yield() try harness.scheduler.advance(by: 0.5) } try await task.value }
@Test func restorePointCannotCrossEnginesOrDisconnectedSpaces() async throws { let first = try EngineHarness() let second = try EngineHarness() try await first.start() try await second.start() let point = try first.engine.captureWorkspaceRestorePoint(in: engineWorkspace) await #expect(throws: EngineWorkspaceFailure.workspaceUnavailable) { try await second.engine.restoreWorkspace(point) } first.engine.send(.displaySetChanged([])) try first.scheduler.runReady() await #expect(throws: EngineWorkspaceFailure.workspaceUnavailable) { try await first.engine.restoreWorkspace(point) } await first.engine.stop() await second.engine.stop() }}