Add back the missing tests

Sean Olszewski · Sean Olszewski · commit cb41e5585fac · 2021-09-09T12:19:25.000-07:00
diff --git a/Sources/XCTest/Public/XCTestCase.swift b/Sources/XCTest/Public/XCTestCase.swift
@@ -35,7 +35,7 @@ open class XCTestCase: XCTest {
     private let testClosure: XCTestCaseClosure
 
     private var skip: XCTSkip?
-    private let teardownBlocksState: XCTestCase.TeardownBlocksState
+    private let teardownBlocksState = XCTestCase.TeardownBlocksState()
 
     /// The name of the test case, consisting of its class name and the method
     /// name it will run.
@@ -201,6 +201,13 @@ open class XCTestCase: XCTest {
     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, *)
+    open func addTeardownBlock(_ block: @escaping () async throws -> Void) {
+        teardownBlocksState.append(block)
+    }
 
     private func performSetUpSequence() {
         func handleErrorDuringSetUp(_ error: Error) {
@@ -236,35 +243,25 @@ open class XCTestCase: XCTest {
         self.setUp()
     }
     
-    static let asyncTestTimeout = 5
     
-    @available(macOS 12.0.0, *)
     private func performTearDownSequence() {
-        @Sendable func handleErrorDuringTearDown(_ error: Error) {
+        func handleErrorDuringTearDown(_ error: Error) {
             if error.xct_shouldRecordAsTestFailure {
                 recordFailure(for: error)
             }
         }
         
-        @Sendable func runTeardownBlocks(errorHandler: @escaping (Error) -> Void) async {
-            for block in teardownBlocks.finalize().reversed() {
+        func runTeardownBlocks(errorHandler: @escaping (Error) -> Void) {
+            for block in self.teardownBlocksState.finalize().reversed() {
                 do {
-                    try await block()
+                    try block()
                 } catch {
                     errorHandler(error)
                 }
             }
         }
         
-        let runTeardownBlocksExpectation = XCTestExpectation(description: "runTeardownBlocksExpectation")
-        Task {
-            defer { runTeardownBlocksExpectation.fulfill() }
-            await runTeardownBlocks(errorHandler: handleErrorDuringTearDown(_:))
-        }
-        _ = XCTWaiter.wait(for: [runTeardownBlocksExpectation], timeout: Self.asyncTestTimeout)
-        
-        
-        runTeardownBlocks()
+        runTeardownBlocks(errorHandler: handleErrorDuringTearDown(_:))
 
         tearDown()
 
@@ -285,19 +282,6 @@ open class XCTestCase: XCTest {
         }
     }
 
-    private func runTeardownBlocks() {
-        let blocks = teardownBlocksQueue.sync { () -> [() -> Void] in
-            self.teardownBlocksDequeued = true
-            let blocks = self.teardownBlocks
-            self.teardownBlocks = []
-            return blocks
-        }
-
-        for block in blocks.reversed() {
-            block()
-        }
-    }
-
     open var continueAfterFailure: Bool {
         get {
             return true
diff --git a/Tests/Functional/Asynchronous/Use/main.swift b/Tests/Functional/Asynchronous/Use/main.swift
@@ -49,7 +49,7 @@ class AsyncAwaitTests: XCTestCase {
             ("test_asyncAwaitCalls_withinTeardownBlocks_areSupported",    asyncTest(test_asyncAwaitCalls_withinTeardownBlocks_areSupported)),
             ("test_asyncErrors_withinTeardownBlocks_areReported",         asyncTest(test_asyncErrors_withinTeardownBlocks_areReported)),
             ("test_somethingAsyncWithDelay",                              asyncTest(test_somethingAsyncWithDelay)),
-            ("test_syncWithinClassWithAsyncTestMethods",                  asyncTest(test_syncWithinClassWithAsyncTestMethods)),
+            ("test_syncWithinClassWithAsyncTestMethods",                  test_syncWithinClassWithAsyncTestMethods),
         ]
     }()
     
@@ -97,7 +97,8 @@ class AsyncAwaitTests: XCTestCase {
     
     // CHECK: Test Case 'AsyncAwaitTests.test_asyncAwaitCalls_withinTeardownBlocks_areSupported' started at \d+-\d+-\d+ \d+:\d+:\d+\.\d+
     // CHECK: In teardown block\n
-    // CHECK: Test Case 'AsyncAwaitTests.test_asyncAwaitCalls_withinTeardownBlocks_areSupported' passed \(\d+\.\d+ seconds\)
+    // CHECK: \<EXPR\>:0: error: AsyncAwaitTests.test_asyncAwaitCalls_withinTeardownBlocks_areSupported : threw error "example"
+    // CHECK: Test Case 'AsyncAwaitTests.test_asyncAwaitCalls_withinTeardownBlocks_areSupported' failed \(\d+\.\d+ seconds\)
     func test_asyncAwaitCalls_withinTeardownBlocks_areSupported() async throws {
         addTeardownBlock {
             print("In teardown block")
@@ -168,12 +169,12 @@ private extension AsyncAwaitTests {
 }
 
 // CHECK: Test Suite 'AsyncAwaitTests' failed at \d+-\d+-\d+ \d+:\d+:\d+\.\d+
-// CHECK: \t Executed 8 tests, with 3 failures \(2 unexpected\) in \d+\.\d+ \(\d+\.\d+\) seconds
+// CHECK: \t Executed 8 tests, with 4 failures \(3 unexpected\) in \d+\.\d+ \(\d+\.\d+\) seconds
 // CHECK: Test Suite '.*\.xctest' failed at \d+-\d+-\d+ \d+:\d+:\d+\.\d+
-// CHECK: \t Executed 8 tests, with 3 failures \(2 unexpected\) in \d+\.\d+ \(\d+\.\d+\) seconds
+// CHECK: \t Executed 8 tests, with 4 failures \(3 unexpected\) in \d+\.\d+ \(\d+\.\d+\) seconds
 
 XCTMain([testCase(AsyncAwaitTests.allTests)])
 
 // CHECK: Test Suite 'All tests' failed at \d+-\d+-\d+ \d+:\d+:\d+\.\d+
-// CHECK: \t Executed 8 tests, with 3 failures \(2 unexpected\) in \d+\.\d+ \(\d+\.\d+\) seconds
+// CHECK: \t Executed 8 tests, with 4 failures \(3 unexpected\) in \d+\.\d+ \(\d+\.\d+\) seconds
 
diff --git a/Tests/Functional/TestCaseLifecycle/main.swift b/Tests/Functional/TestCaseLifecycle/main.swift
@@ -25,17 +25,20 @@ class SetUpTearDownTestCase: XCTestCase {
     override class func setUp() {
         super.setUp()
         print("In class \(#function)")
+        XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")
     }
 
     override func setUp() {
         super.setUp()
         print("In \(#function)")
         value = 42
+        XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")
     }
 
     override func tearDown() {
         super.tearDown()
         print("In \(#function)")
+        XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")
     }
 
 // CHECK: Test Case 'SetUpTearDownTestCase.test_hasValueFromSetUp' started at \d+-\d+-\d+ \d+:\d+:\d+\.\d+
@@ -52,6 +55,7 @@ class SetUpTearDownTestCase: XCTestCase {
     override class func tearDown() {
         super.tearDown()
         print("In class \(#function)")
+        XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")
     }
 }
 // CHECK: Test Suite 'SetUpTearDownTestCase' passed at \d+-\d+-\d+ \d+:\d+:\d+\.\d+
@@ -95,16 +99,21 @@ class TeardownBlocksTestCase: XCTestCase {
             ("test_withSeveralTeardownBlocks", test_withSeveralTeardownBlocks),
         ]
     }()
+    
+    override func setUp() {
+        XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")
+    }
 
     override func tearDown() {
         print("In tearDown function")
+        XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")
     }
 
     // CHECK: Test Case 'TeardownBlocksTestCase.test_withoutTeardownBlocks' started at \d+-\d+-\d+ \d+:\d+:\d+\.\d+
     // CHECK: In tearDown function
     // CHECK: Test Case 'TeardownBlocksTestCase.test_withoutTeardownBlocks' passed \(\d+\.\d+ seconds\)
     func test_withoutTeardownBlocks() {
-        // Intentionally blank
+        XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")
     }
 
     // CHECK: Test Case 'TeardownBlocksTestCase.test_withATeardownBlock' started at \d+-\d+-\d+ \d+:\d+:\d+\.\d+
@@ -114,6 +123,7 @@ class TeardownBlocksTestCase: XCTestCase {
     func test_withATeardownBlock() {
         addTeardownBlock {
             print("In teardown block A")
+            XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")
         }
     }
 
@@ -125,9 +135,11 @@ class TeardownBlocksTestCase: XCTestCase {
     func test_withSeveralTeardownBlocks() {
         addTeardownBlock {
             print("In teardown block B")
+            XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")
         }
         addTeardownBlock {
             print("In teardown block C")
+            XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -25,17 +25,20 @@ class SetUpTearDownTestCase: XCTestCase {`
`25`	`25`	`override class func setUp() {`
`26`	`26`	`super.setUp()`
`27`	`27`	`print("In class \(#function)")`
	`28`	`+ XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")`
`28`	`29`	`}`
`29`	`30`
`30`	`31`	`override func setUp() {`
`31`	`32`	`super.setUp()`
`32`	`33`	`print("In \(#function)")`
`33`	`34`	`value = 42`
	`35`	`+ XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")`
`34`	`36`	`}`
`35`	`37`
`36`	`38`	`override func tearDown() {`
`37`	`39`	`super.tearDown()`
`38`	`40`	`print("In \(#function)")`
	`41`	`+ XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")`
`39`	`42`	`}`
`40`	`43`
`41`	`44`	`// CHECK: Test Case 'SetUpTearDownTestCase.test_hasValueFromSetUp' started at \d+-\d+-\d+ \d+:\d+:\d+\.\d+`
`@@ -52,6 +55,7 @@ class SetUpTearDownTestCase: XCTestCase {`
`52`	`55`	`override class func tearDown() {`
`53`	`56`	`super.tearDown()`
`54`	`57`	`print("In class \(#function)")`
	`58`	`+ XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")`
`55`	`59`	`}`
`56`	`60`	`}`
`57`	`61`	`// CHECK: Test Suite 'SetUpTearDownTestCase' passed at \d+-\d+-\d+ \d+:\d+:\d+\.\d+`
`@@ -95,16 +99,21 @@ class TeardownBlocksTestCase: XCTestCase {`
`95`	`99`	`("test_withSeveralTeardownBlocks", test_withSeveralTeardownBlocks),`
`96`	`100`	`]`
`97`	`101`	`}()`
	`102`	`+`
	`103`	`+ override func setUp() {`
	`104`	`+ XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")`
	`105`	`+ }`
`98`	`106`
`99`	`107`	`override func tearDown() {`
`100`	`108`	`print("In tearDown function")`
	`109`	`+ XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")`
`101`	`110`	`}`
`102`	`111`
`103`	`112`	`// CHECK: Test Case 'TeardownBlocksTestCase.test_withoutTeardownBlocks' started at \d+-\d+-\d+ \d+:\d+:\d+\.\d+`
`104`	`113`	`// CHECK: In tearDown function`
`105`	`114`	`// CHECK: Test Case 'TeardownBlocksTestCase.test_withoutTeardownBlocks' passed \(\d+\.\d+ seconds\)`
`106`	`115`	`func test_withoutTeardownBlocks() {`
`107`		`- // Intentionally blank`
	`116`	`+ XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")`
`108`	`117`	`}`
`109`	`118`
`110`	`119`	`// CHECK: Test Case 'TeardownBlocksTestCase.test_withATeardownBlock' started at \d+-\d+-\d+ \d+:\d+:\d+\.\d+`
`@@ -114,6 +123,7 @@ class TeardownBlocksTestCase: XCTestCase {`
`114`	`123`	`func test_withATeardownBlock() {`
`115`	`124`	`addTeardownBlock {`
`116`	`125`	`print("In teardown block A")`
	`126`	`+ XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")`
`117`	`127`	`}`
`118`	`128`	`}`
`119`	`129`
`@@ -125,9 +135,11 @@ class TeardownBlocksTestCase: XCTestCase {`
`125`	`135`	`func test_withSeveralTeardownBlocks() {`
`126`	`136`	`addTeardownBlock {`
`127`	`137`	`print("In teardown block B")`
	`138`	`+ XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")`
`128`	`139`	`}`
`129`	`140`	`addTeardownBlock {`
`130`	`141`	`print("In teardown block C")`
	`142`	`+ XCTAssert(Thread.isMainThread, "Expected to be ran on the main thread, but wasn't.")`
`131`	`143`	`}`
`132`	`144`	`}`
`133`	`145`	`}`