DO NOT MERGE: Run testCancellation 10,000 times

Author: ahoppen

Tests/SwiftSourceKitPluginTests/SwiftSourceKitPluginTests.swift

@@ -272,70 +272,71 @@ final class SwiftSourceKitPluginTests: XCTestCase {
   }
 
   func testCancellation() async throws {
-    try await SkipUnless.sourcekitdSupportsPlugin()
-    let sourcekitd = try await getSourceKitD()
-    let path = scratchFilePath()
-    let positions = try await sourcekitd.openDocument(
-      path,
-      contents: """
-        struct A: ExpressibleByIntegerLiteral { init(integerLiteral value: Int) {} }
-        struct B: ExpressibleByIntegerLiteral { init(integerLiteral value: Int) {} }
-        struct C: ExpressibleByIntegerLiteral { init(integerLiteral value: Int) {} }
-
-        func + (lhs: A, rhs: B) -> A { fatalError() }
-        func + (lhs: B, rhs: C) -> A { fatalError() }
-        func + (lhs: C, rhs: A) -> A { fatalError() }
-
-        func + (lhs: B, rhs: A) -> B { fatalError() }
-        func + (lhs: C, rhs: B) -> B { fatalError() }
-        func + (lhs: A, rhs: C) -> B { fatalError() }
-
-        func + (lhs: C, rhs: B) -> C { fatalError() }
-        func + (lhs: B, rhs: C) -> C { fatalError() }
-        func + (lhs: A, rhs: A) -> C { fatalError() }
-
-        class Foo {
-          func slow(x: Invalid1, y: Invalid2) {
-            let x: C = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 1️⃣
-          }
-
-          struct Foo {
-            let fooMember: String
+    for _ in 0..<10_000 {
+      let sourcekitd = try await getSourceKitD()
+      let path = scratchFilePath()
+      let positions = try await sourcekitd.openDocument(
+        path,
+        contents: """
+          struct A: ExpressibleByIntegerLiteral { init(integerLiteral value: Int) {} }
+          struct B: ExpressibleByIntegerLiteral { init(integerLiteral value: Int) {} }
+          struct C: ExpressibleByIntegerLiteral { init(integerLiteral value: Int) {} }
+
+          func + (lhs: A, rhs: B) -> A { fatalError() }
+          func + (lhs: B, rhs: C) -> A { fatalError() }
+          func + (lhs: C, rhs: A) -> A { fatalError() }
+
+          func + (lhs: B, rhs: A) -> B { fatalError() }
+          func + (lhs: C, rhs: B) -> B { fatalError() }
+          func + (lhs: A, rhs: C) -> B { fatalError() }
+
+          func + (lhs: C, rhs: B) -> C { fatalError() }
+          func + (lhs: B, rhs: C) -> C { fatalError() }
+          func + (lhs: A, rhs: A) -> C { fatalError() }
+
+          class Foo {
+            func slow(x: Invalid1, y: Invalid2) {
+              let x: C = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 1️⃣
+            }
+
+            struct Foo {
+              let fooMember: String
+            }
+
+            func fast(a: Foo) {
+              a.2️⃣
+            }
           }
+          """,
+        compilerArguments: [path]
+      )
 
-          func fast(a: Foo) {
-            a.2️⃣
-          }
+      let slowCompletionResultReceived = self.expectation(description: "slow completion")
+      let slowCompletionTask = Task {
+        do {
+          _ = try await sourcekitd.completeOpen(
+            path: path,
+            position: positions["1️⃣"],
+            filter: ""
+          )
+          XCTFail("Expected completion to be cancelled")
+        } catch {
+          XCTAssert(error is CancellationError, "Expected completion to be cancelled, failed with \(error)")
         }
-        """,
-      compilerArguments: [path]
-    )
-
-    let slowCompletionResultReceived = self.expectation(description: "slow completion")
-    let slowCompletionTask = Task {
-      do {
-        _ = try await sourcekitd.completeOpen(
-          path: path,
-          position: positions["1️⃣"],
-          filter: ""
-        )
-        XCTFail("Expected completion to be cancelled")
-      } catch {
-        XCTAssert(error is CancellationError, "Expected completion to be cancelled, failed with \(error)")
+        slowCompletionResultReceived.fulfill()
       }
-      slowCompletionResultReceived.fulfill()
-    }
-    slowCompletionTask.cancel()
-    try await fulfillmentOfOrThrow([slowCompletionResultReceived], timeout: 30)
+      slowCompletionTask.cancel()
+      try await fulfillmentOfOrThrow([slowCompletionResultReceived], timeout: 30)
 
-    let fastCompletionStarted = Date()
-    let result = try await sourcekitd.completeOpen(
-      path: path,
-      position: positions["2️⃣"],
-      filter: ""
-    )
-    XCTAssert(result.items.count > 0)
-    XCTAssertLessThan(Date().timeIntervalSince(fastCompletionStarted), 30)
+      let fastCompletionStarted = Date()
+      let result = try await sourcekitd.completeOpen(
+        path: path,
+        position: positions["2️⃣"],
+        filter: ""
+      )
+      XCTAssert(result.items.count > 0)
+      XCTAssertLessThan(Date().timeIntervalSince(fastCompletionStarted), 30)
+    }
   }
 
   func testEdits() async throws {