Tests: Migrate to Swift Testing and augment suites (#8988)

To aid with the Swift Build integration, migrate a few test suites to
Swift Testing and augment the tests to build against the SwiftBuild
build system in addition to the various build configuration.

Depends on: #8975 
Relates to #8997

Author: bkhouri

Sources/_InternalTestSupport/SwiftTesting+Helpers.swift

@@ -0,0 +1,57 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright (c) 2025 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+ */
+
+import Basics
+import Testing
+
+public func expectFileExists(
+    at path: AbsolutePath,
+    sourceLocation: SourceLocation = #_sourceLocation,
+) {
+
+    #expect(
+        localFileSystem.exists(path),
+        "Files '\(path)' does not exist.",
+        sourceLocation: sourceLocation,
+    )
+}
+
+
+public func expectThrowsCommandExecutionError<T>(
+    _ expression: @autoclosure () async throws -> T,
+    _ message: @autoclosure () -> Comment = "",
+    sourceLocation: SourceLocation = #_sourceLocation,
+    _ errorHandler: (_ error: CommandExecutionError) -> Void = { _ in }
+) async {
+    await expectAsyncThrowsError(try await expression(), message(), sourceLocation: sourceLocation) { error in
+        guard case SwiftPMError.executionFailure(let processError, let stdout, let stderr) = error,
+              case AsyncProcessResult.Error.nonZeroExit(let processResult) = processError,
+              processResult.exitStatus != .terminated(code: 0) else {
+            Issue.record("Unexpected error type: \(error.interpolationDescription)", sourceLocation: sourceLocation)
+            return
+        }
+        errorHandler(CommandExecutionError(result: processResult, stdout: stdout, stderr: stderr))
+    }
+}
+
+/// An `async`-friendly replacement for `XCTAssertThrowsError`.
+public func expectAsyncThrowsError<T>(
+    _ expression: @autoclosure () async throws -> T,
+    _ message: @autoclosure () -> Comment = "",
+    sourceLocation: SourceLocation = #_sourceLocation,
+    _ errorHandler: (_ error: any Error) -> Void = { _ in }
+) async {
+    do {
+        _ = try await expression()
+        Issue.record(message(), sourceLocation: sourceLocation)
+    } catch {
+        errorHandler(error)
+    }
+}

Sources/_InternalTestSupport/SwiftTesting+Tags.swift

@@ -44,6 +44,8 @@ extension Tag.Feature.Command.Package {
     @Tag public static var DumpPackage: Tag
     @Tag public static var DumpSymbolGraph: Tag
     @Tag public static var Plugin: Tag
+    @Tag public static var Reset: Tag
+    @Tag public static var ToolsVersion: Tag
 }
 
 extension Tag.Feature.PackageType {

Sources/_InternalTestSupport/SwiftTesting+TraitConditional.swift

@@ -12,6 +12,7 @@
 import class Foundation.FileManager
 import class Foundation.ProcessInfo
 import class PackageModel.UserToolchain
+import DriverSupport
 import Basics
 import Testing
 
@@ -37,6 +38,35 @@ extension Trait where Self == Testing.ConditionTrait {
         }
     }
 
+    /// Enaled only if marcros are built as dylibs
+    public static var requiresBuildingMacrosAsDylibs: Self {
+        enabled("test is only supported if `BUILD_MACROS_AS_DYLIBS` is set") {
+            #if BUILD_MACROS_AS_DYLIBS
+                true
+            #else
+                false
+            #endif
+        }
+    }
+
+    /// Check for required compiler support
+    public static func requiresFrontEndFlags(flags: Set<String>) -> Self {
+        enabled("test requires \(flags.joined(separator: ", "))") {
+            try DriverSupport.checkSupportedFrontendFlags(flags: flags, toolchain: UserToolchain.default, fileSystem: localFileSystem)
+        }
+    }
+
+    private static func requiresHostLibrary(lib: String) -> Self {
+        enabled("test requires `\(lib)` to exist in the host toolchain") {
+            let libSwiftSyntaxMacrosPath = try UserToolchain.default.hostLibDir.appending("libSwiftSyntaxMacros.dylib")
+            return localFileSystem.exists(libSwiftSyntaxMacrosPath)
+        }
+    }
+
+    public static var requiresSwiftTestingMacros: Self {
+        requiresHostLibrary(lib: "libSwiftSyntaxMacros.dylib")
+    }
+
     /// Skip test unconditionally
     public static func skip(_ comment: Comment? = nil) -> Self {
         disabled(comment ?? "Unconditional skip, a comment should be added for the reason") { true }

Tests/FunctionalTests/MacroTests.swift

@@ -2,40 +2,49 @@
 //
 // This source file is part of the Swift open source project
 //
-// Copyright (c) 2023 Apple Inc. and the Swift project authors
+// Copyright (c) 2023-2025 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See http://swift.org/LICENSE.txt for license information
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
+import Foundation
+
+import struct SPMBuildCore.BuildSystemProvider
 
 import DriverSupport
 import _InternalTestSupport
 import PackageModel
-import XCTest
-
-class MacroTests: XCTestCase {
-    func testMacrosBasic() throws {
-        #if BUILD_MACROS_AS_DYLIBS
-        // Check for required compiler support.
-        try XCTSkipIf(!DriverSupport.checkSupportedFrontendFlags(flags: ["load-plugin-library"], toolchain: UserToolchain.default, fileSystem: localFileSystem), "test needs `-load-plugin-library`")
-
-        // Check for presence of `libSwiftSyntaxMacros`.
-        let libSwiftSyntaxMacrosPath = try UserToolchain.default.hostLibDir.appending("libSwiftSyntaxMacros.dylib")
-        try XCTSkipIf(!localFileSystem.exists(libSwiftSyntaxMacrosPath), "test need `libSwiftSyntaxMacros` to exist in the host toolchain")
+import Testing
 
-        try fixtureXCTest(name: "Macros") { fixturePath in
-            let (stdout, _) = try executeSwiftBuild(
+@Suite(
+    .tags(
+        Tag.TestSize.large
+    ),
+)
+struct MacroTests {
+    @Test(
+        .requiresBuildingMacrosAsDylibs,
+        .requiresFrontEndFlags(flags: ["load-plugin-library"]),
+        .requiresSwiftTestingMacros,
+        .tags(
+            Tag.Feature.Command.Build
+        ),
+        arguments: SupportedBuildSystemOnAllPlatforms, BuildConfiguration.allCases,
+    )
+    func macrosBasic(
+        buildSystem: BuildSystemProvider.Kind,
+        configuration: BuildConfiguration,
+    ) async throws {
+        try await fixture(name: "Macros") { fixturePath in
+            let (stdout, _) = try await executeSwiftBuild(
                 fixturePath.appending("MacroPackage"),
-                configuration: .debug,
-                buildSystem: .native,
+                configuration: configuration,
+                buildSystem: buildSystem,
             )
-            XCTAssert(stdout.contains("@__swiftmacro_11MacroClient11fontLiteralfMf_.swift as Font"), "stdout:\n\(stdout)")
-            XCTAssert(stdout.contains("Build complete!"), "stdout:\n\(stdout)")
+            #expect(stdout.contains("@__swiftmacro_11MacroClient11fontLiteralfMf_.swift as Font"), "stdout:\n\(stdout)")
+            #expect(stdout.contains("Build complete!"), "stdout:\n\(stdout)")
         }
-        #else
-        try XCTSkipIf(true, "test is only supported if `BUILD_MACROS_AS_DYLIBS`")
-        #endif
     }
 }