Cleanup testing assertions and canImport(TestingDisabled)

Author: plemarquand

Sources/_InternalTestSupport/BuildSystemProvider+Supported.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import Testing
 import struct SPMBuildCore.BuildSystemProvider
 import enum PackageModel.BuildConfiguration
 
@@ -28,6 +29,12 @@ public struct BuildData {
     public let config: BuildConfiguration
 }
 
+extension BuildData: CustomTestStringConvertible {
+    public var testDescription: String {
+        return "\(buildSystem):\(config)"
+    }
+}
+
 public func getBuildData(for buildSystems: [BuildSystemProvider.Kind]) -> [BuildData] {
     buildSystems.flatMap { buildSystem in
         BuildConfiguration.allCases.compactMap { config in

Sources/_InternalTestSupport/SwiftTesting+Helpers.swift

@@ -61,7 +61,7 @@ public func requireFileExists(
 ///   - path: The absolute path to check for file non-existence.
 ///   - comment: An optional comment to include in the failure message.
 ///   - sourceLocation: The source location where the expectation is made.
-public func expectFileDoesNotExists(
+public func expectFileDoesNotExist(
     at path: AbsolutePath,
     _ comment: Comment? = nil,
     sourceLocation: SourceLocation = #_sourceLocation,

Tests/CommandsTests/PackageCommandTests.swift

@@ -2866,7 +2866,7 @@ struct PackageCommandTests {
                 configuration: data.config,
                 buildSystem: data.buildSystem,
             )
-            expectFileDoesNotExists(at: binFile)
+            expectFileDoesNotExist(at: binFile)
             // Clean again to ensure we get no error.
             _ = try await execute(
                 ["clean"],
@@ -2911,7 +2911,7 @@ struct PackageCommandTests {
                 configuration: data.config,
                 buildSystem: data.buildSystem,
             )
-            expectFileDoesNotExists(at: binFile)
+            expectFileDoesNotExist(at: binFile)
             try #expect(
                 !localFileSystem.getDirectoryContents(buildPath.appending("repositories")).isEmpty
             )
@@ -3014,7 +3014,7 @@ struct PackageCommandTests {
                 #expect(!result.stderr.contains("Could not find Package.swift"))
 
                 // Verify manifest.db was removed (the purge implementation removes this file)
-                expectFileDoesNotExists(at: manifestDB, "manifest.db should be removed after purge")
+                expectFileDoesNotExist(at: manifestDB, "manifest.db should be removed after purge")
 
                 // Note: SQLite auxiliary files (WAL/SHM) may or may not be removed depending on SQLite state
                 // The important check is that the main database file is removed
@@ -5341,7 +5341,7 @@ struct PackageCommandTests {
                         buildSystem: buildData.buildSystem,
                     )
                     expectFileIsExecutable(at: fixturePath.appending(components: debugTarget), "build-target")
-                    expectFileDoesNotExists(
+                    expectFileDoesNotExist(
                         at: fixturePath.appending(components: releaseTarget),
                         "build-target build-inherit"
                     )
@@ -5375,7 +5375,7 @@ struct PackageCommandTests {
                         at: fixturePath.appending(components: debugTarget),
                         "build-target build-debug"
                     )
-                    expectFileDoesNotExists(
+                    expectFileDoesNotExist(
                         at: fixturePath.appending(components: releaseTarget),
                         "build-target build-inherit"
                     )
@@ -5406,7 +5406,7 @@ struct PackageCommandTests {
                         configuration: buildData.config,
                         buildSystem: buildData.buildSystem,
                     )
-                    expectFileDoesNotExists(
+                    expectFileDoesNotExist(
                         at: fixturePath.appending(components: debugTarget),
                         "build-target build-inherit"
                     )
@@ -5450,7 +5450,7 @@ struct PackageCommandTests {
                         fileShouldNotExist = fixturePath.appending(components: debugTarget)
                         fileShouldExist = fixturePath.appending(components: releaseTarget)
                     }
-                    expectFileDoesNotExists(at: fileShouldNotExist, "build-target build-inherit")
+                    expectFileDoesNotExist(at: fileShouldNotExist, "build-target build-inherit")
                     expectFileIsExecutable(at: fileShouldExist, "build-target build-inherit")
                 }
             } when: {

Tests/WorkspaceTests/InitTests.swift

@@ -104,13 +104,13 @@ struct InitTests {
                 #expect(manifestContents.contains(".testTarget("))
             }
 
-            try customVerification?(path, packageName)
-
             if let buildSystem = buildSystem {
                 await expectBuilds(path, buildSystem: buildSystem, configurations: Set([buildConfiguration]))
 
                 try verifyBuildProducts(for: packageType, at: path, name: packageName, buildSystem: buildSystem, buildConfiguration: buildConfiguration)
             }
+
+            try customVerification?(path, packageName)
         }
     }
 
@@ -152,28 +152,11 @@ struct InitTests {
         if hasSwiftTesting {
             #expect(testFileContents.contains(#"import Testing"#))
             #expect(testFileContents.contains(#"@Test func"#))
-        } else {
-            #expect(!testFileContents.contains(#"import Testing"#))
-            #expect(!testFileContents.contains(#"@Test func"#))
         }
 
         if hasXCTest {
             #expect(testFileContents.contains(#"import XCTest"#))
             #expect(testFileContents.contains("func test"))
-
-            if hasSwiftTesting {
-                // When both are present, ensure XCTest content is properly formatted
-                #expect(testFileContents.contains("import XCTest"), "XCTest import should be present")
-            } else {
-                // When only XCTest is present, ensure it's at the beginning of the file
-                #expect(testFileContents.hasPrefix("import XCTest"), """
-                    Validates formatting of XCTest source file, in particular that it does not contain leading whitespace:
-                    \(testFileContents)
-                    """)
-            }
-        } else {
-            #expect(!testFileContents.contains(#"import XCTest"#))
-            #expect(!testFileContents.contains("func test"))
         }
     }
 
@@ -274,7 +257,7 @@ struct InitTests {
         try await createAndVerifyPackage(
             packageType: packageType,
             supportedTestingLibraries: [.xctest],
-            buildSystem: buildSystemRespectingTestingDisabled(data.buildSystem),
+            buildSystem: data.buildSystem,
             buildConfiguration: data.config,
             customVerification: { path, name in
                 #expect(
@@ -299,21 +282,17 @@ struct InitTests {
         try await createAndVerifyPackage(
             packageType: packageType,
             supportedTestingLibraries: [.swiftTesting],
-            buildSystem: buildSystemRespectingTestingDisabled(data.buildSystem),
+            buildSystem: data.buildSystem,
             buildConfiguration: data.config,
             customVerification: { path, name in
                 try verifyTestFileContents(at: path, name: name, hasSwiftTesting: true, hasXCTest: false)
+                let binPath = try data.buildSystem.binPath(for: data.config, triple: Self.targetTriple.platformBuildPathComponent)
+                let swiftModule = "\(name).swiftmodule"
+                let expectedPath = path
+                    .appending(components: binPath)
+                    .appending(components: data.buildSystem == .native ? ["Modules", swiftModule] : [swiftModule])
 
-                #if canImport(TestingDisabled)
-                let expectedPath = path.appending(components: 
-                    ".build", 
-                    Self.targetTriple.platformBuildPathComponent, 
-                    "debug", 
-                    "Modules", 
-                    "\(name).swiftmodule"
-                )
-                try requireFileExists(at: expectedPath)
-                #endif
+                expectFileExists(at: expectedPath)
             }
         )
     }
@@ -324,21 +303,17 @@ struct InitTests {
         try await createAndVerifyPackage(
             packageType: packageType,
             supportedTestingLibraries: [.swiftTesting, .xctest],
-            buildSystem: buildSystemRespectingTestingDisabled(data.buildSystem),
+            buildSystem: data.buildSystem,
             buildConfiguration: data.config,
             customVerification: { path, name in
                 try verifyTestFileContents(at: path, name: name, hasSwiftTesting: true, hasXCTest: true)
+                let binPath = try data.buildSystem.binPath(for: data.config, triple: Self.targetTriple.platformBuildPathComponent)
+                let swiftModule = "\(name).swiftmodule"
+                let expectedPath = path
+                    .appending(components: binPath)
+                    .appending(components: data.buildSystem == .native ? ["Modules", swiftModule] : [swiftModule])
 
-                #if canImport(TestingDisabled)
-                let expectedPath = path.appending(components: 
-                    ".build",
-                    Self.targetTriple.platformBuildPathComponent,
-                    "debug",
-                    "Modules",
-                    "\(name).swiftmodule"
-                )
                 expectFileExists(at: expectedPath)
-                #endif
             }
         )
     }
@@ -349,24 +324,21 @@ struct InitTests {
         try await createAndVerifyPackage(
             packageType: packageType,
             supportedTestingLibraries: [],
-            buildSystem: buildSystemRespectingTestingDisabled(data.buildSystem),
+            buildSystem: data.buildSystem,
             buildConfiguration: data.config,
             customVerification: { path, name in
                 let manifestContents: String = try localFileSystem.readFileContents(path.appending("Package.swift"))
                 #expect(!manifestContents.contains(#".testTarget"#))
 
                 expectDirectoryDoesNotExist(at: path.appending("Tests"))
 
-                #if canImport(TestingDisabled)
-                let expectedPath = path.appending(components: 
-                    ".build",
-                    Self.targetTriple.platformBuildPathComponent,
-                    "debug",
-                    "Modules",
-                    "\(name).swiftmodule"
-                )
+                let binPath = try data.buildSystem.binPath(for: data.config, triple: Self.targetTriple.platformBuildPathComponent)
+                let swiftModule = "\(name).swiftmodule"
+                let expectedPath = path
+                    .appending(components: binPath)
+                    .appending(components: data.buildSystem == .native ? ["Modules", swiftModule] : [swiftModule])
+
                 expectFileExists(at: expectedPath)
-                #endif
             }
         )
     }
@@ -434,7 +406,7 @@ struct InitTests {
     }
 
     /// Tests creating a package with a non-C99 compliant name.
-    @Test(arguments: [BuildSystemProvider.Kind.native, .swiftbuild])
+    @Test(arguments: BuildSystemProvider.Kind.allCases)
     func nonC99NameExecutablePackage(buildSystem: BuildSystemProvider.Kind) async throws {
         try await withTemporaryDirectory(removeTreeOnDeinit: true) { tempDirPath in
             let packageRoot = tempDirPath.appending("Foo")
@@ -486,7 +458,8 @@ struct InitTests {
         }
     }
 
-    @Test func includesSwiftLanguageMode() throws {
+    @Test(arguments: [InitPackage.PackageType.library, .executable, .tool])
+    func includesSwiftLanguageMode(packageType: InitPackage.PackageType) throws {
         try testWithTemporaryDirectory { tmpPath in
             let fs = localFileSystem
             let path = tmpPath.appending("testInitPackageIncludesSwiftLanguageMode")
@@ -496,7 +469,7 @@ struct InitTests {
             // Create a library package
             let initPackage = try InitPackage(
                 name: name,
-                packageType: .library,
+                packageType: packageType,
                 supportedTestingLibraries: [],
                 destinationPath: path,
                 installedSwiftPMConfiguration: .default,
@@ -538,14 +511,4 @@ let package = Package(
 )
 """
     }
-
-    /// Returns the build system to use, respecting whether TestingDisabled is imported.
-    func buildSystemRespectingTestingDisabled(_ buildSystem: BuildSystemProvider.Kind?) -> BuildSystemProvider.Kind? {
-        #if canImport(TestingDisabled)
-            return buildSystem
-        #else
-            return nil
-        #endif
-    }
-
 }