Add FairnessScheduler and TokenExecutor integration

ModernTests/FairnessScheduler/Mocks/MockFairnessSchedulerExecutor.swift

@@ -0,0 +1,77 @@
+//
+//  MockFairnessSchedulerExecutor.swift
+//  ModernTests
+//
+//  Mock executor for testing FairnessScheduler in isolation.
+//  This simulates the TokenExecutor interface that FairnessScheduler will use.
+//
+
+import Foundation
+@testable import iTerm2SharedARC
+
+// TurnResult and FairnessSchedulerExecutor are defined in FairnessScheduler.swift
+
+/// Mock implementation for testing FairnessScheduler without real TokenExecutor.
+final class MockFairnessSchedulerExecutor: FairnessSchedulerExecutor {
+
+    // MARK: - Configuration
+
+    /// The result to return from executeTurn. Set this before each test scenario.
+    var turnResult: TurnResult = .completed
+
+    /// If set, executeTurn calls this instead of using turnResult.
+    /// Useful for dynamic behavior or async testing.
+    var executeTurnHandler: ((Int, @escaping (TurnResult) -> Void) -> Void)?
+
+    /// Delay before calling completion (simulates execution time)
+    var executionDelay: TimeInterval = 0
+
+    // MARK: - Call Tracking
+
+    struct ExecuteTurnCall: Equatable {
+        let tokenBudget: Int
+        let timestamp: Date
+
+        static func == (lhs: ExecuteTurnCall, rhs: ExecuteTurnCall) -> Bool {
+            return lhs.tokenBudget == rhs.tokenBudget
+        }
+    }
+
+    private(set) var executeTurnCalls: [ExecuteTurnCall] = []
+    private(set) var totalTokenBudgetConsumed: Int = 0
+
+    // MARK: - FairnessSchedulerExecutor
+
+    func executeTurn(tokenBudget: Int, completion: @escaping (TurnResult) -> Void) {
+        executeTurnCalls.append(ExecuteTurnCall(tokenBudget: tokenBudget, timestamp: Date()))
+        totalTokenBudgetConsumed += tokenBudget
+
+        if let handler = executeTurnHandler {
+            handler(tokenBudget, completion)
+            return
+        }
+
+        if executionDelay > 0 {
+            DispatchQueue.global().asyncAfter(deadline: .now() + executionDelay) { [turnResult] in
+                completion(turnResult)
+            }
+        } else {
+            completion(turnResult)
+        }
+    }
+
+    // MARK: - Test Helpers
+
+    func reset() {
+        turnResult = .completed
+        executeTurnHandler = nil
+        executionDelay = 0
+        executeTurnCalls = []
+        totalTokenBudgetConsumed = 0
+    }
+
+    /// Returns the number of times executeTurn was called
+    var executeTurnCallCount: Int {
+        return executeTurnCalls.count
+    }
+}

ModernTests/FairnessScheduler/Mocks/MockSideEffectPerformer.swift

@@ -0,0 +1,25 @@
+//
+//  MockSideEffectPerformer.swift
+//  ModernTests
+//
+//  Mock implementation of VT100ScreenSideEffectPerforming for testing.
+//  Used to create VT100ScreenMutableState instances without a real PTYSession.
+//
+
+import Foundation
+@testable import iTerm2SharedARC
+
+/// Mock implementation of VT100ScreenSideEffectPerforming for testing VT100ScreenMutableState.
+/// Returns nil for delegates which is acceptable for test scenarios (init/deinit don't use them).
+@objc final class MockSideEffectPerformer: NSObject, VT100ScreenSideEffectPerforming {
+
+    // MARK: - VT100ScreenSideEffectPerforming
+
+    @objc func sideEffectPerformingScreenDelegate() -> (any VT100ScreenDelegate)! {
+        return nil
+    }
+
+    @objc func sideEffectPerformingIntervalTreeObserver() -> (any iTermIntervalTreeObserver)! {
+        return nil
+    }
+}

ModernTests/FairnessScheduler/Mocks/MockTokenExecutorDelegate.swift

