import ParcelAnimation import ParcelConfig import ParcelCore import ParcelEngine import ParcelPlatform import Testing let engineDisplay = DisplayID(rawValue: "00000000-0000-0000-0000-000000000001") let secondEngineDisplay = DisplayID(rawValue: "00000000-0000-0000-0000-000000000002") let engineSpace = SpaceID(rawValue: 1) let engineWorkspace = WorkspaceKey(display: engineDisplay, space: engineSpace) let engineApp = AppID(pid: 100, bundleID: "test.fixture") let secondEngineApp = AppID(pid: 200, bundleID: "test.second") let engineScreen = Rect(x: 0, y: 0, width: 1200, height: 800) let initialEngineFrame = Rect(x: 40, y: 60, width: 300, height: 200) func engineWindow(_ id: UInt32, app: AppID = engineApp, floating: Bool = false, title: String = "Document") -> ManagedWindow { ManagedWindow(id: WindowID(rawValue: id), app: app, title: title, isFloating: floating) } func engineConfiguration(glide: Bool = false, layout: ConfigLayout = .columns) -> ParcelConfiguration { ParcelConfiguration( layout: LayoutConfiguration(global: LayoutValues(defaultLayout: layout, gaps: LayoutGaps(inner: 0, outer: 0))), motion: MotionConfiguration(transitions: glide ? .glide : .snap) ) } func engineInitialState(twoDisplays: Bool = false) -> State { let first = Display(id: engineDisplay, frame: engineScreen) if twoDisplays { let second = Display(id: secondEngineDisplay, frame: Rect(x: 1200, y: 0, width: 1200, height: 800)) return State( displays: [first, second], activeSpaces: [engineDisplay: engineSpace, secondEngineDisplay: SpaceID(rawValue: 2)]) } return State(displays: [first], activeSpaces: [engineDisplay: engineSpace]) } @MainActor final class ManualEngineClock: EngineClock { private var instant: Double = 10 var readStep: Double = 0 { didSet { precondition(readStep.isFinite && readStep >= 0) } } var now: Double { get { defer { instant += readStep } return instant } set { instant = newValue } } } @MainActor final class ManualEngineCancellation: EngineCancellation { private(set) var isCancelled = false func cancel() { isCancelled = true } } @MainActor final class ManualEngineScheduler: EngineScheduler { private struct Work { let identifier: Int let deadline: Double let cancellation: ManualEngineCancellation let action: @MainActor () -> Void } private let clock: ManualEngineClock private var work: [Work] = [] private var nextIdentifier = 0 private(set) var scheduledCount = 0 var pendingCount: Int { work.filter { !$0.cancellation.isCancelled }.count } var readyCount: Int { work.filter { !$0.cancellation.isCancelled && $0.deadline <= clock.now }.count } var cancelledCount: Int { work.filter { $0.cancellation.isCancelled }.count } var nextDeadline: Double? { work.filter { !$0.cancellation.isCancelled }.map(\.deadline).min() } init(clock: ManualEngineClock) { self.clock = clock } func schedule(after delay: Double, _ action: @escaping @MainActor () -> Void) -> any EngineCancellation { precondition(delay.isFinite && delay >= 0) let cancellation = ManualEngineCancellation() nextIdentifier += 1 scheduledCount += 1 work.append( Work(identifier: nextIdentifier, deadline: clock.now + delay, cancellation: cancellation, action: action)) return cancellation } func runReady(limit: Int = 1000) throws { var executed = 0 while let index = work.indices.filter({ !work[$0].cancellation.isCancelled && work[$0].deadline <= clock.now }) .min(by: { let lhs = work[$0] let rhs = work[$1] return lhs.deadline == rhs.deadline ? lhs.identifier < rhs.identifier : lhs.deadline < rhs.deadline }) { guard executed < limit else { throw HarnessError.schedulerDidNotQuiesce } let ready = work.remove(at: index) ready.action() executed += 1 } } func advance(by interval: Double) throws { precondition(interval >= 0) clock.now += interval try runReady() } func runNext() throws { guard let deadline = nextDeadline else { throw HarnessError.noScheduledWork } clock.now = max(clock.now, deadline) try runReady() } func fireCancelledWork() { let cancelled = work.filter { $0.cancellation.isCancelled } work.removeAll { $0.cancellation.isCancelled } for item in cancelled { item.action() } } } enum HarnessError: Error { case schedulerDidNotQuiesce case noScheduledWork case missingWrite case missingAction case missingConfigurationStart case startup } @MainActor final class FakeEngineWorld: EngineWindowWorld, EngineCommandWindowProviding { var accessibilityPermissionGranted: Bool? struct Behavior { var duration: Double = 0.001 var minimumSize: Size? var maximumSize: Size? var widthMultiple: Double? var roundsWidthUp = false var positionOffset = Point() var offsetWrites = Int.max var timesOut = false var vanishes = false var refusesFrames = false } struct WriteRecord { let app: AppID let writes: [EngineFrameWrite] let at: Double } private struct PendingWrite { let record: WriteRecord let completion: @MainActor (EngineWriteReceipt) -> Void } private let clock: ManualEngineClock private var receive: (@MainActor (EnginePlatformEvent) -> Void)? private var retainedReceive: (@MainActor (EnginePlatformEvent) -> Void)? private var receivers: [@MainActor (EnginePlatformEvent) -> Void] = [] private var pendingWrites: [PendingWrite] = [] private var pendingActions: [@MainActor (EnginePlatformFailure?) -> Void] = [] var frames: [WindowID: Rect] = [:] var behaviors: [AppID: Behavior] = [:] var deferWrites = false var afterReceipt: (@MainActor ([EngineFrameWrite]) -> Void)? var deferActions = false var startError: HarnessError? var emitsEngineEchoes = false private(set) var writes: [WriteRecord] = [] private(set) var focused: [WindowID] = [] private(set) var raised: [WindowID] = [] private(set) var closed: [WindowID] = [] private(set) var fullscreenToggles: [WindowID] = [] var commandWindow: ManagedWindow? var commandWindowError: (any Error)? var commandError: (any Error)? var deferWindowCommands = false var onWindowCommandPending: (@MainActor () -> Void)? private var windowCommands: [CheckedContinuation] = [] var pendingWindowCommandCount: Int { windowCommands.count } private(set) var reconciliations: [Set] = [] func reconcile(_ apps: Set) { reconciliations.append(apps) } private(set) var allowsSpeculation = false private(set) var placementClassifier: WindowClassifier? func updatePlacementState(_ state: State, classifier: WindowClassifier?, allowsSpeculation: Bool) { self.allowsSpeculation = allowsSpeculation placementClassifier = classifier } private(set) var startCount = 0 private(set) var stopCount = 0 var pendingWriteCount: Int { pendingWrites.count } var pendingActionCount: Int { pendingActions.count } var allWrites: [EngineFrameWrite] { writes.flatMap(\.writes) } init(clock: ManualEngineClock) { self.clock = clock } func start(receive: @escaping @MainActor (EnginePlatformEvent) -> Void) throws { startCount += 1 if let startError { throw startError } self.receive = receive retainedReceive = receive receivers.append(receive) } func stop() { stopCount += 1 receive = nil } func emit(_ event: EnginePlatformEvent) { receive?(event) } func emitLate(_ event: EnginePlatformEvent) { retainedReceive?(event) } func emitFromStart(_ index: Int, event: EnginePlatformEvent) { receivers[index](event) } func appear(_ window: ManagedWindow, workspace: WorkspaceKey = engineWorkspace, frame: Rect = initialEngineFrame) { frames[window.id] = frame emit(.observed(.windowAppeared(window, workspace: workspace, frame: frame))) } func disappear(_ window: WindowID) { frames[window] = nil emit(.observed(.windowDisappeared(window))) } func userFrame(_ window: WindowID, frame: Rect, resized: Bool = false, origin: FrameChangeOrigin = .user) { frames[window] = frame emit(.frameChanged(window, frame: frame, resized: resized, origin: origin)) } func write( _ frames: [EngineFrameWrite], for app: AppID, completion: @escaping @MainActor (EngineWriteReceipt) -> Void ) { let record = WriteRecord(app: app, writes: frames, at: clock.now) writes.append(record) if deferWrites { pendingWrites.append(PendingWrite(record: record, completion: completion)) } else { completion(makeReceipt(record)) afterReceipt?(frames) } } func focus(_ window: WindowID, completion: @escaping @MainActor (EnginePlatformFailure?) -> Void) { focused.append(window) completeAction(completion) } func raise(_ window: WindowID, completion: @escaping @MainActor (EnginePlatformFailure?) -> Void) { raised.append(window) completeAction(completion) } func focusedCommandWindow() async throws -> ManagedWindow? { if let commandWindowError { throw commandWindowError } return commandWindow } func close(_ window: WindowID) async throws { closed.append(window) try await windowCommand() } func toggleFullscreen(_ window: WindowID) async throws { fullscreenToggles.append(window) try await windowCommand() } private func windowCommand() async throws { try Task.checkCancellation() if let commandError { throw commandError } if deferWindowCommands { try await withCheckedThrowingContinuation { windowCommands.append($0) onWindowCommandPending?() } } try Task.checkCancellation() } func completeWindowCommand(error: (any Error)? = nil) throws { guard !windowCommands.isEmpty else { throw HarnessError.missingAction } let pending = windowCommands.removeFirst() if let error { pending.resume(throwing: error) } else { pending.resume() } } func completeNextWrite(receipt: EngineWriteReceipt? = nil) throws { guard !pendingWrites.isEmpty else { throw HarnessError.missingWrite } let pending = pendingWrites.removeFirst() pending.completion(receipt ?? makeReceipt(pending.record)) afterReceipt?(pending.record.writes) } func completeNextAction(failure: EnginePlatformFailure? = nil) throws { guard !pendingActions.isEmpty else { throw HarnessError.missingAction } pendingActions.removeFirst()(failure) } func writes(for window: WindowID) -> [EngineFrameWrite] { allWrites.filter { $0.window == window } } private func completeAction(_ completion: @escaping @MainActor (EnginePlatformFailure?) -> Void) { if deferActions { pendingActions.append(completion) } else { completion(nil) } } private func makeReceipt(_ record: WriteRecord) -> EngineWriteReceipt { var behavior = behaviors[record.app] ?? Behavior() if behavior.vanishes { for write in record.writes { frames[write.window] = nil } return EngineWriteReceipt( frames: [], failures: record.writes.map { .vanished($0.window) }, duration: behavior.duration) } if behavior.timesOut { return EngineWriteReceipt(frames: [], failures: [.timedOut(record.app)], duration: behavior.duration) } let initial = record.writes.compactMap { write -> WindowFrame? in guard write.capturesInitialFrame, let frame = frames[write.window] else { return nil } return WindowFrame(window: write.window, frame: frame) } let observed = record.writes.map { write in var frame = behavior.refusesFrames ? frames[write.window] ?? write.frame : write.frame if let minimum = behavior.minimumSize { frame.size = Size( width: max(frame.size.width, minimum.width), height: max(frame.size.height, minimum.height)) } if let maximum = behavior.maximumSize { frame.size = Size( width: min(frame.size.width, maximum.width), height: min(frame.size.height, maximum.height)) } if let multiple = behavior.widthMultiple { frame.size.width = (frame.size.width / multiple).rounded(behavior.roundsWidthUp ? .up : .down) * multiple } if behavior.offsetWrites > 0 { frame.origin.xCoordinate += behavior.positionOffset.xCoordinate frame.origin.yCoordinate += behavior.positionOffset.yCoordinate behavior.offsetWrites -= 1 } frames[write.window] = frame if emitsEngineEchoes { emit(.frameChanged(write.window, frame: frame, resized: true, origin: .engine(write.transaction))) } return WindowFrame(window: write.window, frame: frame) } behaviors[record.app] = behavior return EngineWriteReceipt(frames: observed, duration: behavior.duration, initialFrames: initial) } } @MainActor final class FakeEngineDisplayLink: EngineDisplayLink { var frameRate: Double = 120 private var tick: (@MainActor (Double) -> Void)? private var retainedTick: (@MainActor (Double) -> Void)? private(set) var isRunning = false private(set) var startCount = 0 private(set) var stopCount = 0 func start(tick: @escaping @MainActor (Double) -> Void) { self.tick = tick retainedTick = tick isRunning = true startCount += 1 } func stop() { isRunning = false tick = nil stopCount += 1 } func fire(at timestamp: Double) { tick?(timestamp) } func fireLate(at timestamp: Double) { retainedTick?(timestamp) } } @MainActor final class FakeEngineLinks { private(set) var links: [DisplayID: FakeEngineDisplayLink] = [:] var creationFailure = false var runningCount: Int { links.values.filter(\.isRunning).count } func make(_ display: DisplayID) throws -> any EngineDisplayLink { if creationFailure { throw HarnessError.startup } let link = FakeEngineDisplayLink() links[display] = link return link } func tickAll(at timestamp: Double) { for display in links.keys.sorted() { links[display]?.fire(at: timestamp) } } } @MainActor final class FakeEngineAnnouncer: EngineAnnouncer { private(set) var announcements: [Announcement] = [] func announce(_ announcement: Announcement) { announcements.append(announcement) } } @MainActor final class FakeEngineLog: EngineLogSink { private(set) var diagnostics: [EngineDiagnostic] = [] var platformFailures: [EnginePlatformFailure] { diagnostics.compactMap { if case .platform(let failure) = $0 { failure } else { nil } } } var reports: [Report] { diagnostics.compactMap { if case .core(let report) = $0 { report } else { nil } } } var motionErrors: [MotionError] { diagnostics.compactMap { if case .motion(let error) = $0 { error } else { nil } } } func record(_ diagnostic: EngineDiagnostic) { diagnostics.append(diagnostic) } } @MainActor final class FakeEngineTrace: EngineTraceSink { struct Entry: Equatable { let stage: EngineTraceStage let transaction: UInt64 let begins: Bool } private(set) var entries: [Entry] = [] func begin(_ stage: EngineTraceStage, transaction: UInt64) { entries.append(Entry(stage: stage, transaction: transaction, begins: true)) } func end(_ stage: EngineTraceStage, transaction: UInt64) { entries.append(Entry(stage: stage, transaction: transaction, begins: false)) } func balance(for stage: EngineTraceStage) -> Int { entries.filter { $0.stage == stage }.reduce(0) { $0 + ($1.begins ? 1 : -1) } } } @MainActor final class FakeEngineConfigurationSource: EngineConfigurationSource { var initial: ParcelConfiguration var startError: HarnessError? var deferStart = false private var changed: (@MainActor (ConfigSnapshot) -> Void)? private var retainedChanges: [@MainActor (ConfigSnapshot) -> Void] = [] private var startContinuation: CheckedContinuation? private(set) var startCount = 0 private(set) var stopCount = 0 var isSubscribed: Bool { changed != nil } var isAwaitingStart: Bool { startContinuation != nil } init(initial: ParcelConfiguration = engineConfiguration()) { self.initial = initial } func start(changed: @escaping @MainActor (ConfigSnapshot) -> Void) async throws -> ParcelConfiguration { startCount += 1 self.changed = changed retainedChanges.append(changed) if let startError { throw startError } if deferStart { return try await withCheckedThrowingContinuation { startContinuation = $0 } } return initial } func stop() async { stopCount += 1 changed = nil } func emit(_ snapshot: ConfigSnapshot) { changed?(snapshot) } func emitFromStart(_ index: Int, snapshot: ConfigSnapshot) { retainedChanges[index](snapshot) } func completeStart() throws { guard let continuation = startContinuation else { throw HarnessError.missingConfigurationStart } startContinuation = nil continuation.resume(returning: initial) } } @MainActor final class EngineHarness { let clock = ManualEngineClock() let scheduler: ManualEngineScheduler let world: FakeEngineWorld let links = FakeEngineLinks() let announcer = FakeEngineAnnouncer() let log = FakeEngineLog() let trace = FakeEngineTrace() let engine: ParcelEngine init( configuration: ParcelConfiguration = engineConfiguration(), initialState: State = engineInitialState(), configSource: (any EngineConfigurationSource)? = nil, recorder: (any EngineEventRecorder)? = nil, minimumSizeStore: MinimumSizeStore? = nil, spaceWorld: (any EngineSpaceWorld)? = nil, workspaceStateStore: WorkspaceStateStore? = nil, ruleSpaceMoveStore: RuleSpaceMoveStore? = nil, startupWindowIDs: (@Sendable () async throws -> Set)? = nil ) throws { scheduler = ManualEngineScheduler(clock: clock) world = FakeEngineWorld(clock: clock) let links = links engine = try ParcelEngine( world: world, clock: clock, scheduler: scheduler, displayLink: { try links.make($0) }, announcer: announcer, log: log, configuration: configuration, initialState: initialState, configSource: configSource, trace: trace, reduceMotionSource: nil, recorder: recorder, minimumSizeStore: minimumSizeStore, spaceWorld: spaceWorld, workspaceStateStore: workspaceStateStore, ruleSpaceMoveStore: ruleSpaceMoveStore, startupWindowIDs: startupWindowIDs ) } func start() async throws { try await engine.start() try scheduler.runReady() } func add(_ ids: [UInt32], app: AppID = engineApp, workspace: WorkspaceKey = engineWorkspace) throws { for id in ids { world.appear(engineWindow(id, app: app), workspace: workspace) } try scheduler.runReady() } func finishMotion(after interval: Double = 2) throws { clock.now += interval links.tickAll(at: clock.now) try scheduler.runReady() } }