Unable to use RunLoop to allow task to advance

[jonreid]

Description

Say we have a UIKit table view controller which loads its data by doing this inside viewDidLoad():

Task {
    results = await viewModel.load()
    self.tableView.reloadData()
}

I am able to test this in XCTest by pumping the run loop. This does not work in Swift Testing.

Expected behavior

With XCTest, I can allow the task to proceed by polling for the expected results in a loop that calls:

RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.01))

Actual behavior

With Swift Testing, pumping the run loop does not advance the task.

I added print statements in 2 places: one inside the Task after the await, and another at the end of the test case, both XCTest and Swift Testing.

• XCTest: Task completes, then test completes
• Swift Testing: Test completes, then task completes

Steps to reproduce

In https://github.com/jonreid/ExpectToEventuallyEqual there is a SampleApp that contains both XCTest and Swift Testing targets. The print statements are in place inside TableViewController viewDidLoad(), and at the end of test_numberOfRows and numberOfRows. Run each to see the difference in behavior.

swift-testing version/commit hash

Xcode 16.0.0 built-in

Swift & OS version (output of swift --version ; uname -a)

swift-driver version: 1.115 Apple Swift version 6.0 (swiftlang-6.0.0.9.10 clang-1600.0.26.2)
Target: arm64-apple-macosx14.0
Darwin Llama.local 23.6.0 Darwin Kernel Version 23.6.0: Mon Jul 29 21:14:30 PDT 2024; root:xnu-10063.141.2~1/RELEASE_ARM64_T6000 arm64

[grynspan]

Just to clarify: is the test in question marked @MainActor? Is it async?

[jonreid]

It is @MainActor. Tried both with and without async.

[grynspan]

Alright, thanks. Interactions between the main actor and main run loop are controlled by the Swift runtime, so I'm going to move this issue to the main Swift repo.

[grynspan]

I don't see the Swift Testing implementation of (I assume) @Test numberOfRows() in your repo. Mind helping me find it?

[jonreid]

@grynspan I moved it to a swift-testing branch. Here's the broken commit: jonreid/ExpectToEventuallyEqual@01d91f0

[grynspan]

I was not able to reproduce the issue with this minimal test case:

@MainActor
var string = "abc123"

@MainActor
@Test func example() throws {
  RunLoop.main.schedule(after: RunLoop.main.now.advanced(by: .seconds(3)), tolerance: .zero, options: nil) {
    string = "book 2"
  }
  try expectToEventuallyEqual(
    actual: { string },
    expected: "book 2"
  )
}

However, changing the test function to use Task {} instead of RunLoop.main.schedule() did show the issue:

@MainActor
@Test func example() throws {
  Task {
    try await Task.sleep(nanoseconds: 3_000_000_000)
    string = "book 2"
  }
  try expectToEventuallyEqual(
    actual: { string },
    expected: "book 2"
  )
}

This is more or less expected in my experience: Swift Concurrency schedules work on the main actor using the main dispatch queue, not the main run loop. The main run loop is implemented above the main dispatch queue. So spinning the run loop will drain pending events scheduled on the run loop, but the main dispatch queue remains stuck in the same work item while the spin takes place. The same basic problem is why you need to use await fulfillment(of:) in an async XCTest test instead of XCTWaiter.wait(for:), BTW.

There are a couple of ways to resolve this issue:

• Instead of spinning the main run loop, make expectToEventuallyEqual() async and have it call Task.sleep() instead of runLoop.run(). This requires callers to be async.
• Instead of using Task {} to schedule a child task, use RunLoop.current.run() (or some variant thereof) to ensure asynchronous work is scheduled using the main run loop. This precludes the use of async code given RunLoop's current API surface.

[jonreid]

@grynspan Thank you for this detailed breakdown with explanation. I was stuck in the old world. Maybe I can learn new tricks after all!

[grynspan]

Happy to help!