migrate to Swift Testing

Author: kukushechkin

Tests/InMemoryTracingTests/InMemoryTracerTests.swift

@@ -12,11 +12,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if canImport(Testing)
+@_spi(Testing) import InMemoryTracing
 @_spi(Locking) import Instrumentation
 import Testing
 import Tracing
-@_spi(Testing) import InMemoryTracing
 
 @Suite("InMemoryTracer")
 struct InMemoryTracerTests {
@@ -437,5 +436,3 @@ private final class MockClock {
         Instant(nanosecondsSinceEpoch: self._now)
     }
 }
-
-#endif

Tests/InstrumentationTests/InstrumentTests.swift

@@ -12,12 +12,15 @@
 //
 //===----------------------------------------------------------------------===//
 
+import Foundation
 import Instrumentation
 import ServiceContextModule
-import XCTest
+import Testing
 
-final class InstrumentTests: XCTestCase {
-    func testMultiplexInvokesAllInstruments() {
+@Suite("MultiplexInstrument")
+struct InstrumentTests {
+    @Test("MultiplexInstrument invokes all instruments")
+    func multiplexInvokesAllInstruments() {
         let instrument = MultiplexInstrument([
             FirstFakeTracer(),
             SecondFakeTracer(),
@@ -26,15 +29,14 @@ final class InstrumentTests: XCTestCase {
         var context = ServiceContext.topLevel
         instrument.extract([String: String](), into: &context, using: DictionaryExtractor())
 
-        XCTAssertEqual(context[FirstFakeTracer.TraceIDKey.self], FirstFakeTracer.defaultTraceID)
-        XCTAssertEqual(context[SecondFakeTracer.TraceIDKey.self], SecondFakeTracer.defaultTraceID)
+        #expect(context[FirstFakeTracer.TraceIDKey.self] == FirstFakeTracer.defaultTraceID)
+        #expect(context[SecondFakeTracer.TraceIDKey.self] == SecondFakeTracer.defaultTraceID)
 
         var subsequentRequestHeaders = ["Accept": "application/json"]
         instrument.inject(context, into: &subsequentRequestHeaders, using: DictionaryInjector())
 
-        XCTAssertEqual(
-            subsequentRequestHeaders,
-            [
+        #expect(
+            subsequentRequestHeaders == [
                 "Accept": "application/json",
                 FirstFakeTracer.headerName: FirstFakeTracer.defaultTraceID,
                 SecondFakeTracer.headerName: SecondFakeTracer.defaultTraceID,

Tests/TracingTests/ActorTracingTests.swift

@@ -13,14 +13,19 @@
 //===----------------------------------------------------------------------===//
 
 import ServiceContextModule
+import Testing
 import Tracing
-import XCTest
 
 @testable import Instrumentation
 
 /// This is a compile-time test
-final class ActorTracingTests: XCTestCase {
-    func test() {}
+@Suite("Actor Tracing Compatibility")
+struct ActorTracingTests {
+    @Test("Compiles with actor isolation")
+    func compilesWithActorIsolation() {
+        // This test exists purely to verify that the code compiles
+        // with Swift's strict concurrency checking
+    }
 }
 
 func work() async {}

Tests/TracingTests/DynamicTracepointTracerTests.swift

@@ -12,14 +12,17 @@
 //
 //===----------------------------------------------------------------------===//
 
+import Foundation
 import ServiceContextModule
+import Testing
 import Tracing
-import XCTest
 
 @testable import Instrumentation
 
-final class DynamicTracepointTracerTests: XCTestCase {
-    func test_adhoc_enableBySourceLoc() {
+@Suite("Dynamic Tracepoint Tracer Tests")
+struct DynamicTracepointTracerTests {
+    @Test("Ad-hoc tracepoint enable by source location")
+    func adhoc_enableBySourceLoc() {
         let tracer = DynamicTracepointTestTracer()
 
         let fileID = #fileID
@@ -49,16 +52,17 @@ final class DynamicTracepointTracerTests: XCTestCase {
             }
         }
 
-        XCTAssertEqual(tracer.spans.count, 4)
+        #expect(tracer.spans.count == 4)
 
         for span in tracer.spans {
-            XCTAssertEqual(span.context.traceID, "trace-id-fake-\(fileID)-\(fakeLine)")
+            #expect(span.context.traceID == "trace-id-fake-\(fileID)-\(fakeLine)")
         }
-        XCTAssertEqual(tracer.spans[0].context.spanID, "span-id-fake-\(fileID)-\(fakeLine)")
-        XCTAssertEqual(tracer.spans[1].context.spanID, "span-id-fake-\(fileID)-\(fakeNextLine)")
+        #expect(tracer.spans[0].context.spanID == "span-id-fake-\(fileID)-\(fakeLine)")
+        #expect(tracer.spans[1].context.spanID == "span-id-fake-\(fileID)-\(fakeNextLine)")
     }
 
-    func test_adhoc_enableByFunction() {
+    @Test("Ad-hoc tracepoint enable by function")
+    func adhoc_enableByFunction() {
         let tracer = DynamicTracepointTestTracer()
 
         let fileID = #fileID
@@ -70,12 +74,12 @@ final class DynamicTracepointTracerTests: XCTestCase {
         self.logic(fakeLine: 55, tracer: tracer)
         self.traceMeLogic(fakeLine: fakeLine, tracer: tracer)
 
-        XCTAssertEqual(tracer.spans.count, 2)
+        #expect(tracer.spans.count == 2)
         for span in tracer.spans {
-            XCTAssertEqual(span.context.traceID, "trace-id-fake-\(fileID)-\(fakeLine)")
+            #expect(span.context.traceID == "trace-id-fake-\(fileID)-\(fakeLine)")
         }
-        XCTAssertEqual(tracer.spans[0].context.spanID, "span-id-fake-\(fileID)-\(fakeLine)")
-        XCTAssertEqual(tracer.spans[1].context.spanID, "span-id-fake-\(fileID)-\(fakeNextLine)")
+        #expect(tracer.spans[0].context.spanID == "span-id-fake-\(fileID)-\(fakeLine)")
+        #expect(tracer.spans[1].context.spanID == "span-id-fake-\(fileID)-\(fakeNextLine)")
     }
 
     func logic(fakeLine: UInt, tracer: any Tracer) {