1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift open source project
//
// Copyright (c) 2020-2023 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 struct Basics.AbsolutePath
import struct Basics.Triple
import enum PackageModel.BuildConfiguration
extension BuildParameters {
/// Represents the test product style.
public enum TestProductStyle: Encodable {
/// Test product is a loadable bundle. This style is used on Darwin platforms and, for XCTest tests, relies on the Objective-C
/// runtime to automatically discover all tests.
case loadableBundle
/// Test product is an executable which serves as the testing entry point. This style is used on non-Darwin platforms and,
/// for XCTests, relies on the testing entry point file to indicate which tests to run. By default, the test entry point file is
/// synthesized automatically, and uses indexer data to locate all tests and run them. But the entry point may be customized
/// in one of two ways: if a path to a test entry point file was explicitly passed via the
/// `--experimental-test-entry-point-path <file>` option, that file is used, otherwise if an `XCTMain.swift`
/// (formerly `LinuxMain.swift`) file is located in the package, it is used.
///
/// - Parameter explicitlyEnabledDiscovery: Whether test discovery generation was forced by passing
/// `--enable-test-discovery`, overriding any custom test entry point file specified via other CLI options or located in
/// the package.
/// - Parameter explicitlySpecifiedPath: The path to the test entry point file, if one was specified explicitly via
/// `--experimental-test-entry-point-path <file>`.
case entryPointExecutable(
explicitlyEnabledDiscovery: Bool,
explicitlySpecifiedPath: AbsolutePath?
)
/// The explicitly-specified entry point file path, if this style of test product supports it and a path was specified.
public var explicitlySpecifiedEntryPointPath: AbsolutePath? {
switch self {
case .loadableBundle:
return nil
case .entryPointExecutable(explicitlyEnabledDiscovery: _, explicitlySpecifiedPath: let entryPointPath):
return entryPointPath
}
}
public enum DiscriminatorKeys: String, Codable {
case loadableBundle
case entryPointExecutable
}
public enum CodingKeys: CodingKey {
case _case
case explicitlyEnabledDiscovery
case explicitlySpecifiedPath
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
switch self {
case .loadableBundle:
try container.encode(DiscriminatorKeys.loadableBundle, forKey: ._case)
case .entryPointExecutable(let explicitlyEnabledDiscovery, let explicitlySpecifiedPath):
try container.encode(DiscriminatorKeys.entryPointExecutable, forKey: ._case)
try container.encode(explicitlyEnabledDiscovery, forKey: .explicitlyEnabledDiscovery)
try container.encode(explicitlySpecifiedPath, forKey: .explicitlySpecifiedPath)
}
}
}
/// Build parameters related to testing grouped in a single type to aggregate those in one place.
public struct Testing: Encodable {
/// Whether to enable code coverage.
public var enableCodeCoverage: Bool
/// Whether building for testability is explicitly enabled or disabled.
package var explicitlyEnabledTestability: Bool?
/// Whether or not to enable the experimental test output mode.
public var experimentalTestOutput: Bool
/// Whether to force test discovery.
fileprivate var explicitlyEnabledDiscovery: Bool
/// The path to the test entry point file, if one was specified explicitly
/// via `--experimental-test-entry-point-path <file>`.
fileprivate var explicitlySpecifiedPath: AbsolutePath?
public init(
enableCodeCoverage: Bool = false,
enableTestability: Bool? = nil,
experimentalTestOutput: Bool = false,
forceTestDiscovery: Bool = false,
testEntryPointPath: AbsolutePath? = nil
) {
self.enableCodeCoverage = enableCodeCoverage
self.experimentalTestOutput = experimentalTestOutput
self.explicitlyEnabledTestability = enableTestability
self.explicitlyEnabledDiscovery = forceTestDiscovery
self.explicitlySpecifiedPath = testEntryPointPath
}
}
/// Whether building for testability is enabled.
public var enableTestability: Bool {
// decide on testability based on debug/release config
// the goals of this being based on the build configuration is
// that `swift build` followed by a `swift test` will need to do minimal rebuilding
// given that the default configuration for `swift build` is debug
// and that `swift test` normally requires building with testable enabled.
// when building and testing in release mode, one can use the '--disable-testable-imports' flag
// to disable testability in `swift test`, but that requires that the tests do not use the testable imports feature
self.testingParameters.explicitlyEnabledTestability ?? (self.configuration == .debug)
}
/// The style of test product to produce.
public var testProductStyle: TestProductStyle {
return triple.isDarwin() ? .loadableBundle : .entryPointExecutable(
explicitlyEnabledDiscovery: testingParameters.explicitlyEnabledDiscovery,
explicitlySpecifiedPath: testingParameters.explicitlySpecifiedPath
)
}
}
|
