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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
|
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2024 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
//
@testable @_spi(Experimental) @_spi(ForToolsIntegrationOnly) import Testing
private import _TestingInternals
#if !SWT_NO_EXIT_TESTS
@Suite("Exit test tests") struct ExitTestTests {
@Test("Exit tests (passing)") func passing() async {
await #expect(exitsWith: .failure) {
exit(EXIT_FAILURE)
}
if EXIT_SUCCESS != EXIT_FAILURE + 1 {
await #expect(exitsWith: .failure) {
exit(EXIT_FAILURE + 1)
}
}
await #expect(exitsWith: .success) {
exit(EXIT_SUCCESS)
}
await #expect(exitsWith: .exitCode(123)) {
exit(123)
}
await #expect(exitsWith: .exitCode(123)) {
await Task.yield()
exit(123)
}
#if !os(Windows)
await #expect(exitsWith: .signal(SIGKILL)) {
_ = kill(getpid(), SIGKILL)
// Allow up to 1s for the signal to be delivered.
try! await Task.sleep(nanoseconds: 1_000_000_000_000)
}
await #expect(exitsWith: .signal(SIGABRT)) {
abort()
}
#endif
#if !SWT_NO_UNSTRUCTURED_TASKS
#if false
// Test the detached (no task-local configuration) path. Disabled because,
// like other tests using Task.detached, it can interfere with other tests
// running concurrently.
#expect(Test.current != nil)
await Task.detached {
#expect(Test.current == nil)
await #expect(exitsWith: .failure) {
fatalError()
}
}.value
#endif
#endif
}
@Test("Exit tests (failing)") func failing() async {
let expectedCount: Int
#if os(Windows)
expectedCount = 6
#else
expectedCount = 10
#endif
await confirmation("Exit tests failed", expectedCount: expectedCount) { failed in
var configuration = Configuration()
configuration.eventHandler = { event, _ in
if case .issueRecorded = event.kind {
failed()
}
}
configuration.exitTestHandler = ExitTest.handlerForEntryPoint()
await runTest(for: FailingExitTests.self, configuration: configuration)
}
}
@Test("Mock exit test handlers (passing)") func passingMockHandler() async {
await confirmation("System issue recorded", expectedCount: 0) { issueRecorded in
var configuration = Configuration()
configuration.eventHandler = { event, _ in
if case .issueRecorded = event.kind {
issueRecorded()
}
}
// Mock an exit test where the process exits successfully.
configuration.exitTestHandler = { _ in
return .exitCode(EXIT_SUCCESS)
}
await Test {
await #expect(exitsWith: .success) {}
}.run(configuration: configuration)
// Mock an exit test where the process exits with a generic failure.
configuration.exitTestHandler = { _ in
return .failure
}
await Test {
await #expect(exitsWith: .failure) {}
}.run(configuration: configuration)
await Test {
await #expect(exitsWith: .exitCode(EXIT_FAILURE)) {}
}.run(configuration: configuration)
#if !os(Windows)
await Test {
await #expect(exitsWith: .signal(SIGABRT)) {}
}.run(configuration: configuration)
#endif
// Mock an exit test where the process exits with a particular error code.
configuration.exitTestHandler = { _ in
return .exitCode(123)
}
await Test {
await #expect(exitsWith: .failure) {}
}.run(configuration: configuration)
#if !os(Windows)
// Mock an exit test where the process exits with a signal.
configuration.exitTestHandler = { _ in
return .signal(SIGABRT)
}
await Test {
await #expect(exitsWith: .signal(SIGABRT)) {}
}.run(configuration: configuration)
await Test {
await #expect(exitsWith: .failure) {}
}.run(configuration: configuration)
#endif
}
}
@Test("Mock exit test handlers (failing)") func failingMockHandlers() async {
let expectedCount: Int
#if os(Windows)
expectedCount = 2
#else
expectedCount = 6
#endif
await confirmation("Issue recorded", expectedCount: expectedCount) { issueRecorded in
var configuration = Configuration()
configuration.eventHandler = { event, _ in
if case .issueRecorded = event.kind {
issueRecorded()
}
}
// Mock exit tests that were expected to fail but passed.
configuration.exitTestHandler = { _ in
return .exitCode(EXIT_SUCCESS)
}
await Test {
await #expect(exitsWith: .failure) {}
}.run(configuration: configuration)
await Test {
await #expect(exitsWith: .exitCode(EXIT_FAILURE)) {}
}.run(configuration: configuration)
#if !os(Windows)
await Test {
await #expect(exitsWith: .signal(SIGABRT)) {}
}.run(configuration: configuration)
#endif
#if !os(Windows)
// Mock exit tests that unexpectedly signalled.
configuration.exitTestHandler = { _ in
return .signal(SIGABRT)
}
await Test {
await #expect(exitsWith: .exitCode(EXIT_SUCCESS)) {}
}.run(configuration: configuration)
await Test {
await #expect(exitsWith: .exitCode(EXIT_FAILURE)) {}
}.run(configuration: configuration)
await Test {
await #expect(exitsWith: .success) {}
}.run(configuration: configuration)
#endif
}
}
@Test("Exit test without configured exit test handler") func noHandler() async {
await confirmation("System issue recorded") { issueRecorded in
var configuration = Configuration()
configuration.eventHandler = { event, _ in
if case let .issueRecorded(issue) = event.kind, case .system = issue.kind {
issueRecorded()
}
}
await Test {
await #expect(exitsWith: .success) {}
}.run(configuration: configuration)
}
}
}
// MARK: - Fixtures
@Suite(.hidden) struct FailingExitTests {
@Test(.hidden) func failingExitTests() async {
await #expect(exitsWith: .success) {}
await #expect(exitsWith: .failure) {}
await #expect(exitsWith: .exitCode(123)) {}
await #expect(exitsWith: .failure) {
exit(EXIT_SUCCESS)
}
await #expect(exitsWith: .success) {
exit(EXIT_FAILURE)
}
await #expect(exitsWith: .exitCode(123)) {
exit(0)
}
#if !os(Windows)
await #expect(exitsWith: .exitCode(SIGABRT)) {
// abort() raises on Windows, but we don't handle that yet and it is
// reported as .failure (which will fuzzy-match with SIGABRT.)
abort()
}
await #expect(exitsWith: .signal(123)) {}
await #expect(exitsWith: .signal(123)) {
exit(123)
}
await #expect(exitsWith: .signal(SIGSEGV)) {
abort() // sends SIGABRT, not SIGSEGV
}
#endif
}
}
#if false // intentionally fails to compile
@Test(arguments: 100 ..< 200)
func sellIceCreamCones(count: Int) async throws {
try await #require(exitsWith: .failure) {
precondition(count < 10, "Too many ice cream cones")
}
}
#endif
#endif
|
