Avoid reassigning task-local runtime state in a Runner's event handler unless it's nested (#339)

This is a mitigation for a bug in which an expectation inside a
`withTaskGroup` closure can cause a crash if it fails.

### Motivation:

It can sometimes be useful to perform expectations (e.g. `#expect`)
within the body of the closure passed to `withTaskGroup` or similar
APIs. However, doing so currently causes a crash if the expectation
fails, illustrated by this small example:

```swift
@test func example() async {
  await withTaskGroup(of: Void.self) { _ in
    #expect("abc" == "123") // 💥
  }
}
```

### Modifications:

This change avoids wrapping the event handler of a runner's
configuration with one that reassigns a TaskLocal (potentially
triggering the crash) unless that runner is running during the run
operation of another runner. In other words, only mutate the TaskLocal
for nested runners. Nesting, or running one runner in the context of
another, is something which is only done in practice when performing
tests of the testing library itself. Ordinary usage of the testing
library only has one “outer“ runner.

### Result:

The above example code no longer crashes, verified by the new unit test.

### Checklist:

- [x] Code and documentation should follow the style of the [Style
Guide](https://github.com/apple/swift-testing/blob/main/Documentation/StyleGuide.md).
- [x] If public symbols are renamed or modified, DocC references should
be updated.

Resolves rdar://126132392

Author: stmontgomery

Sources/Testing/Running/Runner.RuntimeState.swift

@@ -25,9 +25,10 @@ extension Runner {
     /// The test case that is running on the current task, if any.
     var testCase: Test.Case?
 
-    /// The runtime state related to the runner running on the current task.
+    /// The runtime state related to the runner running on the current task,
+    /// if any.
     @TaskLocal
-    static var current = Self()
+    static var current: Self?
   }
 }
 
@@ -42,7 +43,10 @@ extension Runner {
   /// In practice, the primary scenario where this is important is when running
   /// the testing library's own tests.
   mutating func configureEventHandlerRuntimeState() {
-    let existingRuntimeState = RuntimeState.current
+    guard let existingRuntimeState = RuntimeState.current else {
+      return
+    }
+
     configuration.eventHandler = { [eventHandler = configuration.eventHandler] event, context in
       RuntimeState.$current.withValue(existingRuntimeState) {
         eventHandler(event, context)
@@ -56,7 +60,7 @@ extension Runner {
 extension Configuration {
   /// The configuration for the current task, if any.
   public static var current: Self? {
-    Runner.RuntimeState.current.configuration
+    Runner.RuntimeState.current?.configuration
   }
 
   /// Call a function while the value of ``Configuration/current`` is set.
@@ -74,7 +78,7 @@ extension Configuration {
       configuration._removeFromAll(identifiedBy: id)
     }
 
-    var runtimeState = Runner.RuntimeState.current
+    var runtimeState = Runner.RuntimeState.current ?? .init()
     runtimeState.configuration = configuration
     return try await Runner.RuntimeState.$current.withValue(runtimeState, operation: body)
   }
@@ -144,7 +148,7 @@ extension Test {
   /// or [`DispatchQueue.async(execute:)`](https://developer.apple.com/documentation/dispatch/dispatchqueue/2016103-async)),
   /// the value of this property may be `nil`.
   public static var current: Self? {
-    Runner.RuntimeState.current.test
+    Runner.RuntimeState.current?.test
   }
 
   /// Call a function while the value of ``Test/current`` is set.
@@ -157,7 +161,7 @@ extension Test {
   ///
   /// - Throws: Whatever is thrown by `body`.
   static func withCurrent<R>(_ test: Self, perform body: () async throws -> R) async rethrows -> R {
-    var runtimeState = Runner.RuntimeState.current
+    var runtimeState = Runner.RuntimeState.current ?? .init()
     runtimeState.test = test
     return try await Runner.RuntimeState.$current.withValue(runtimeState, operation: body)
   }
@@ -177,7 +181,7 @@ extension Test.Case {
   /// or [`DispatchQueue.async(execute:)`](https://developer.apple.com/documentation/dispatch/dispatchqueue/2016103-async)),
   /// the value of this property may be `nil`.
   public static var current: Self? {
-    Runner.RuntimeState.current.testCase
+    Runner.RuntimeState.current?.testCase
   }
 
   /// Call a function while the value of ``Test/Case/current`` is set.
@@ -190,7 +194,7 @@ extension Test.Case {
   ///
   /// - Throws: Whatever is thrown by `body`.
   static func withCurrent<R>(_ testCase: Self, perform body: () async throws -> R) async rethrows -> R {
-    var runtimeState = Runner.RuntimeState.current
+    var runtimeState = Runner.RuntimeState.current ?? .init()
     runtimeState.testCase = testCase
     return try await Runner.RuntimeState.$current.withValue(runtimeState, operation: body)
   }

Tests/TestingTests/Runner.RuntimeStateTests.swift

@@ -25,4 +25,21 @@ struct Runner_RuntimeStateTests {
 
     await Test(name: "foo") {}.run(configuration: configuration)
   }
+
+  // This confirms that an event posted within the closure of `withTaskGroup`
+  // (and similar APIs) in regular tests (those which are not testing the
+  // testing library itself) are handled appropriately and do not crash.
+  @Test func eventPostingInTaskGroup() async {
+    // Enable delivery of "expectation checked" events, merely as a way to allow
+    // an event to be posted during the test below without causing any real
+    // issues to be recorded or otherwise confuse the testing harness.
+    var configuration = Configuration.current ?? .init()
+    configuration.deliverExpectationCheckedEvents = true
+
+    await Configuration.withCurrent(configuration) {
+      await withTaskGroup(of: Void.self) { group in
+        #expect(Bool(true))
+      }
+    }
+  }
 }

Tests/TestingTests/RunnerTests.swift

@@ -49,6 +49,13 @@ struct NeverRunTests {
 }
 
 final class RunnerTests: XCTestCase {
+  func testInitialTaskLocalState() {
+    // These are expected to be `nil` since this is an XCTest.
+    XCTAssertNil(Test.current)
+    XCTAssertNil(Test.Case.current)
+    XCTAssertNil(Configuration.current)
+  }
+
   func testDefaultInit() async throws {
     let runner = await Runner()
     XCTAssertFalse(runner.tests.contains(where: \.isHidden))