@@ -0,0 +1,170 @@
+//
+//  MockTokenExecutorDelegate.swift
+//  ModernTests
+//
+//  Mock implementation of TokenExecutorDelegate for testing.
+//  Provides configurable behavior and call tracking for token execution tests.
+//
+
+import Foundation
+@testable import iTerm2SharedARC
+
+/// Mock implementation of TokenExecutorDelegate for testing.
+final class MockTokenExecutorDelegate: NSObject, TokenExecutorDelegate {
+
+    // MARK: - Configuration
+
+    /// When true, tokenExecutorShouldQueueTokens() returns true (simulates paused/blocked state)
+    var shouldQueueTokens = false
+
+    /// When true, tokenExecutorShouldDiscard() returns true
+    var shouldDiscardTokens = false
+
+    /// Callback invoked when tokenExecutorWillExecuteTokens is called.
+    /// Use this to fulfill expectations in tests.
+    var onWillExecute: (() -> Void)?
+
+    // MARK: - Call Tracking
+
+    private let lock = NSLock()
+    private var _executedLengths: [(total: Int, excluding: Int, throughput: Int)] = []
+    private var _syncCount = 0
+    private var _willExecuteCount = 0
+    private var _handledFlags: [Int64] = []
+
+    var executedLengths: [(total: Int, excluding: Int, throughput: Int)] {
+        lock.lock()
+        defer { lock.unlock() }
+        return _executedLengths
+    }
+
+    var syncCount: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return _syncCount
+    }
+
+    var willExecuteCount: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return _willExecuteCount
+    }
+
+    var handledFlags: [Int64] {
+        lock.lock()
+        defer { lock.unlock() }
+        return _handledFlags
+    }
+
+    // MARK: - TokenExecutorDelegate
+
+    func tokenExecutorShouldQueueTokens() -> Bool {
+        return shouldQueueTokens
+    }
+
+    func tokenExecutorShouldDiscard(token: VT100Token, highPriority: Bool) -> Bool {
+        return shouldDiscardTokens
+    }
+
+    func tokenExecutorDidExecute(lengthTotal: Int, lengthExcludingInBandSignaling: Int, throughput: Int) {
+        lock.lock()
+        _executedLengths.append((lengthTotal, lengthExcludingInBandSignaling, throughput))
+        lock.unlock()
+    }
+
+    func tokenExecutorCursorCoordString() -> NSString {
+        return "(0,0)" as NSString
+    }
+
+    func tokenExecutorSync() {
+        lock.lock()
+        _syncCount += 1
+        lock.unlock()
+    }
+
+    func tokenExecutorHandleSideEffectFlags(_ flags: Int64) {
+        lock.lock()
+        _handledFlags.append(flags)
+        lock.unlock()
+    }
+
+    func tokenExecutorWillExecuteTokens() {
+        lock.lock()
+        _willExecuteCount += 1
+        lock.unlock()
+        onWillExecute?()
+    }
+
+    // MARK: - Test Helpers
+
+    func reset() {
+        lock.lock()
+        shouldQueueTokens = false
+        shouldDiscardTokens = false
+        _executedLengths = []
+        _syncCount = 0
+        _willExecuteCount = 0
+        _handledFlags = []
+        onWillExecute = nil
+        lock.unlock()
+    }
+}
+
+/// TokenExecutorDelegate that tracks execution order for ordering tests.
+/// Provides callbacks when tokens are executed to verify priority ordering.
+final class OrderTrackingTokenExecutorDelegate: NSObject, TokenExecutorDelegate {
+
+    private let lock = NSLock()
+    private var _willExecuteCount = 0
+    private var _totalExecutedLength = 0
+
+    /// Callback invoked with lengthTotal when tokenExecutorDidExecute is called
+    var onExecute: ((Int) -> Void)?
+
+    var willExecuteCount: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return _willExecuteCount
+    }
+
+    var totalExecutedLength: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return _totalExecutedLength
+    }
+
+    // MARK: - TokenExecutorDelegate
+
+    func tokenExecutorShouldQueueTokens() -> Bool {
+        return false  // Allow execution
+    }
+
+    func tokenExecutorShouldDiscard(token: VT100Token, highPriority: Bool) -> Bool {
+        return false  // Don't discard
+    }
+
+    func tokenExecutorDidExecute(lengthTotal: Int, lengthExcludingInBandSignaling: Int, throughput: Int) {
+        lock.lock()
+        _totalExecutedLength += lengthTotal
+        lock.unlock()
+        onExecute?(lengthTotal)
+    }
+
+    func tokenExecutorCursorCoordString() -> NSString {
+        return "(0,0)" as NSString
+    }
+
+    func tokenExecutorSync() {
+        // Not used in ordering tests
+    }
+
+    func tokenExecutorHandleSideEffectFlags(_ flags: Int64) {
+        // Not used in ordering tests
+    }
+
+    func tokenExecutorWillExecuteTokens() {
+        lock.lock()
+        _willExecuteCount += 1
+        lock.unlock()
+    }
+}