How do you test code that depends on time: debounce, timeouts, retries and expiry?

Predict first

A debouncer waits one second after the last keystroke. Three keystrokes arrive, then a manual clock advances one second. What does the debouncer report before and after?

import Foundation

final class ManualClock: Clock, @unchecked Sendable {
    struct Instant: InstantProtocol, Comparable {
        var offset: Duration
        func advanced(by d: Duration) -> Instant { .init(offset: offset + d) }
        func duration(to o: Instant) -> Duration { o.offset - offset }
        static func < (a: Instant, b: Instant) -> Bool { a.offset < b.offset }
    }
    var now = Instant(offset: .zero)
    let minimumResolution = Duration.zero
    private var waiters: [(Instant, CheckedContinuation<Void, Never>)] = []
    private let lock = NSLock()

    func sleep(until deadline: Instant, tolerance: Duration?) async throws {
        if deadline <= now { return }
        await withCheckedContinuation { c in lock.lock(); waiters.append((deadline, c)); lock.unlock() }
    }
    func advance(by d: Duration) {
        lock.lock(); now = now.advanced(by: d)
        let due = waiters.filter { $0.0 <= now }
        waiters.removeAll { $0.0 <= now }
        lock.unlock()
        due.forEach { $0.1.resume() }
    }
}

actor Debouncer<C: Clock<Duration>> {
    let clock: C
    var fired: [String] = []
    var task: Task<Void, Never>?
    init(clock: C) { self.clock = clock }
    func send(_ value: String) {
        task?.cancel()
        task = Task { [clock] in
            try? await clock.sleep(for: .seconds(1))
            if !Task.isCancelled { self.fired.append(value) }
        }
    }
    func result() -> [String] { fired }
}

let clock = ManualClock()
let debouncer = Debouncer(clock: clock)
await debouncer.send("a"); await debouncer.send("ab"); await debouncer.send("abc")
try await Task.sleep(nanoseconds: 50_000_000)
print("before", await debouncer.result())
clock.advance(by: .seconds(1))
try await Task.sleep(nanoseconds: 50_000_000)
print("after", await debouncer.result())

• before [], then after ["abc"]
• before ["a"], then after ["a", "ab", "abc"]
• before ["abc"], then after ["abc"]