blob: 10fdc8cfb967d06deef80376779d4ebe1c246847 [file] [log] [blame]
/*
This source file is part of the Swift.org open source project
Copyright (c) 2014 - 2017 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 XCTest
import XCTest
import Basic
import PackageDescription4
import PackageModel
import Utility
@testable import PackageLoading
fileprivate typealias Package = PackageDescription4.Package
class PackageBuilderV4Tests: XCTestCase {
func testDeclaredExecutableProducts() {
// Check that declaring executable product doesn't collide with the
// inferred products.
let fs = InMemoryFileSystem(emptyFiles:
"/Sources/exec/main.swift",
"/Sources/foo/foo.swift"
)
let package = Package(
name: "pkg",
products: [
.executable(name: "exec", targets: ["exec", "foo"]),
],
targets: [
.target(name: "foo"),
.target(name: "exec"),
]
)
PackageBuilderTester(package, in: fs) { result in
result.checkModule("foo") { _ in }
result.checkModule("exec") { _ in }
result.checkProduct("exec") { productResult in
productResult.check(type: .executable, targets: ["exec", "foo"])
}
}
package.products = []
PackageBuilderTester(package, in: fs) { result in
result.checkModule("foo") { _ in }
result.checkModule("exec") { _ in }
result.checkProduct("exec") { productResult in
productResult.check(type: .executable, targets: ["exec"])
}
}
// If we already have an explicit product, we shouldn't create an
// implicit one.
package.products = [
.executable(name: "exec1", targets: ["exec"]),
]
PackageBuilderTester(package, in: fs) { result in
result.checkModule("foo") { _ in }
result.checkModule("exec") { _ in }
result.checkProduct("exec1") { productResult in
productResult.check(type: .executable, targets: ["exec"])
}
}
}
func testLinuxMain() {
let fs = InMemoryFileSystem(emptyFiles:
"/swift/exe/foo.swift",
"/LinuxMain.swift",
"/swift/tests/footests.swift"
)
let package = Package(
name: "pkg",
targets: [
.target(
name: "exe",
path: "swift/exe"
),
.testTarget(
name: "tests",
path: "swift/tests"
),
]
)
PackageBuilderTester(package, in: fs) { result in
result.checkModule("exe") { moduleResult in
moduleResult.check(c99name: "exe", type: .library)
moduleResult.checkSources(root: "/swift/exe", paths: "foo.swift")
}
result.checkModule("tests") { moduleResult in
moduleResult.check(c99name: "tests", type: .test)
moduleResult.checkSources(root: "/swift/tests", paths: "footests.swift")
}
result.checkProduct("pkgPackageTests") { productResult in
productResult.check(type: .test, targets: ["tests"])
productResult.check(linuxMainPath: "/LinuxMain.swift")
}
}
}
func testLinuxMainError() {
let fs = InMemoryFileSystem(emptyFiles:
"/LinuxMain.swift",
"/swift/LinuxMain.swift",
"/swift/tests/footests.swift"
)
let package = Package(
name: "pkg",
targets: [
.testTarget(
name: "tests",
path: "swift/tests"
),
]
)
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("package 'pkg' has multiple linux main files: /LinuxMain.swift, /swift/LinuxMain.swift")
}
}
func testCustomTargetPaths() {
let fs = InMemoryFileSystem(emptyFiles:
"/mah/target/exe/swift/exe/main.swift",
"/mah/target/exe/swift/exe/foo.swift",
"/mah/target/exe/swift/bar.swift",
"/mah/target/exe/shouldBeIgnored.swift",
"/mah/target/exe/foo.c",
"/Sources/foo/foo.swift",
"/bar/bar/foo.swift",
"/bar/bar/excluded.swift",
"/bar/bar/fixture/fix1.swift",
"/bar/bar/fixture/fix2.swift"
)
let package = Package(
name: "pkg",
targets: [
.target(
name: "exe",
path: "mah/target/exe",
sources: ["swift"]),
.target(
name: "clib",
path: "mah/target/exe",
sources: ["foo.c"]),
.target(
name: "foo"),
.target(
name: "bar",
path: "bar",
exclude: ["bar/excluded.swift", "bar/fixture"],
sources: ["bar"]),
]
)
PackageBuilderTester(package, in: fs) { result in
result.checkPredefinedPaths(target: "/Sources", testTarget: "/Tests")
result.checkModule("exe") { moduleResult in
moduleResult.check(c99name: "exe", type: .executable)
moduleResult.checkSources(root: "/mah/target/exe",
paths: "swift/exe/main.swift", "swift/exe/foo.swift", "swift/bar.swift")
}
result.checkModule("clib") { moduleResult in
moduleResult.check(c99name: "clib", type: .library)
moduleResult.checkSources(root: "/mah/target/exe", paths: "foo.c")
}
result.checkModule("foo") { moduleResult in
moduleResult.check(c99name: "foo", type: .library)
moduleResult.checkSources(root: "/Sources/foo", paths: "foo.swift")
}
result.checkModule("bar") { moduleResult in
moduleResult.check(c99name: "bar", type: .library)
moduleResult.checkSources(root: "/bar", paths: "bar/foo.swift")
}
result.checkProduct("exe") { _ in }
}
}
func testCustomTargetPathsOverlap() {
let fs = InMemoryFileSystem(emptyFiles:
"/target/bar/bar.swift",
"/target/bar/Tests/barTests.swift"
)
let package = Package(
name: "pkg",
targets: [
.target(
name: "bar",
path: "target/bar"),
.testTarget(
name: "barTests",
path: "target/bar/Tests"),
]
)
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("target 'barTests' has sources overlapping sources: /target/bar/Tests/barTests.swift")
}
package.targets[0].exclude = ["Tests"]
PackageBuilderTester(package, in: fs) { result in
result.checkPredefinedPaths(target: "/Sources", testTarget: "/Tests")
result.checkModule("bar") { moduleResult in
moduleResult.check(c99name: "bar", type: .library)
moduleResult.checkSources(root: "/target/bar", paths: "bar.swift")
}
result.checkModule("barTests") { moduleResult in
moduleResult.check(c99name: "barTests", type: .test)
moduleResult.checkSources(root: "/target/bar/Tests", paths: "barTests.swift")
}
result.checkProduct("pkgPackageTests")
}
}
func testPublicHeadersPath() throws {
let fs = InMemoryFileSystem(emptyFiles:
"/Sources/Foo/inc/module.modulemap",
"/Sources/Foo/inc/Foo.h",
"/Sources/Foo/Foo.c",
"/Sources/Bar/include/module.modulemap",
"/Sources/Bar/include/Bar.h",
"/Sources/Bar/Bar.c"
)
let package = Package(
name: "Foo",
targets: [
.target(name: "Foo", publicHeadersPath: "inc"),
.target(name: "Bar"),
])
PackageBuilderTester(package, in: fs) { result in
result.checkPredefinedPaths(target: "/Sources", testTarget: "/Tests")
result.checkModule("Foo") { moduleResult in
moduleResult.check(c99name: "Foo", type: .library)
moduleResult.checkSources(root: "/Sources/Foo", paths: "Foo.c")
moduleResult.check(includeDir: "/Sources/Foo/inc")
}
result.checkModule("Bar") { moduleResult in
moduleResult.check(c99name: "Bar", type: .library)
moduleResult.checkSources(root: "/Sources/Bar", paths: "Bar.c")
moduleResult.check(includeDir: "/Sources/Bar/include")
}
}
}
func testTestsLayoutsv4() throws {
let fs = InMemoryFileSystem(emptyFiles:
"/Sources/A/main.swift",
"/Tests/B/Foo.swift",
"/Tests/ATests/Foo.swift",
"/Tests/TheTestOfA/Foo.swift")
let package = Package(
name: "Foo",
targets: [
.target(name: "A"),
.testTarget(name: "TheTestOfA", dependencies: ["A"]),
.testTarget(name: "ATests"),
.testTarget(name: "B"),
])
PackageBuilderTester(package, in: fs) { result in
result.checkPredefinedPaths(target: "/Sources", testTarget: "/Tests")
result.checkModule("A") { moduleResult in
moduleResult.check(c99name: "A", type: .executable)
moduleResult.checkSources(root: "/Sources/A", paths: "main.swift")
}
result.checkModule("TheTestOfA") { moduleResult in
moduleResult.check(c99name: "TheTestOfA", type: .test)
moduleResult.checkSources(root: "/Tests/TheTestOfA", paths: "Foo.swift")
moduleResult.check(dependencies: ["A"])
}
result.checkModule("B") { moduleResult in
moduleResult.check(c99name: "B", type: .test)
moduleResult.checkSources(root: "/Tests/B", paths: "Foo.swift")
moduleResult.check(dependencies: [])
}
result.checkModule("ATests") { moduleResult in
moduleResult.check(c99name: "ATests", type: .test)
moduleResult.checkSources(root: "/Tests/ATests", paths: "Foo.swift")
moduleResult.check(dependencies: [])
}
result.checkProduct("FooPackageTests") { _ in }
result.checkProduct("A") { _ in }
}
}
func testMultipleTestProducts() {
let fs = InMemoryFileSystem(emptyFiles:
"/Sources/foo/foo.swift",
"/Tests/fooTests/foo.swift",
"/Tests/barTests/bar.swift"
)
let package = Package(
name: "pkg",
targets: [
.target(name: "foo"),
.testTarget(name: "fooTests"),
.testTarget(name: "barTests"),
]
)
PackageBuilderTester(.v4(package), shouldCreateMultipleTestProducts: true, in: fs) { result in
result.checkModule("foo") { _ in }
result.checkModule("fooTests") { _ in }
result.checkModule("barTests") { _ in }
result.checkProduct("fooTests") { product in
product.check(type: .test, targets: ["fooTests"])
}
result.checkProduct("barTests") { product in
product.check(type: .test, targets: ["barTests"])
}
}
PackageBuilderTester(.v4(package), shouldCreateMultipleTestProducts: false, in: fs) { result in
result.checkModule("foo") { _ in }
result.checkModule("fooTests") { _ in }
result.checkModule("barTests") { _ in }
result.checkProduct("pkgPackageTests") { product in
product.check(type: .test, targets: ["barTests", "fooTests"])
}
}
}
func testCustomTargetDependencies() throws {
let fs = InMemoryFileSystem(emptyFiles:
"/Sources/Foo/Foo.swift",
"/Sources/Bar/Bar.swift",
"/Sources/Baz/Baz.swift")
// Direct.
var package = Package(
name: "pkg",
targets: [
.target(name: "Foo", dependencies: ["Bar"]),
.target(name: "Bar"),
.target(name: "Baz"),
]
)
PackageBuilderTester(package, in: fs) { result in
result.checkModule("Foo") { moduleResult in
moduleResult.check(c99name: "Foo", type: .library)
moduleResult.checkSources(root: "/Sources/Foo", paths: "Foo.swift")
moduleResult.check(dependencies: ["Bar"])
}
for target in ["Bar", "Baz"] {
result.checkModule(target) { moduleResult in
moduleResult.check(c99name: target, type: .library)
moduleResult.checkSources(root: "/Sources/\(target)", paths: "\(target).swift")
}
}
}
// Transitive.
package = Package(
name: "pkg",
targets: [
.target(name: "Foo", dependencies: ["Bar"]),
.target(name: "Bar", dependencies: ["Baz"]),
.target(name: "Baz"),
]
)
PackageBuilderTester(package, in: fs) { result in
result.checkModule("Foo") { moduleResult in
moduleResult.check(c99name: "Foo", type: .library)
moduleResult.checkSources(root: "/Sources/Foo", paths: "Foo.swift")
moduleResult.check(dependencies: ["Bar"])
}
result.checkModule("Bar") { moduleResult in
moduleResult.check(c99name: "Bar", type: .library)
moduleResult.checkSources(root: "/Sources/Bar", paths: "Bar.swift")
moduleResult.check(dependencies: ["Baz"])
}
result.checkModule("Baz") { moduleResult in
moduleResult.check(c99name: "Baz", type: .library)
moduleResult.checkSources(root: "/Sources/Baz", paths: "Baz.swift")
}
}
}
func testDuplicateTargets() throws {
let fs = InMemoryFileSystem(emptyFiles:
"/Sources/A/main.swift",
"/Sources/A/foo.swift",
"/Sources/B/bar.swift",
"/Sources/C/baz.swift"
)
let package = Package(
name: "A",
targets: [
.target(name: "A", dependencies: []),
.target(name: "B", dependencies: []),
.target(name: "A", dependencies: []),
.target(name: "B", dependencies: []),
]
)
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("duplicate targets found: A, B")
}
}
func testTargetDependencies() throws {
let fs = InMemoryFileSystem(emptyFiles:
"/Sources/Foo/Foo.swift",
"/Sources/Bar/Bar.swift",
"/Sources/Baz/Baz.swift")
// We create a manifest which uses byName product dependencies.
let package = Package(
name: "pkg",
targets: [
.target(name: "Bar"),
.target(name: "Baz"),
.target(
name: "Foo",
dependencies: ["Bar", "Baz", "Bam"]
),
])
PackageBuilderTester(package, in: fs) { result in
result.checkPredefinedPaths(target: "/Sources", testTarget: "/Tests")
result.checkModule("Foo") { moduleResult in
moduleResult.check(c99name: "Foo", type: .library)
moduleResult.checkSources(root: "/Sources/Foo", paths: "Foo.swift")
moduleResult.check(dependencies: ["Bar", "Baz"])
moduleResult.check(productDeps: [(name: "Bam", package: nil)])
}
for target in ["Bar", "Baz"] {
result.checkModule(target) { moduleResult in
moduleResult.check(c99name: target, type: .library)
moduleResult.checkSources(root: "/Sources/\(target)", paths: "\(target).swift")
}
}
}
}
func testManifestTargetDeclErrors() throws {
do {
// Reference a target which doesn't exist.
let fs = InMemoryFileSystem(emptyFiles:
"/Foo.swift")
let package = Package(name: "pkg", targets: [.target(name: "Random")])
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("could not find target(s): Random; use the 'path' property in the Swift 4 manifest to set a custom target path")
}
}
do {
let fs = InMemoryFileSystem(emptyFiles:
"/src/pkg/Foo.swift")
// Reference an invalid dependency.
let package = Package(
name: "pkg",
targets: [
.target(name: "pkg", dependencies: [.target(name: "Foo")]),
])
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("could not find target(s): Foo; use the 'path' property in the Swift 4 manifest to set a custom target path")
}
}
do {
let fs = InMemoryFileSystem(emptyFiles:
"/Source/pkg/Foo.swift")
// Reference self in dependencies.
let package = Package(name: "pkg", targets: [.target(name: "pkg", dependencies: ["pkg"])])
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("cyclic dependency declaration found: pkg -> pkg")
}
}
do {
let fs = InMemoryFileSystem(emptyFiles:
"/Source/pkg/Foo.swift")
// Reference invalid target.
let package = Package(name: "pkg", targets: [.target(name: "foo")])
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("could not find target(s): foo; use the 'path' property in the Swift 4 manifest to set a custom target path")
}
}
do {
let fs = InMemoryFileSystem(emptyFiles:
"/Sources/pkg1/Foo.swift",
"/Sources/pkg2/Foo.swift",
"/Sources/pkg3/Foo.swift"
)
// Cyclic dependency.
var package = Package(name: "pkg", targets: [
.target(name: "pkg1", dependencies: ["pkg2"]),
.target(name: "pkg2", dependencies: ["pkg3"]),
.target(name: "pkg3", dependencies: ["pkg1"]),
])
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("cyclic dependency declaration found: pkg1 -> pkg2 -> pkg3 -> pkg1")
}
package = Package(name: "pkg", targets: [
.target(name: "pkg1", dependencies: ["pkg2"]),
.target(name: "pkg2", dependencies: ["pkg3"]),
.target(name: "pkg3", dependencies: ["pkg2"]),
])
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("cyclic dependency declaration found: pkg1 -> pkg2 -> pkg3 -> pkg2")
}
}
do {
// Reference a target which doesn't have sources.
let fs = InMemoryFileSystem(emptyFiles:
"/Sources/pkg1/Foo.swift",
"/Sources/pkg2/readme.txt")
let package = Package(
name: "pkg",
targets: [
.target(name: "pkg1", dependencies: ["pkg2"]),
.target(name: "pkg2"),
])
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("target 'pkg2' in package 'pkg' contains no valid source files")
result.checkModule("pkg1") { moduleResult in
moduleResult.check(c99name: "pkg1", type: .library)
moduleResult.checkSources(root: "/Sources/pkg1", paths: "Foo.swift")
}
}
}
do {
let fs = InMemoryFileSystem(emptyFiles:
"/Sources/Foo/Foo.c",
"/Sources/Bar/Bar.c")
let package = Package(
name: "Foo",
targets: [
.target(name: "Foo", publicHeadersPath: "../inc"),
])
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("public headers directory path for 'Foo' is invalid or not contained in the target")
}
package.targets = [.target(name: "Bar", publicHeadersPath: "inc/../../../foo")]
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("public headers directory path for 'Bar' is invalid or not contained in the target")
}
}
do {
let fs = InMemoryFileSystem(emptyFiles:
"/pkg/Sources/Foo/Foo.c",
"/foo/Bar.c")
let package = Package(
name: "Foo",
targets: [
.target(name: "Foo", path: "../foo"),
])
PackageBuilderTester(package, path: AbsolutePath("/pkg"), in: fs) { result in
result.checkDiagnostic("target 'Foo' in package 'Foo' is outside the package root")
}
}
}
func testExecutableAsADep() {
// Executable as dependency.
let fs = InMemoryFileSystem(emptyFiles:
"/Sources/exec/main.swift",
"/Sources/lib/lib.swift")
let package = Package(
name: "pkg",
targets: [
.target(name: "lib", dependencies: ["exec"]),
.target(name: "exec"),
])
PackageBuilderTester(package, in: fs) { result in
result.checkModule("exec") { moduleResult in
moduleResult.check(c99name: "exec", type: .executable)
moduleResult.checkSources(root: "/Sources/exec", paths: "main.swift")
}
result.checkModule("lib") { moduleResult in
moduleResult.check(c99name: "lib", type: .library)
moduleResult.checkSources(root: "/Sources/lib", paths: "lib.swift")
}
result.checkProduct("exec")
}
}
func testInvalidManifestConfigForNonSystemModules() {
var fs = InMemoryFileSystem(emptyFiles:
"/Sources/main.swift"
)
var package = Package(name: "pkg", pkgConfig: "foo")
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("configuration of package 'pkg' is invalid; the 'pkgConfig' property can only be used with a System Module Package")
}
fs = InMemoryFileSystem(emptyFiles:
"/Sources/Foo/main.c"
)
package = Package(name: "pkg", providers: [.brew(["foo"])])
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("configuration of package 'pkg' is invalid; the 'providers' property can only be used with a System Module Package")
}
}
func testResolvesSystemModulePackage() throws {
let fs = InMemoryFileSystem(emptyFiles:
"/module.modulemap")
let pkg = Package(name: "SystemModulePackage")
PackageBuilderTester(pkg, in: fs) { result in
result.checkModule("SystemModulePackage") { moduleResult in
moduleResult.check(c99name: "SystemModulePackage", type: .systemModule)
moduleResult.checkSources(root: "/")
}
}
}
func testCompatibleSwiftVersions() throws {
// Single swift executable target.
let fs = InMemoryFileSystem(emptyFiles:
"/foo/main.swift"
)
let package = Package(
name: "pkg",
targets: [.target(name: "foo", path: "foo")],
swiftLanguageVersions: [3, 4])
PackageBuilderTester(package, in: fs) { result in
result.checkModule("foo") { moduleResult in
moduleResult.check(swiftVersion: 4)
}
result.checkProduct("foo") { _ in }
}
package.swiftLanguageVersions = [3]
PackageBuilderTester(package, in: fs) { result in
result.checkModule("foo") { moduleResult in
moduleResult.check(swiftVersion: 3)
}
result.checkProduct("foo") { _ in }
}
package.swiftLanguageVersions = [4]
PackageBuilderTester(package, in: fs) { result in
result.checkModule("foo") { moduleResult in
moduleResult.check(swiftVersion: 4)
}
result.checkProduct("foo") { _ in }
}
package.swiftLanguageVersions = nil
PackageBuilderTester(package, in: fs) { result in
result.checkModule("foo") { moduleResult in
moduleResult.check(swiftVersion: 4)
}
result.checkProduct("foo") { _ in }
}
package.swiftLanguageVersions = []
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("package 'pkg' supported Swift language versions is empty")
}
package.swiftLanguageVersions = [500, 600]
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("package \'pkg\' not compatible with current tools version (4); it supports: 500, 600")
}
}
func testPredefinedTargetSearchError() {
do {
// We should look only in one of the predefined search paths.
let fs = InMemoryFileSystem(emptyFiles:
"/Source/Foo/Foo.swift",
"/src/Bar/Bar.swift")
let package = Package(
name: "pkg",
targets: [
.target(name: "Foo", dependencies: ["Bar"]),
.target(name: "Bar"),
]
)
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("could not find target(s): Bar; use the 'path' property in the Swift 4 manifest to set a custom target path")
}
}
do {
// We should look only in one of the predefined search paths.
let fs = InMemoryFileSystem(emptyFiles:
"/Source/Foo/Foo.swift",
"/Tests/FooTests/Foo.swift",
"/Source/BarTests/Foo.swift")
let package = Package(
name: "pkg",
targets: [
.testTarget(name: "BarTests"),
.testTarget(name: "FooTests"),
]
)
PackageBuilderTester(package, in: fs) { result in
result.checkDiagnostic("could not find target(s): BarTests; use the 'path' property in the Swift 4 manifest to set a custom target path")
}
// We should be able to fix this by using custom paths.
package.targets[0] = .testTarget(name: "BarTests", path: "Source/BarTests")
PackageBuilderTester(package, in: fs) { result in
result.checkModule("BarTests") { moduleResult in
moduleResult.check(c99name: "BarTests", type: .test)
}
result.checkModule("FooTests") { moduleResult in
moduleResult.check(c99name: "FooTests", type: .test)
}
result.checkProduct("pkgPackageTests") { _ in }
}
}
}
func testSpecialTargetDir() {
// Special directory should be src because both target and test target are under it.
let fs = InMemoryFileSystem(emptyFiles:
"/src/A/Foo.swift",
"/src/ATests/Foo.swift")
let package = Package(
name: "Foo",
targets: [
.target(name: "A"),
.testTarget(name: "ATests"),
]
)
PackageBuilderTester(package, in: fs) { result in
result.checkPredefinedPaths(target: "/src", testTarget: "/src")
result.checkModule("A") { moduleResult in
moduleResult.check(c99name: "A", type: .library)
}
result.checkModule("ATests") { moduleResult in
moduleResult.check(c99name: "ATests", type: .test)
}
result.checkProduct("FooPackageTests") { _ in }
}
}
func testExcludes() {
// The exclude should win if a file is in exclude as well as sources.
let fs = InMemoryFileSystem(emptyFiles:
"/Sources/bar/barExcluded.swift",
"/Sources/bar/bar.swift"
)
let package = Package(
name: "pkg",
targets: [
.target(
name: "bar",
exclude: ["barExcluded.swift",],
sources: ["bar.swift", "barExcluded.swift"]
),
]
)
PackageBuilderTester(package, in: fs) { result in
result.checkModule("bar") { moduleResult in
moduleResult.check(c99name: "bar", type: .library)
moduleResult.checkSources(root: "/Sources/bar", paths: "bar.swift")
}
}
}
static var allTests = [
("testCompatibleSwiftVersions", testCompatibleSwiftVersions),
("testCustomTargetDependencies", testCustomTargetDependencies),
("testCustomTargetPaths", testCustomTargetPaths),
("testCustomTargetPathsOverlap", testCustomTargetPathsOverlap),
("testDeclaredExecutableProducts", testDeclaredExecutableProducts),
("testExecutableAsADep", testExecutableAsADep),
("testInvalidManifestConfigForNonSystemModules", testInvalidManifestConfigForNonSystemModules),
("testLinuxMain", testLinuxMain),
("testLinuxMainError", testLinuxMainError),
("testManifestTargetDeclErrors", testManifestTargetDeclErrors),
("testMultipleTestProducts", testMultipleTestProducts),
("testPublicHeadersPath", testPublicHeadersPath),
("testResolvesSystemModulePackage", testResolvesSystemModulePackage),
("testTargetDependencies", testTargetDependencies),
("testTestsLayoutsv4", testTestsLayoutsv4),
("testPredefinedTargetSearchError", testPredefinedTargetSearchError),
("testSpecialTargetDir", testSpecialTargetDir),
("testDuplicateTargets", testDuplicateTargets),
("testExcludes", testExcludes),
]
}