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
|
//===--- AssertDiagnosticsTests.swift - Diagnostic Test Assertion Tests ---===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2019 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 the list of Swift project authors
//
//===----------------------------------------------------------------------===//
import XCTest
@_spi(Testing) import SwiftDriver
// Yes, these are meta-tests! `assertDiagnostics(do:)` and friends are
// complicated enough to warrant a few tests of their own. To test that they
// fail when they're supposed to, this test class has access to an
// `assertFails(times:during:)` helper; see `FailableTestCase` below for the
// implementation.
class AssertDiagnosticsTests: FailableTestCase {
func testAssertNoDiagnostics() {
assertNoDiagnostics { _ in }
assertFails {
assertNoDiagnostics { diags in
diags.emit(error: "something happened")
}
}
assertFails {
assertNoDiagnostics { diags in
diags.emit(warning: "hello")
}
}
// Unexpected warnings/notes/remarks are okay
assertNoDiagnostics { diags in
diags.emit(note: "hello")
}
assertNoDiagnostics { diags in
diags.emit(remark: "hello")
}
}
func testAssertDiagnostics() {
assertDiagnostics { diags, match in
diags.emit(error: "yankees won again")
match.expect(.error("won"))
}
assertDiagnostics { diags, match in
match.expect(.error("won"))
diags.emit(error: "yankees won again")
}
assertFails(times: 2) {
assertDiagnostics { diags, match in
match.expect(.error("lost"))
diags.emit(error: "yankees won again")
}
}
assertFails(times: 2) {
assertDiagnostics { diags, match in
diags.emit(error: "yankees won again")
diags.emit(error: "yankees won yet again")
}
}
assertFails(times: 2) {
assertDiagnostics { diags, match in
match.expect(.error("won"))
match.expect(.error("won"))
}
}
// We should get two assertion failures: one for expecting the warning, one
// for emitting the error.
assertFails(times: 2) {
assertDiagnostics { diags, match in
match.expect(.warning("won"))
diags.emit(.error("yankees won again"))
}
}
// We should get one assertion failure for the unexpected error. An
// unexpected note is okay.
assertFails(times: 1) {
assertDiagnostics { diags, match in
diags.emit(error: "yankees won again")
diags.emit(note: "investigate their star's doctor")
}
}
// ...unless we tighten things up.
assertFails(times: 2) {
assertDiagnostics { diags, match in
diags.emit(error: "yankees won again")
diags.emit(note: "investigate their star's doctor")
match.forbidUnexpected(.note)
}
}
// ...or loosen them.
assertDiagnostics { diags, match in
diags.emit(error: "yankees won again")
diags.emit(note: "investigate their star's doctor")
match.permitUnexpected(.error)
}
}
func testAssertDriverDiagosotics() throws {
try assertNoDriverDiagnostics(args: "swiftc", "test.swift")
try assertDriverDiagnostics(args: "swiftc", "test.swift") { driver, verify in
driver.diagnosticEngine.emit(.error("this mode does not support emitting modules"))
verify.expect(.error("this mode does not support emitting modules"))
}
try assertFails {
try assertDriverDiagnostics(args: "swiftc", "test.swift") { driver, verify in
verify.expect(.error("this mode does not support emitting modules"))
}
}
try assertFails {
try assertDriverDiagnostics(args: "swiftc", "test.swift") { driver, verify in
driver.diagnosticEngine.emit(.error("this mode does not support emitting modules"))
}
}
try assertFails(times: 2) {
try assertDriverDiagnostics(args: "swiftc", "test.swift") { driver, verify in
driver.diagnosticEngine.emit(.error("this mode does not support emitting modules"))
verify.expect(.error("-static may not be used with -emit-executable"))
}
}
}
}
// MARK: - Failure testing
/// Subclasses are considered to pass if exactly the right number of test assertions
/// fail in each `assertFails(times:during:)` block. Failures are recorded
/// if they fail too often or not often enough.
class FailableTestCase: XCTestCase {
fileprivate var anticipatedFailures = 0
func assertFails(
times: Int = 1,
_ message: String = "",
file: String = #file,
line: Int = #line,
during body: () throws -> Void
) rethrows {
let outer = anticipatedFailures
anticipatedFailures = times
defer {
if anticipatedFailures > 0 {
recordFailure(
withDescription: "\(anticipatedFailures) failure(s) were supposed to occur, but did not: \(message)",
inFile: file, atLine: line,
expected: false
)
}
anticipatedFailures = outer
}
try body()
}
override func setUp() {
super.setUp()
anticipatedFailures = 0
}
override func recordFailure(
withDescription description: String,
inFile filePath: String, atLine lineNumber: Int,
expected: Bool
) {
guard anticipatedFailures == 0 else {
anticipatedFailures -= 1
return
}
if #available(macOS 10.13, *) {
super.recordFailure(
withDescription: description,
inFile: filePath, atLine: lineNumber,
expected: expected
)
} else {
fatalError(description, line: UInt(lineNumber))
}
}
}
|