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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2023 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for Swift project authors
//
private import _TestingInternals
/// A protocol describing a type that contains tests.
///
/// - Warning: This protocol is used to implement the `@Test` macro. Do not use
/// it directly.
@_alwaysEmitConformanceMetadata
public protocol __TestContainer {
/// The set of tests contained by this type.
static var __tests: [Test] { get async }
}
extension Test {
/// A string that appears within all auto-generated types conforming to the
/// `__TestContainer` protocol.
private static let _testContainerTypeNameMagic = "__🟠$test_container__"
/// All available ``Test`` instances in the process, according to the runtime.
///
/// The order of values in this sequence is unspecified.
static var all: some Sequence<Test> {
get async {
// Convert the raw sequence of tests to a dictionary keyed by ID.
var result = await testsByID(_all)
// Ensure test suite types that don't have the @Suite attribute are still
// represented in the result.
_synthesizeSuiteTypes(into: &result)
return result.values
}
}
/// All available ``Test`` instances in the process, according to the runtime.
///
/// The order of values in this sequence is unspecified. This sequence may
/// contain duplicates; callers should use ``all`` instead.
private static var _all: some Sequence<Self> {
get async {
await withTaskGroup(of: [Self].self) { taskGroup in
enumerateTypes(withNamesContaining: _testContainerTypeNameMagic) { type, _ in
if let type = type as? any __TestContainer.Type {
taskGroup.addTask {
await type.__tests
}
}
}
return await taskGroup.reduce(into: [], +=)
}
}
}
/// Create a dictionary mapping the IDs of a sequence of tests to those tests.
///
/// - Parameters:
/// - tests: The sequence to convert to a dictionary.
///
/// - Returns: A dictionary containing `tests` keyed by those tests' IDs.
static func testsByID(_ tests: some Sequence<Self>) -> [ID: Self] {
[ID: Self](
tests.lazy.map { ($0.id, $0) },
uniquingKeysWith: { existing, _ in existing }
)
}
/// Synthesize any missing test suite types (that is, types containing test
/// content that do not have the `@Suite` attribute) and add them to a
/// dictionary of tests.
///
/// - Parameters:
/// - tests: A dictionary of tests to amend.
///
/// - Returns: The number of key-value pairs added to `tests`.
@discardableResult private static func _synthesizeSuiteTypes(into tests: inout [ID: Self]) -> Int {
let originalCount = tests.count
// Find any instances of Test in the input that are *not* suites. We'll be
// checking the containing types of each one.
for test in tests.values where !test.isSuite {
guard let suiteTypeInfo = test.containingTypeInfo else {
continue
}
let suiteID = ID(typeInfo: suiteTypeInfo)
if tests[suiteID] == nil {
tests[suiteID] = Test(traits: [], sourceLocation: test.sourceLocation, containingTypeInfo: suiteTypeInfo, isSynthesized: true)
// Also synthesize any ancestral suites that don't have tests.
for ancestralSuiteTypeInfo in suiteTypeInfo.allContainingTypeInfo {
let ancestralSuiteID = ID(typeInfo: ancestralSuiteTypeInfo)
if tests[ancestralSuiteID] == nil {
tests[ancestralSuiteID] = Test(traits: [], sourceLocation: test.sourceLocation, containingTypeInfo: ancestralSuiteTypeInfo, isSynthesized: true)
}
}
}
}
return tests.count - originalCount
}
}
// MARK: -
/// The type of callback called by ``enumerateTypes(withNamesContaining:_:)``.
///
/// - Parameters:
/// - type: A Swift type.
/// - stop: An `inout` boolean variable indicating whether type enumeration
/// should stop after the function returns. Set `stop` to `true` to stop
/// type enumeration.
typealias TypeEnumerator = (_ type: Any.Type, _ stop: inout Bool) -> Void
/// Enumerate all types known to Swift found in the current process whose names
/// contain a given substring.
///
/// - Parameters:
/// - nameSubstring: A string which the names of matching classes all contain.
/// - body: A function to invoke, once per matching type.
func enumerateTypes(withNamesContaining nameSubstring: String, _ typeEnumerator: TypeEnumerator) {
withoutActuallyEscaping(typeEnumerator) { typeEnumerator in
withUnsafePointer(to: typeEnumerator) { context in
swt_enumerateTypes(withNamesContaining: nameSubstring, .init(mutating: context)) { type, stop, context in
let typeEnumerator = context!.load(as: TypeEnumerator.self)
let type = unsafeBitCast(type, to: Any.Type.self)
var stop2 = false
typeEnumerator(type, &stop2)
stop.pointee = stop2
}
}
}
}
|
