import Foundation import ParcelCore import ParcelPlatform import Testing @testable import ParcelEngine @MainActor final class FakeNativeApplication: NativeEngineApplication { let events: AsyncStream private let continuation: AsyncStream.Continuation var snapshots: [NativeWindowSnapshot] = [] var focused: WindowID? var edited: Bool? = false private(set) var closed: [WindowID] = [] var onClose: (@MainActor (WindowID) -> Void)? private(set) var restored: [WindowID] = [] var restoreError: (any Error)? var onRestore: (@MainActor () async -> Void)? private(set) var fullscreenToggles: [WindowID] = [] var fullscreenError: (any Error)? var shortcuts: [MenuShortcut] = [] var onMenuRead: (@MainActor () async -> Void)? var beforeFocusOrRaise: (@MainActor () async throws -> Void)? private(set) var menuReads = 0 var error: (any Error)? var deferFrameRead = false var deferWindowRead = false private var windowContinuation: CheckedContinuation<[NativeWindowSnapshot], any Error>? private var activeWindowReads = 0 private(set) var maximumConcurrentWindowReads = 0 var hasPendingWindows: Bool { windowContinuation != nil } var deferFocusRead = false private var frameContinuation: CheckedContinuation? private var focusContinuation: CheckedContinuation? private(set) var windowReads = 0 private(set) var probeReads = 0 func probeResponsiveness() async throws { probeReads += 1 if let error { throw error } } private(set) var focusReads = 0 private(set) var frameReads = 0 private(set) var acknowledgedMotion: [UInt32] = [] private(set) var shutdownCount = 0 private(set) var writes: [WindowFrame] = [] private(set) var batchWrites = 0 private(set) var cancelledWrites: [(WindowID, UInt64)] = [] var deferBatchWrite = false private var batchContinuation: CheckedContinuation? var hasPendingWrite: Bool { batchContinuation != nil } func completeWrite() { batchContinuation?.resume() batchContinuation = nil } var batchDuration: Double = 0.001 var onFrameWrite: (@MainActor (WindowFrame) -> Void)? var shutdownError: (any Error)? var hasPendingFrame: Bool { frameContinuation != nil } var hasPendingFocus: Bool { focusContinuation != nil } init() { let stream = AsyncStream.makeStream() events = stream.stream continuation = stream.continuation } func spaceDragWindow(_ window: WindowID) async throws -> SpaceDragWindow { guard let frame = snapshots.first(where: { $0.window.id == window })?.frame else { throw SpaceCommandError.windowUnavailable } return SpaceDragWindow( id: window.rawValue, titleBar: CGRect(x: frame.minX, y: frame.minY, width: frame.size.width, height: 20), isFullscreen: false) } func emit(_ event: AppThreadEvent) { continuation.yield(event) } func acknowledgeMotion(_ window: UInt32) { acknowledgedMotion.append(window) } func windows() async throws -> [NativeWindowSnapshot] { windowReads += 1 activeWindowReads += 1 maximumConcurrentWindowReads = max(maximumConcurrentWindowReads, activeWindowReads) defer { activeWindowReads -= 1 } if let error { throw error } if deferWindowRead { return try await withCheckedThrowingContinuation { windowContinuation = $0 } } return snapshots } func completeWindows(_ result: [NativeWindowSnapshot]? = nil) throws { guard let continuation = windowContinuation else { throw NativeHarnessError.noPendingWindows } windowContinuation = nil continuation.resume(returning: result ?? snapshots) } func frame(_ window: WindowID) async throws -> Rect { frameReads += 1 if let error { throw error } if deferFrameRead { return try await withCheckedThrowingContinuation { frameContinuation = $0 } } guard let frame = snapshots.first(where: { $0.window.id == window })?.frame else { throw AppThreadFailure.windowNotFound(window.rawValue) } return frame } func completeFrame(_ frame: Rect) throws { guard let continuation = frameContinuation else { throw NativeHarnessError.noPendingFrame } frameContinuation = nil continuation.resume(returning: frame) } func menuShortcuts() async throws -> [MenuShortcut] { menuReads += 1 await onMenuRead?() if let error { throw error } return shortcuts } func focusedWindow() async throws -> WindowID? { focusReads += 1 if let error { throw error } if deferFocusRead { return try await withCheckedThrowingContinuation { focusContinuation = $0 } } return focused } func completeFocus(_ window: WindowID?) throws { guard let continuation = focusContinuation else { throw NativeHarnessError.noPendingFocus } focusContinuation = nil continuation.resume(returning: window) } func write(_ frame: Rect, to window: WindowID) async throws -> Rect { if let error { throw error } recordWrite(WindowFrame(window: window, frame: frame)) return frame } func writeFrames(_ frames: [EngineFrameWrite]) async throws -> EngineWriteReceipt { batchWrites += 1 if deferBatchWrite { await withCheckedContinuation { batchContinuation = $0 } } var actual: [WindowFrame] = [] var failures: [EnginePlatformFailure] = [] for request in frames { if let error { failures.append( NativeEngineWorld.failure( error, app: snapshots.first?.window.app ?? engineApp, window: request.window)) } else { let frame = WindowFrame(window: request.window, frame: request.frame) recordWrite(frame) if request.isFinal { actual.append(frame) } } } return EngineWriteReceipt( frames: actual, failures: failures, duration: batchDuration, writtenWindowCount: frames.count > failures.count ? frames.count - failures.count : nil) } private func recordWrite(_ frame: WindowFrame) { writes.append(frame) if let index = snapshots.firstIndex(where: { $0.window.id == frame.window }) { snapshots[index].frame = frame.frame } onFrameWrite?(frame) } func cancelFrameWrites(_ window: WindowID, throughGeneration: UInt64) async throws { cancelledWrites.append((window, throughGeneration)) } func finishShutdown() async throws { if let shutdownError { throw shutdownError } } func focus(_ window: WindowID) async throws { try await beforeFocusOrRaise?() if let error { throw error } focused = window } func raise(_ window: WindowID) async throws { try await beforeFocusOrRaise?() if let error { throw error } } func edited(_ window: WindowID) async throws -> Bool? { if let error { throw error } return edited } func close(_ window: WindowID) async throws { if let error { throw error } closed.append(window) snapshots.removeAll { $0.window.id == window } onClose?(window) } func restore(_ window: WindowID, validity: AppThreadOperationValidity) async throws { await onRestore?() do { try validity.check() } catch is AppThreadOperationInvalidated { throw MinimizedWindowRestoreError.staleWindow(window) } if let restoreError { throw restoreError } if let error { throw error } guard let index = snapshots.firstIndex(where: { $0.window.id == window }) else { throw EnginePlatformFailure.vanished(window) } restored.append(window) let previous = snapshots[index] var managed = previous.window managed.facts?.isMinimized = false snapshots[index] = NativeWindowSnapshot( window: managed, frame: previous.frame, excluded: managed.facts?.isFullScreen == true, validity: previous.validity) } func toggleFullscreen(_ window: WindowID) async throws { if let fullscreenError { throw fullscreenError } if let error { throw error } fullscreenToggles.append(window) guard let index = snapshots.firstIndex(where: { $0.window.id == window }) else { throw EnginePlatformFailure.vanished(window) } let previous = snapshots[index] var managed = previous.window var facts = managed.facts ?? WindowFacts(bundleID: managed.app.bundleID, role: managed.role) facts.isFullScreen = facts.isFullScreen != true managed.facts = facts snapshots[index] = NativeWindowSnapshot( window: managed, frame: previous.frame, excluded: facts.isFullScreen == true, validity: previous.validity) } func shutdown() { shutdownCount += 1 completeWrite() windowContinuation?.resume(throwing: CancellationError()) windowContinuation = nil continuation.finish() } } @MainActor final class FakeNativeBackend: NativeEngineBackend { var displays = [Display(id: engineDisplay, frame: engineScreen)] var infos = [NativeApplicationInfo(id: engineApp), NativeApplicationInfo(id: secondEngineApp)] var frontmost: AppID? = engineApp var apps: [AppID: FakeNativeApplication] = [:] var visible: [WindowID: Rect] = [:] var catalogFrames: [WindowID: Rect] = [:] var catalogOwners: [WindowID: Int32] = [:] var spaces = [engineDisplay: engineSpace] var suspendedDisplays: Set = [] var applicationError: (any Error)? var spaceError: (any Error)? var nativeSpaceSnapshot: [NativeDisplaySpaces]? var windowSpaceMemberships: [WindowID: Set] = [:] var windowSpaceError: (any Error)? private(set) var windowSpaceReads = 0 private(set) var newWindowTarget: (@Sendable (AppThreadCreatedWindow) -> CGRect?)? func setNewWindowTarget(_ target: @escaping @Sendable (AppThreadCreatedWindow) -> CGRect?) { newWindowTarget = target } var visibleError: (any Error)? var deferVisibleRead = false private var visibleContinuation: CheckedContinuation? private var heldVisible: NativeVisibleWindows? var hasPendingVisible: Bool { visibleContinuation != nil } private var receive: (@MainActor (NativeEngineEvent) -> Void)? private(set) var runningReads = 0 private(set) var visibleReads = 0 private(set) var spaceReads = 0 private(set) var applicationRequests: [AppID] = [] func start(receive: @escaping @MainActor (NativeEngineEvent) -> Void) throws { self.receive = receive } var stopError: (any Error)? func stop() { if let stopError { receive?(.failure(stopError)) } receive = nil visibleContinuation?.resume(throwing: CancellationError()) visibleContinuation = nil heldVisible = nil } func emit(_ event: NativeEngineEvent, changesFrontmost: Bool = true) { if changesFrontmost, case .activated(let info) = event { frontmost = info.id } receive?(event) } func currentDisplays() throws -> [ParcelCore.Display] { displays } func focusedApplication() -> AppID? { frontmost } func runningApplications() -> [NativeApplicationInfo] { runningReads += 1 return infos } func application(_ app: AppID) throws -> any NativeEngineApplication { applicationRequests.append(app) if let applicationError { throw applicationError } guard let application = apps[app] else { throw AppThreadFailure.stopped } application.onClose = { [weak self] window in self?.visible[window] = nil self?.catalogFrames[window] = nil self?.catalogOwners[window] = nil self?.windowSpaceMemberships[window] = nil } application.onFrameWrite = { [weak self] frame in guard let self, self.visible[frame.window] != nil else { return } self.visible[frame.window] = frame.frame } return application } func visibleWindows() async throws -> NativeVisibleWindows { visibleReads += 1 if let visibleError { throw visibleError } let snapshots = apps.values.flatMap(\.snapshots) for snapshot in snapshots { catalogFrames[snapshot.window.id] = visible[snapshot.window.id] ?? snapshot.frame catalogOwners[snapshot.window.id] = snapshot.window.app.pid } let result = NativeVisibleWindows( frames: visible, owners: catalogOwners.filter { visible[$0.key] != nil }, catalogFrames: catalogFrames, catalogOwners: catalogOwners) if deferVisibleRead { heldVisible = result return try await withCheckedThrowingContinuation { visibleContinuation = $0 } } return result } func completeVisible() throws { guard let continuation = visibleContinuation, let result = heldVisible else { throw NativeHarnessError.noPendingVisible } visibleContinuation = nil heldVisible = nil continuation.resume(returning: result) } func currentSpaces(for displays: [DisplayID]) async throws -> NativeSpaceState { spaceReads += 1 if let spaceError { throw spaceError } return NativeSpaceState( spaces: spaces.filter { displays.contains($0.key) }, suspended: suspendedDisplays.intersection(displays), snapshot: nativeSpaceSnapshot ?? displays.compactMap { display in guard let space = spaces[display] else { return nil } return NativeDisplaySpaces( displayID: display.rawValue, currentSpace: space.rawValue, spaces: [NativeSpace(id: space.rawValue, kind: .desktop, desktopNumber: Int(space.rawValue))]) }) } func windowSpaces(for windows: Set) async throws -> [WindowID: Set] { windowSpaceReads += 1 if let windowSpaceError { throw windowSpaceError } return windowSpaceMemberships.filter { windows.contains($0.key) } } } enum NativeHarnessError: Error { case noPendingFrame, noPendingFocus, noPendingWindows, noPendingVisible, reconciliationTimedOut } @MainActor final class NativeHarness { let clock = ManualEngineClock() let scheduler: ManualEngineScheduler let backend = FakeNativeBackend() let first = FakeNativeApplication() let second = FakeNativeApplication() let world: NativeEngineWorld private(set) var events: [EnginePlatformEvent] = [] private(set) var state = State() var appeared: [(window: ManagedWindow, workspace: WorkspaceKey)] { events.compactMap { if case .observed(.windowAppeared(let window, let workspace, _)) = $0 { (window, workspace) } else { nil } } } var disappeared: [WindowID] { events.compactMap { if case .observed(.windowDisappeared(let id)) = $0 { id } else { nil } } } var failures: [EnginePlatformFailure] { events.compactMap { if case .failure(let failure) = $0 { failure } else { nil } } } init(spaceController: SpaceController? = nil) { scheduler = ManualEngineScheduler(clock: clock) world = NativeEngineWorld(backend: backend, scheduler: scheduler, spaceController: spaceController) backend.apps = [engineApp: first, secondEngineApp: second] first.snapshots = [NativeWindowSnapshot(window: engineWindow(1), frame: initialEngineFrame)] second.snapshots = [ NativeWindowSnapshot(window: engineWindow(2, app: secondEngineApp), frame: initialEngineFrame) ] backend.visible = [WindowID(rawValue: 1): initialEngineFrame, WindowID(rawValue: 2): initialEngineFrame] first.focused = WindowID(rawValue: 1) second.focused = WindowID(rawValue: 2) } func start() async throws { try world.start { [weak self] event in guard let self else { return } self.events.append(event) if case .observed(let observed) = event { self.state = reduce(self.state, observed).0 } } try await drain() } func drain() async throws { for _ in 0..<100 { try scheduler.runReady() await withCheckedContinuation { continuation in DispatchQueue.main.async { continuation.resume() } } } #expect(scheduler.readyCount == 0) } func drainReconciliation() async throws { let deadline = ContinuousClock.now + .seconds(10) while true { try scheduler.runReady() if !world.hasPendingReconciliation { return } guard ContinuousClock.now < deadline else { throw NativeHarnessError.reconciliationTimedOut } await withCheckedContinuation { continuation in DispatchQueue.main.async { continuation.resume() } } } } func clearEvents() { events.removeAll() } func apply(_ event: Event) { state = reduce(state, event).0 } }