[WIP] Dependency traits

Author: grynspan

Sources/Testing/CMakeLists.txt

@@ -58,6 +58,7 @@ add_library(Testing
   Running/Runner.Plan+Dumping.swift
   Running/Runner.RuntimeState.swift
   Running/Runner.swift
+  Running/Serializer.swift
   Running/SkipInfo.swift
   SourceAttribution/Backtrace.swift
   SourceAttribution/Backtrace+Symbolication.swift

Sources/Testing/Running/Serializer.swift

@@ -0,0 +1,59 @@
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for Swift project authors
+//
+
+/// A type whose instances can run a series of work items in strict order.
+///
+/// When a work item is scheduled on an instance of this type, it runs after any
+/// previously-scheduled work items. If it suspends, subsequently-scheduled work
+/// items do not start running; they must wait until the suspended work item
+/// either returns or throws an error.
+final actor Serializer {
+  /// The number of scheduled work items, including (possibly) the one currently
+  /// running.
+  private var scheduledCount = 0
+
+  /// Continuations for any scheduled work items that haven't started yet.
+  private var continuations = [CheckedContinuation<Void, Never>]()
+
+  /// Run a work item serially after any previously-scheduled work items.
+  ///
+  /// - Parameters:
+  ///     - workItem: A closure to run.
+  ///
+  /// - Returns: Whatever is returned from `workItem`.
+  ///
+  /// - Throws: Whatever is thrown by `workItem`.
+  func run<R>(_ workItem: @Sendable @isolated(any) () async throws -> sending R) async rethrows -> R {
+    scheduledCount += 1
+    defer {
+      // Resume the next scheduled closure.
+      if !continuations.isEmpty {
+        let continuation = continuations.removeFirst()
+        continuation.resume()
+      }
+
+      scheduledCount -= 1
+    }
+
+    await withCheckedContinuation { continuation in
+      if scheduledCount == 1 {
+        // Nothing else was scheduled, so we can resume immediately.
+        continuation.resume()
+      } else {
+        // Something was scheduled, so add the continuation to the list. When it
+        // resumes, we can run.
+        continuations.append(continuation)
+      }
+    }
+
+    return try await workItem()
+  }
+}
+

Sources/Testing/Support/Environment.swift

@@ -89,24 +89,41 @@ enum Environment {
   }()
 #endif
 
+  /// The address of the environment block, if available.
+  ///
+  /// The value of this property is always `nil` on Windows and on platforms
+  /// that do not support environment variables.
+  static var unsafeAddress: UnsafeMutablePointer<UnsafeMutablePointer<CChar>?>? {
+#if SWT_NO_ENVIRONMENT_VARIABLES
+    nil
+#elseif SWT_TARGET_OS_APPLE
+    _NSGetEnviron()?.pointee
+#elseif os(Linux) || os(FreeBSD) || os(OpenBSD) || os(Android)
+    swt_environ()
+#elseif os(WASI)
+    __wasilibc_get_environ()
+#elseif os(Windows)
+    nil
+#else
+#warning("Platform-specific implementation missing: environment variables unavailable")
+    nil
+#endif
+  }
+
   /// Get all environment variables in the current process.
   ///
   /// - Returns: A copy of the current process' environment dictionary.
   static func get() -> [String: String] {
 #if SWT_NO_ENVIRONMENT_VARIABLES
     simulatedEnvironment.rawValue
-#elseif SWT_TARGET_OS_APPLE
-#if !SWT_NO_DYNAMIC_LINKING
+#elseif SWT_TARGET_OS_APPLE || os(Linux) || os(FreeBSD) || os(OpenBSD) || os(Android) || os(WASI)
+#if SWT_TARGET_OS_APPLE && !SWT_NO_DYNAMIC_LINKING
     _environ_lock_np?()
     defer {
       _environ_unlock_np?()
     }
 #endif
-    return _get(fromEnviron: _NSGetEnviron()!.pointee!)
-#elseif os(Linux) || os(FreeBSD) || os(OpenBSD) || os(Android)
-    _get(fromEnviron: swt_environ())
-#elseif os(WASI)
-    _get(fromEnviron: __wasilibc_get_environ())
+    return _get(fromEnviron: Self.unsafeAddress!)
 #elseif os(Windows)
     guard let environ = GetEnvironmentStringsW() else {
       return [:]
@@ -153,7 +170,9 @@ enum Environment {
     defer {
       _environ_unlock_np?()
     }
-    let environ = _NSGetEnviron()!.pointee!
+    guard let environ = Self.unsafeAddress else {
+      return nil
+    }
 
     return name.withCString { name in
       for i in 0... {

Sources/Testing/Testing.docc/Parallelization.md

@@ -19,6 +19,8 @@ accomplished by the testing library using task groups, and tests generally all
 run in the same process. The number of tests that run concurrently is controlled
 by the Swift runtime.
 
+<!-- TODO: discuss .serialized(for:) -->
+
 ## Disabling parallelization
 
 Parallelization can be disabled on a per-function or per-suite basis using the