Migrate some tests to swift-testing

Some are more difficult and/or not really possible due to, for instance, swift-syntax not having done the utilities for them (see <swiftlang/swift-syntax#2720>).

Author: Frizlab

Tests/GlobalConfTests/DocTests.swift

@@ -1,30 +1,33 @@
 import Foundation
-import XCTest
+import Testing
 
 /* No @testable import: we mostly test whether the architecture works; we must be as close as possible to a regular client’s use. */
 import GlobalConfModule
 
 
 
 /* We mostly just check the examples in the Readme compile. */
-final class DocTests : XCTestCase {
+struct DocTests {
 
+	@Test
 	func testDependencyInjectionUsage() {
 		Conf.setRootValue(DefaultDocService(), for: \.docService)
 		docService.doAmazingStuff()
-		XCTAssertTrue(true)
+		#expect(true)
 	}
 
 	@InjectedConf(\.docService)
 	var docService: DocService
 
+	@Test
 	func testConfUsage() {
-		XCTAssertEqual(Conf[\.docConf], 42)
-		XCTAssertEqual(Conf.docConf, 42)
+		#expect(Conf[\.docConf] == 42)
+		#expect(Conf.docConf == 42)
 	}
 
+	@Test
 	func testAutoInjectedUsage() {
-		XCTAssertNotNil(docAutoInjectedService)
+		#expect(docAutoInjectedService != nil)
 	}
 
 	@InjectedConf()

Tests/GlobalConfTests/UsageMainActorTests.swift

@@ -1,54 +1,55 @@
 import Foundation
-import XCTest
+import Testing
 
 /* No @testable import: we mostly test whether the architecture works; we must be as close as possible to a regular client’s use. */
 import GlobalConfModule
 
 
 
-final class UsageMainActorTests : XCTestCase {
+struct UsageMainActorTests {
 
+	@Test
 	@MainActor
 	func testUsingMainActorService() {
 		MainActor.preconditionIsolated()
 		let c = MainActorContainer()
 		c.mainActorService.printHello()
 		c.mainActorServiceFromKeyPath.printHello()
 		InjectedConf<MainActorService>.value.printHello()
-		XCTAssertTrue(c.mainActorService === Conf[\.mainActorService])
-		XCTAssertTrue(c.mainActorService === Conf[key: MainActorService.AutoInjectionKey.self])
-		XCTAssertTrue(c.mainActorService === Conf.rootValue(for: MainActorService.AutoInjectionKey.self))
-		XCTAssertTrue(c.mainActorService === InjectedConf<MainActorService>.value)
-		XCTAssertTrue(c.mainActorServiceFromKeyPath === InjectedConf<MainActorService>.value)
+		#expect(c.mainActorService === Conf[\.mainActorService])
+		#expect(c.mainActorService === Conf[key: MainActorService.AutoInjectionKey.self])
+		#expect(c.mainActorService === Conf.rootValue(for: MainActorService.AutoInjectionKey.self))
+		#expect(c.mainActorService === InjectedConf<MainActorService>.value)
+		#expect(c.mainActorServiceFromKeyPath === InjectedConf<MainActorService>.value)
 
-		XCTAssertTrue(c.otherMainActorService !== InjectedConf<MainActorService>.value)
+		#expect(c.otherMainActorService !== InjectedConf<MainActorService>.value)
 
 		let oldOtherActor = c.otherMainActorService
 		Conf.setRootValue(c.mainActorService, for: \.mainActorService2)
-		XCTAssertTrue(c.otherMainActorService === InjectedConf<MainActorService>.value)
+		#expect(c.otherMainActorService === InjectedConf<MainActorService>.value)
 
 		Conf.withValue(oldOtherActor, for: \.mainActorService2, operation: {
-			XCTAssertTrue(c.mainActorService === Conf[\.mainActorService])
-			XCTAssertTrue(c.otherMainActorService === oldOtherActor)
-			XCTAssertTrue(c.otherMainActorService !== InjectedConf<MainActorService>.value)
+			#expect(c.mainActorService === Conf[\.mainActorService])
+			#expect(c.otherMainActorService === oldOtherActor)
+			#expect(c.otherMainActorService !== InjectedConf<MainActorService>.value)
 		})
 
 		Conf.withValues{
 			$0[\.mainActorService2] = MainActorService()
 		}operation:{
-			XCTAssertTrue(c.otherMainActorService !== oldOtherActor)
-			XCTAssertTrue(c.otherMainActorService !== InjectedConf<MainActorService>.value)
+			#expect(c.otherMainActorService !== oldOtherActor)
+			#expect(c.otherMainActorService !== InjectedConf<MainActorService>.value)
 		}
 
 		InjectedConf<MainActorService>.withValue(MainActorService()){
-			XCTAssertTrue(c.otherMainActorService !== oldOtherActor)
-			XCTAssertTrue(c.otherMainActorService !== InjectedConf<MainActorService>.value)
+			#expect(c.otherMainActorService !== oldOtherActor)
+			#expect(c.otherMainActorService !== InjectedConf<MainActorService>.value)
 		}
 
-		XCTAssertTrue(c.otherMainActorService === InjectedConf<MainActorService>.value)
+		#expect(c.otherMainActorService === InjectedConf<MainActorService>.value)
 
 		InjectedConf<MainActorService>.rootValue = oldOtherActor
-		XCTAssertTrue(c.otherMainActorService !== c.mainActorService)
+		#expect(c.otherMainActorService !== c.mainActorService)
 	}
 
 	@MainActor

Tests/GlobalConfTests/UsageTests.swift

@@ -1,24 +1,26 @@
 import Foundation
-import XCTest
+import Testing
 
 /* No @testable import: we mostly test whether the architecture works; we must be as close as possible to a regular client’s use. */
 import GlobalConfModule
 
 
 
-final class UsageTests : XCTestCase {
+struct UsageTests {
 
+	@Test
 	func testUsingNoActorService() {
 		noActorService.printHello()
 		noActorServiceFromKeyPath.printHello()
 		InjectedConf<NoActorService>.value.printHello()
-		XCTAssertTrue(noActorService === InjectedConf<NoActorService>.value)
-		XCTAssertTrue(noActorServiceFromKeyPath === InjectedConf<NoActorService>.value)
+		#expect(noActorService === InjectedConf<NoActorService>.value)
+		#expect(noActorServiceFromKeyPath === InjectedConf<NoActorService>.value)
 	}
 
+	@Test
 	func testUsingNoActorServiceWithFactory() {
-		XCTAssertTrue(noActorService === noActorService)
-		XCTAssertTrue(noActorFactoryService !== noActorFactoryService)
+		#expect(noActorService === noActorService)
+		#expect(noActorFactoryService !== noActorFactoryService)
 	}
 
 	@InjectedConf()