Merge pull request #330 from apple/revert-326-chefski/add-async-support

Revert "[REVIEW] Add Async Support to XCTest"

Author: stmontgomery

.gitignore

@@ -4,4 +4,3 @@ xcuserdata
 *.xcscmblueprint
 .build/
 Output/
-Tests/Functional/.lit_test_times.txt

CMakeLists.txt

@@ -29,7 +29,6 @@ add_library(XCTest
   Sources/XCTest/Private/SourceLocation.swift
   Sources/XCTest/Private/WaiterManager.swift
   Sources/XCTest/Private/IgnoredErrors.swift
-  Sources/XCTest/Private/XCTestCase.TearDownBlocksState.swift
   Sources/XCTest/Public/XCTestRun.swift
   Sources/XCTest/Public/XCTestMain.swift
   Sources/XCTest/Public/XCTestCase.swift

Sources/XCTest/Private/XCTestCase.TearDownBlocksState.swift

@@ -52,10 +52,6 @@ open class XCTest {
         perform(testRun!)
     }
 
-    /// Async setup method called before the invocation of `setUpWithError` for each test method in the class.
-    @available(macOS 12.0, *)
-    open func setUp() async throws {}
-
     /// Setup method called before the invocation of `setUp` and the test method
     /// for each test method in the class.
     open func setUpWithError() throws {}
@@ -72,11 +68,6 @@ open class XCTest {
     /// for each test method in the class.
     open func tearDownWithError() throws {}
 
-    /// Async teardown method which is called after the invocation of `tearDownWithError`
-    /// for each test method in the class.
-    @available(macOS 12.0, *)
-    open func tearDown() async throws {}
-
     // FIXME: This initializer is required due to a Swift compiler bug on Linux.
     //        It should be removed once the bug is fixed.
     public init() {}

Sources/XCTest/Public/XCAbstractTest.swift

@@ -195,23 +195,23 @@ open class XCTestCase: XCTest {
     /// class.
     open class func tearDown() {}
 
-    private let teardownBlocksState = TeardownBlocksState()
+    private var teardownBlocks: [() -> Void] = []
+    private var teardownBlocksDequeued: Bool = false
+    private let teardownBlocksQueue: DispatchQueue = DispatchQueue(label: "org.swift.XCTest.XCTestCase.teardownBlocks")
 
     /// Registers a block of teardown code to be run after the current test
     /// method ends.
     open func addTeardownBlock(_ block: @escaping () -> Void) {
-        teardownBlocksState.append(block)
-    }
-
-    /// Registers a block of teardown code to be run after the current test
-    /// method ends.
-    @available(macOS 12.0, *)
-    public func addTeardownBlock(_ block: @Sendable @escaping () async throws -> Void) {
-        teardownBlocksState.appendAsync(block)
+        teardownBlocksQueue.sync {
+            precondition(!self.teardownBlocksDequeued, "API violation -- attempting to add a teardown block after teardown blocks have been dequeued")
+            self.teardownBlocks.append(block)
+        }
     }
 
     private func performSetUpSequence() {
-        func handleErrorDuringSetUp(_ error: Error) {
+        do {
+            try setUpWithError()
+        } catch {
             if error.xct_shouldRecordAsTestFailure {
                 recordFailure(for: error)
             }
@@ -225,60 +225,33 @@ open class XCTestCase: XCTest {
             }
         }
 
-        do {
-            if #available(macOS 12.0, *) {
-                try awaitUsingExpectation {
-                    try await self.setUp()
-                }
-            }
-        } catch {
-            handleErrorDuringSetUp(error)
-        }
-
-        do {
-            try setUpWithError()
-        } catch {
-            handleErrorDuringSetUp(error)
-        }
-
         setUp()
     }
 
     private func performTearDownSequence() {
-        func handleErrorDuringTearDown(_ error: Error) {
-            if error.xct_shouldRecordAsTestFailure {
-                recordFailure(for: error)
-            }
-        }
-
-        func runTeardownBlocks() {
-            for block in self.teardownBlocksState.finalize().reversed() {
-                do {
-                    try block()
-                } catch {
-                    handleErrorDuringTearDown(error)
-                }
-            }
-        }
-
         runTeardownBlocks()
 
         tearDown()
 
         do {
             try tearDownWithError()
         } catch {
-            handleErrorDuringTearDown(error)
+            if error.xct_shouldRecordAsTestFailure {
+                recordFailure(for: error)
+            }
+        }
+    }
+
+    private func runTeardownBlocks() {
+        let blocks = teardownBlocksQueue.sync { () -> [() -> Void] in
+            self.teardownBlocksDequeued = true
+            let blocks = self.teardownBlocks
+            self.teardownBlocks = []
+            return blocks
         }
 
-        do {
-            if #available(macOS 12.0, *) {
-                try awaitUsingExpectation {
-                    try await self.tearDown()
-                }
-            }
-        } catch {
-            handleErrorDuringTearDown(error)
+        for block in blocks.reversed() {
+            block()
         }
     }
 
@@ -319,59 +292,3 @@ private func test<T: XCTestCase>(_ testFunc: @escaping (T) -> () throws -> Void)
         try testFunc(testCase)()
     }
 }
-
-@available(macOS 12.0, *)
-public func asyncTest<T: XCTestCase>(
-    _ testClosureGenerator: @escaping (T) -> () async throws -> Void
-) -> (T) -> () throws -> Void {
-    return { (testType: T) in
-        let testClosure = testClosureGenerator(testType)
-        return {
-            try awaitUsingExpectation(testClosure)
-        }
-    }
-}
-
-@available(macOS 12.0, *)
-func awaitUsingExpectation(
-    _ closure: @escaping () async throws -> Void
-) throws -> Void {
-    let expectation = XCTestExpectation(description: "async test completion")
-    let thrownErrorWrapper = ThrownErrorWrapper()
-
-    Task {
-        defer { expectation.fulfill() }
-
-        do {
-            try await closure()
-        } catch {
-            thrownErrorWrapper.error = error
-        }
-    }
-
-    _ = XCTWaiter.wait(for: [expectation], timeout: asyncTestTimeout)
-
-    if let error = thrownErrorWrapper.error {
-        throw error
-    }
-}
-
-private final class ThrownErrorWrapper: @unchecked Sendable {
-
-    private var _error: Error?
-
-    var error: Error? {
-        get {
-            XCTWaiter.subsystemQueue.sync { _error }
-        }
-        set {
-            XCTWaiter.subsystemQueue.sync { _error = newValue }
-        }
-    }
-}
-
-
-// This time interval is set to a very large value due to their being no real native timeout functionality within corelibs-xctest.
-// With the introduction of async/await support, the framework now relies on XCTestExpectations internally to coordinate the addition async portions of setup and tear down.
-// This time interval is the timeout corelibs-xctest uses with XCTestExpectations.
-private let asyncTestTimeout: TimeInterval = 60 * 60 * 24 * 30