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
|
//
// 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
@Suite("Comment Tests", .tags(.traitRelated))
struct CommentTests {
@Test(".comment() factory method")
func commentFactoryMethod() {
let trait = Comment.comment("No comment")
#expect((trait as Any) is Comment)
}
@Test("Test.comments property")
func testCommentsGetter() async throws {
let plan = await Runner.Plan(selecting: CommentedTests.self)
let commentTestsType = try #require(plan.steps.map(\.test).first { $0.name == "CommentedTests" })
#expect(commentTestsType.comments == ["A"])
// Comments are not inherited
let example1 = try #require(plan.steps.map(\.test).first { $0.name == "example1()" })
#expect(example1.comments == ["B", "C"])
let example2 = try #require(plan.steps.map(\.test).first { $0.name == "example2()" })
#expect(example2.comments == [
"// D",
"/// E",
"/* F */",
"/** G */",
])
let example3 = try #require(plan.steps.map(\.test).first { $0.name == "example3()" })
#expect(example3.comments == ["H", "I"])
#expect(example3.comments(from: Comment.self) == ["H"])
let innerType = try #require(plan.steps.map(\.test).first { $0.name == "Inner" })
#expect(innerType.comments == ["// J"])
#if !SWT_NO_GLOBAL_ACTORS
let example4 = try #require(plan.steps.map(\.test).first { $0.name == "example4()" })
#expect(example4.comments == ["// K"])
let inner2Type = try #require(plan.steps.map(\.test).first { $0.name == "Inner2" })
#expect(inner2Type.comments == ["// L"])
#endif
}
@Test("Explicitly nil comment")
func explicitlyNilComment() {
#expect(true as Bool, nil as Comment?)
}
@Test("String interpolation")
func stringInterpolation() {
let value1: Int = 123
let value2: Int? = nil
let value3: Any.Type = Int.self
let comment: Comment = "abc\(value1)def\(value2)ghi\(value3)"
#expect(comment.rawValue == "abc123defnilghiInt")
}
@Test("String interpolation with a custom type")
func stringInterpolationWithCustomType() {
struct S: CustomStringConvertible, CustomTestStringConvertible {
var description: String {
"wrong!"
}
var testDescription: String {
"right!"
}
}
let comment: Comment = "abc\(S())def\(S() as S?)ghi\(S.self)jkl\("string")"
#expect(comment.rawValue == "abcright!defright!ghiSjklstring")
}
}
// MARK: - Fixtures
@Suite(.hidden, .comment("A"))
struct CommentedTests {
@Test(.hidden, .comment("B"), .comment("C"))
func example1() {}
// D
/// E
/* F */
/** G */
@Test(.hidden)
func example2() {}
@Test(.hidden, .comment("H"), .disabled("I"))
func example3() {}
// J
@Suite struct Inner {}
#if !SWT_NO_GLOBAL_ACTORS
// K
@MainActor
@Test(.hidden)
func example4() {}
// L
@MainActor
@Suite(.hidden) struct Inner2 {}
#endif
}
|
