How do you test async code: async test functions, expectations, confirmations, actors and the main actor?

Predict first

An async test, a callback test with an expectation, and an inverted expectation. Do all three pass?

// === Package.swift ===
// swift-tools-version:6.0
import PackageDescription
let package = Package(name: "Lib", targets: [.target(name: "Lib"), .testTarget(name: "LibTests", dependencies: ["Lib"])])
// === Sources/Lib/Lib.swift ===
import Foundation
public actor Store {
    private var items: [String] = []
    public init() {}
    public func add(_ s: String) async { try? await Task.sleep(nanoseconds: 1_000_000); items.append(s) }
    public func count() -> Int { items.count }
}
public final class Loader: @unchecked Sendable {
    public init() {}
    public func load(_ done: @escaping @Sendable (Int) -> Void) { DispatchQueue.global().asyncAfter(deadline: .now() + 0.01) { done(42) } }
}
// === Tests/LibTests/T.swift ===
import XCTest
@testable import Lib

final class T: XCTestCase {
    func testAsyncAwait() async {
        let store = Store()
        await store.add("a")
        let n = await store.count()
        XCTAssertEqual(n, 1)
    }
    func testCallbackWithExpectation() async {
        let done = expectation(description: "loaded")
        let result = ResultBox()
        Loader().load { v in result.set(v); done.fulfill() }
        await fulfillment(of: [done], timeout: 2)
        XCTAssertEqual(result.value, 42)
    }
    func testInvertedExpectation() async {
        let never = expectation(description: "must not fire")
        never.isInverted = true
        await fulfillment(of: [never], timeout: 0.1)
    }
}
final class ResultBox: @unchecked Sendable {
    private let lock = NSLock(); private var v = 0
    func set(_ x: Int) { lock.lock(); v = x; lock.unlock() }
    var value: Int { lock.lock(); defer { lock.unlock() }; return v }
}

• Yes, all three pass
• The callback test fails because it is not on the main thread
• The inverted one fails because nothing fires