[pull] swiftwasm from main

CMakeLists.txt

@@ -8,13 +8,29 @@ project(XCTest LANGUAGES Swift)
 option(BUILD_SHARED_LIBS "Build shared libraries" ON)
 option(USE_FOUNDATION_FRAMEWORK "Use Foundation.framework on Darwin" NO)
 
-if(NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
+set(DISABLE_XCTWAITER_default NO)
+
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL wasm32)
+  set(DISABLE_XCTWAITER_default ON)
+endif()
+
+option(DISABLE_XCTWAITER "Disable XCTWaiter" "${DISABLE_XCTWAITER_default}")
+
+if(NOT CMAKE_SYSTEM_NAME STREQUAL Darwin AND NOT DISABLE_XCTWAITER)
   find_package(dispatch CONFIG REQUIRED)
   find_package(Foundation CONFIG REQUIRED)
 endif()
 
 include(SwiftSupport)
 include(GNUInstallDirs)
+include(CheckLinkerFlag)
+
+if(CMAKE_SYSTEM_NAME STREQUAL Linux
+    OR CMAKE_SYSTEM_NAME STREQUAL FreeBSD
+    OR CMAKE_SYSTEM_NAME STREQUAL OpenBSD)
+  enable_language(C)
+  check_linker_flag(C "LINKER:--build-id=sha1" LINKER_SUPPORTS_BUILD_ID)
+endif()
 
 add_library(XCTest
   Sources/XCTest/Private/WallClockTimeMetric.swift
@@ -49,6 +65,12 @@ add_library(XCTest
   Sources/XCTest/Public/Asynchronous/XCTWaiter.swift
   Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift
   Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift)
+
+if(DISABLE_XCTWAITER)
+  target_compile_definitions(XCTest PRIVATE
+    DISABLE_XCTWAITER)
+endif()
+
 if(USE_FOUNDATION_FRAMEWORK)
   target_compile_definitions(XCTest PRIVATE
     USE_FOUNDATION_FRAMEWORK)
@@ -65,6 +87,10 @@ set_target_properties(XCTest PROPERTIES
   Swift_MODULE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/swift
   INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_BINARY_DIR}/swift)
 
+if(LINKER_SUPPORTS_BUILD_ID)
+  target_link_options(XCTest PRIVATE "LINKER:--build-id=sha1")
+endif()
+
 
 if(ENABLE_TESTING)
   enable_testing()

README.md

@@ -17,43 +17,7 @@ For general information about using XCTest, see:
 
 The Swift Package Manager integrates directly with XCTest to provide a streamlined experience for unit testing SwiftPM packages. If you are using XCTest within a SwiftPM package, unit test files are located within the package's `Tests` subdirectory, and you can build and run the full test suite in one step by running `swift test`.
 
-For more information about using XCTest with SwiftPM, see its [documentation](https://github.com/apple/swift-package-manager).
-
-### Test Method Discovery
-
-Unlike the version of XCTest included with Xcode, this version does not use the Objective-C runtime to automatically discover test methods because that runtime is not available on all platforms Swift supports. This means that in certain configurations, the full set of test methods must be explicitly provided to XCTest.
-
-When using XCTest via SwiftPM on macOS, this is not necessary because SwiftPM uses the version of XCTest included with Xcode to run tests. But when using this version of XCTest _without_ SwiftPM, or _with_ SwiftPM on a platform other than macOS (including Linux), the full set of test methods cannot be discovered automatically, and your test target must tell XCTest about them explicitly.
-
-The recommended way to do this is to create a static property in each of your `XCTestCase` subclasses. By convention, this property is named `allTests`, and should contain all of the tests in the class. For example:
-
-```swift
-class TestNSURL : XCTestCase {
-    static var allTests = {
-        return [
-            ("test_bestNumber", test_bestNumber),
-            ("test_URLStrings", test_URLStrings),
-            ("test_fileURLWithPath", test_fileURLWithPath),
-            // Other tests go here
-        ]
-    }()
-
-    func test_bestNumber() {
-        // Write your test here. Most of the XCTAssert functions you are familiar with are available.
-        XCTAssertTrue(theBestNumber == 42, "The number is wrong")
-    }
-
-    // Other tests go here
-}
-```
-
-After creating an `allTests` property in each `XCTestCase` subclass, you must tell XCTest about those classes' tests.
-
-If the project is a SwiftPM package which supports macOS, the easiest way to do this is to run `swift test --generate-linuxmain` from a macOS machine. This command generates files within the package's `Tests` subdirectory which contains the necessary source code for passing all test classes and methods to XCTest. These files should be committed to source control and re-generated whenever `XCTestCase` subclasses or test methods are added to or removed from your package's test suite.
-
-If the project is a SwiftPM package but does not support macOS, you may edit the package's default  `LinuxMain.swift` file manually to add all `XCTestCase` subclasses.
-
-If the project is not a SwiftPM package, follow the steps in the next section to create an executable which calls the `XCTMain` function manually.
+For more information about using XCTest with SwiftPM, see its [documentation](https://github.com/swiftlang/swift-package-manager).
 
 ### Standalone Command Line Usage
 

Sources/XCTest/Private/WaiterManager.swift

@@ -9,6 +9,7 @@
 //
 //  WaiterManager.swift
 //
+#if !DISABLE_XCTWAITER
 
 internal protocol ManageableWaiter: AnyObject, Equatable {
     var isFinished: Bool { get }
@@ -143,3 +144,5 @@ internal final class WaiterManager<WaiterType: ManageableWaiter> : NSObject {
     }
 
 }
+
+#endif

Sources/XCTest/Private/XCTestCase.TearDownBlocksState.swift

@@ -12,29 +12,42 @@ extension XCTestCase {
     /// Supports async and sync throwing methods.
     final class TeardownBlocksState {
 
+        #if DISABLE_XCTWAITER
+        typealias TeardownBlock = @Sendable @MainActor () async throws -> Void
+        #else
+        typealias TeardownBlock = () throws -> Void
+        #endif
+
         private var wasFinalized = false
-        private var blocks: [() throws -> Void] = []
+        private var blocks: [TeardownBlock] = []
 
         // We don't want to overload append(_:) below because of how Swift will implicitly promote sync closures to async closures,
         // which can unexpectedly change their semantics in difficult to track down ways.
         //
         // Because of this, we chose the unusual decision to forgo overloading (which is a super sweet language feature <3) to prevent this issue from surprising any contributors to corelibs-xctest
         @available(macOS 12.0, *)
         func appendAsync(_ block: @Sendable @escaping () async throws -> Void) {
+            #if DISABLE_XCTWAITER
+            XCTestCase.subsystemQueue.sync {
+                precondition(wasFinalized == false, "API violation -- attempting to add a teardown block after teardown blocks have been dequeued")
+                blocks.append(block)
+            }
+            #else
             self.append {
                 try awaitUsingExpectation { try await block() }
             }
+            #endif
         }
 
         func append(_ block: @escaping () throws -> Void) {
-            XCTWaiter.subsystemQueue.sync {
+            XCTestCase.subsystemQueue.sync {
                 precondition(wasFinalized == false, "API violation -- attempting to add a teardown block after teardown blocks have been dequeued")
                 blocks.append(block)
             }
         }
 
-        func finalize() -> [() throws -> Void] {
-            XCTWaiter.subsystemQueue.sync {
+        func finalize() -> [TeardownBlock] {
+            XCTestCase.subsystemQueue.sync {
                 precondition(wasFinalized == false, "API violation -- attempting to run teardown blocks after they've already run")
                 wasFinalized = true
                 return blocks

Sources/XCTest/Public/Asynchronous/XCTNSNotificationExpectation.swift

@@ -10,6 +10,8 @@
 //  XCTNSNotificationExpectation.swift
 //
 
+#if !DISABLE_XCTWAITER
+
 /// Expectation subclass for waiting on a condition defined by a Foundation Notification instance.
 open class XCTNSNotificationExpectation: XCTestExpectation {
 
@@ -19,7 +21,7 @@ open class XCTNSNotificationExpectation: XCTestExpectation {
     /// - Returns: `true` if the expectation should be fulfilled, `false` if it should not.
     ///
     /// - SeeAlso: `XCTNSNotificationExpectation.handler`
-    public typealias Handler = (Notification) -> Bool
+    public typealias Handler = @Sendable (Notification) -> Bool
 
     private let queue = DispatchQueue(label: "org.swift.XCTest.XCTNSNotificationExpectation")
 
@@ -114,3 +116,5 @@ open class XCTNSNotificationExpectation: XCTestExpectation {
 /// - SeeAlso: `XCTNSNotificationExpectation.handler`
 @available(*, deprecated, renamed: "XCTNSNotificationExpectation.Handler")
 public typealias XCNotificationExpectationHandler = XCTNSNotificationExpectation.Handler
+
+#endif

Sources/XCTest/Public/Asynchronous/XCTNSPredicateExpectation.swift

@@ -10,6 +10,8 @@
 //  XCTNSPredicateExpectation.swift
 //
 
+#if !DISABLE_XCTWAITER
+
 /// Expectation subclass for waiting on a condition defined by an NSPredicate and an optional object.
 open class XCTNSPredicateExpectation: XCTestExpectation {
 
@@ -18,7 +20,7 @@ open class XCTNSPredicateExpectation: XCTestExpectation {
     /// - Returns: `true` if the expectation should be fulfilled, `false` if it should not.
     ///
     /// - SeeAlso: `XCTNSPredicateExpectation.handler`
-    public typealias Handler = () -> Bool
+    public typealias Handler = @Sendable () -> Bool
 
     private let queue = DispatchQueue(label: "org.swift.XCTest.XCTNSPredicateExpectation")
 
@@ -133,3 +135,4 @@ open class XCTNSPredicateExpectation: XCTestExpectation {
 /// - SeeAlso: `XCTNSPredicateExpectation.handler`
 @available(*, deprecated, renamed: "XCTNSPredicateExpectation.Handler")
 public typealias XCPredicateExpectationHandler = XCTNSPredicateExpectation.Handler
+#endif

Sources/XCTest/Public/Asynchronous/XCTWaiter+Validation.swift

@@ -9,6 +9,7 @@
 //
 //  XCTWaiter+Validation.swift
 //
+#if !DISABLE_XCTWAITER
 
 protocol XCTWaiterValidatableExpectation: Equatable {
     var isFulfilled: Bool { get }
@@ -87,3 +88,5 @@ extension XCTWaiter {
         return .incomplete
     }
 }
+
+#endif

Sources/XCTest/Public/Asynchronous/XCTWaiter.swift

@@ -9,6 +9,7 @@
 //
 //  XCTWaiter.swift
 //
+#if !DISABLE_XCTWAITER
 
 #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
 import CoreFoundation
@@ -479,3 +480,5 @@ extension XCTWaiter: ManageableWaiter {
         }
     }
 }
+
+#endif

Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift

@@ -11,6 +11,8 @@
 //  Methods on XCTestCase for testing asynchronous operations
 //
 
+#if !DISABLE_XCTWAITER
+
 public extension XCTestCase {
 
     /// Creates a point of synchronization in the flow of a test. Only one
@@ -41,7 +43,7 @@ public extension XCTestCase {
     ///   these environments. To ensure compatibility of tests between
     ///   swift-corelibs-xctest and Apple XCTest, it is not recommended to pass
     ///   explicit values for `file` and `line`.
-    // FIXME: This should have `@MainActor` to match Xcode XCTest, but adding it causes errors in tests authored pre-Swift Concurrency which don't typically have `@MainActor`.
+    @preconcurrency @MainActor
     func waitForExpectations(timeout: TimeInterval, file: StaticString = #file, line: Int = #line, handler: XCWaitCompletionHandler? = nil) {
         precondition(Thread.isMainThread, "\(#function) must be called on the main thread")
         if currentWaiter != nil {
@@ -265,3 +267,4 @@ internal extension XCTestCase {
             expected: false)
     }
 }
+#endif

Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift

@@ -9,6 +9,7 @@
 //
 //  XCTestExpectation.swift
 //
+#if !DISABLE_XCTWAITER
 
 /// Expectations represent specific conditions in asynchronous testing.
 open class XCTestExpectation: @unchecked Sendable {
@@ -320,3 +321,5 @@ extension XCTestExpectation: CustomStringConvertible {
         return expectationDescription
     }
 }
+
+#endif

Sources/XCTest/Public/XCAbstractTest.swift

@@ -36,20 +36,43 @@ open class XCTest {
     /// testRunClass. If the test has not yet been run, this will be nil.
     open private(set) var testRun: XCTestRun? = nil
 
+    #if DISABLE_XCTWAITER
+    internal var performTask: Task<Void, Never>?
+
+    internal func _performAsync(_ run: XCTestRun) async {
+        fatalError("Must be overridden by subclasses.")
+    }
+    internal func _runAsync() async {
+        guard let testRunType = testRunClass as? XCTestRun.Type else {
+            fatalError("XCTest.testRunClass must be a kind of XCTestRun.")
+        }
+        testRun = testRunType.init(test: self)
+        await _performAsync(testRun!)
+    }
+    #endif
+
     /// The method through which tests are executed. Must be overridden by
     /// subclasses.
+    #if DISABLE_XCTWAITER
+    @available(*, unavailable)
+    #endif
     open func perform(_ run: XCTestRun) {
         fatalError("Must be overridden by subclasses.")
     }
 
     /// Creates an instance of the `testRunClass` and passes it as a parameter
     /// to `perform()`.
+    #if DISABLE_XCTWAITER
+    @available(*, unavailable)
+    #endif
     open func run() {
+        #if !DISABLE_XCTWAITER
         guard let testRunType = testRunClass as? XCTestRun.Type else {
             fatalError("XCTest.testRunClass must be a kind of XCTestRun.")
         }
         testRun = testRunType.init(test: self)
         perform(testRun!)
+        #endif
     }
 
     /// Async setup method called before the invocation of `setUpWithError` for each test method in the class.