mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
12c7cead9d
This adjusts the paths in the test to support the Linux and Windows path separators. Loosen the test to accept the interleaved stdout output on Windows.
618 lines
19 KiB
Swift
618 lines
19 KiB
Swift
// RUN: %target-run-simple-swift | %FileCheck %s
|
|
// REQUIRES: executable_test
|
|
// FIXME: this test is failing for watchos <rdar://problem/29996991>
|
|
// UNSUPPORTED: OS=watchos
|
|
|
|
import SwiftPrivate
|
|
import StdlibUnittest
|
|
|
|
|
|
_setOverrideOSVersion(.osx(major: 10, minor: 9, bugFix: 3))
|
|
_setTestSuiteFailedCallback() { print("abort()") }
|
|
|
|
//
|
|
// Test that harness aborts when a test fails
|
|
//
|
|
|
|
var TestSuitePasses = TestSuite("TestSuitePasses")
|
|
|
|
// CHECK: {{^}}[ RUN ] TestSuitePasses.passes{{$}}
|
|
// CHECK: {{^}}[ OK ] TestSuitePasses.passes{{$}}
|
|
TestSuitePasses.test("passes") {
|
|
expectEqual(1, 1)
|
|
}
|
|
|
|
// CHECK: {{^}}[ RUN ] TestSuitePasses.passes/parameterized/0{{$}}
|
|
// CHECK: {{^}}stdout>>> 1010{{$}}
|
|
// CHECK: {{^}}[ OK ] TestSuitePasses.passes/parameterized/0{{$}}
|
|
// CHECK: {{^}}[ RUN ] TestSuitePasses.passes/parameterized/1{{$}}
|
|
// CHECK: {{^}}stdout>>> 2020{{$}}
|
|
// CHECK: {{^}}[ OK ] TestSuitePasses.passes/parameterized/1{{$}}
|
|
TestSuitePasses.test("passes/parameterized").forEach(in: [1010, 2020]) {
|
|
(parameter) in
|
|
|
|
print(parameter)
|
|
expectEqual(1, 1)
|
|
}
|
|
// CHECK: TestSuitePasses: All tests passed
|
|
|
|
var TestSuiteUXPasses = TestSuite("TestSuiteUXPasses")
|
|
|
|
// CHECK: {{^}}[ UXPASS ] TestSuiteUXPasses.uxpasses{{$}}
|
|
TestSuiteUXPasses.test("uxpasses").xfail(.osxAny("")).code {
|
|
expectEqual(1, 1)
|
|
}
|
|
|
|
// CHECK: {{^}}[ UXPASS ] TestSuiteUXPasses.uxpasses/parameterized/0{{$}}
|
|
// CHECK: {{^}}[ XFAIL ] TestSuiteUXPasses.uxpasses/parameterized/1{{$}}
|
|
TestSuiteUXPasses.test("uxpasses/parameterized")
|
|
.xfail(.osxAny(""))
|
|
.forEach(in: [1010, 2020]) {
|
|
(parameter) in
|
|
|
|
if parameter == 1010 {
|
|
expectEqual(1, 1)
|
|
} else {
|
|
expectEqual(1, 2)
|
|
}
|
|
}
|
|
|
|
// CHECK: TestSuiteUXPasses: Some tests failed, aborting
|
|
// CHECK: UXPASS: ["uxpasses", "uxpasses/parameterized/0"]
|
|
// CHECK: FAIL: []
|
|
// CHECK: SKIP: []
|
|
// CHECK: abort()
|
|
|
|
var TestSuiteFails = TestSuite("TestSuiteFails")
|
|
|
|
// CHECK: {{^}}[ FAIL ] TestSuiteFails.fails{{$}}
|
|
TestSuiteFails.test("fails") {
|
|
expectEqual(1, 2)
|
|
}
|
|
|
|
// CHECK: {{^}}[ OK ] TestSuiteFails.fails/parameterized/0{{$}}
|
|
// CHECK: {{^}}[ FAIL ] TestSuiteFails.fails/parameterized/1{{$}}
|
|
TestSuiteFails.test("fails/parameterized").forEach(in: [1010, 2020]) {
|
|
(parameter) in
|
|
|
|
if parameter == 1010 {
|
|
expectEqual(1, 1)
|
|
} else {
|
|
expectEqual(1, 2)
|
|
}
|
|
}
|
|
|
|
// CHECK: TestSuiteFails: Some tests failed, aborting
|
|
// CHECK: UXPASS: []
|
|
// CHECK: FAIL: ["fails", "fails/parameterized/1"]
|
|
// CHECK: SKIP: []
|
|
// CHECK: abort()
|
|
|
|
var TestSuiteXFails = TestSuite("TestSuiteXFails")
|
|
|
|
// CHECK: {{^}}[ XFAIL ] TestSuiteXFails.xfails{{$}}
|
|
TestSuiteXFails.test("xfails").xfail(.osxAny("")).code {
|
|
expectEqual(1, 2)
|
|
}
|
|
|
|
// CHECK: {{^}}[ UXPASS ] TestSuiteXFails.xfails/parameterized/0{{$}}
|
|
// CHECK: {{^}}[ XFAIL ] TestSuiteXFails.xfails/parameterized/1{{$}}
|
|
TestSuiteXFails.test("xfails/parameterized")
|
|
.xfail(.osxAny(""))
|
|
.forEach(in: [1010, 2020]) {
|
|
(parameter) in
|
|
|
|
if parameter == 1010 {
|
|
expectEqual(1, 1)
|
|
} else {
|
|
expectEqual(1, 2)
|
|
}
|
|
}
|
|
|
|
// CHECK: TestSuiteXFails: Some tests failed, aborting
|
|
// CHECK: UXPASS: ["xfails/parameterized/0"]
|
|
// CHECK: FAIL: []
|
|
// CHECK: SKIP: []
|
|
|
|
//
|
|
// Test 'xfail:' and 'skip:' annotations
|
|
//
|
|
|
|
var XFailsAndSkips = TestSuite("XFailsAndSkips")
|
|
|
|
// CHECK: [ OK ] XFailsAndSkips.passes{{$}}
|
|
XFailsAndSkips.test("passes") {
|
|
expectEqual(1, 1)
|
|
}
|
|
|
|
// CHECK: [ FAIL ] XFailsAndSkips.fails{{$}}
|
|
XFailsAndSkips.test("fails") {
|
|
expectEqual(1, 2)
|
|
}
|
|
|
|
// CHECK: [ XFAIL ] XFailsAndSkips.fails-always{{$}}
|
|
XFailsAndSkips.test("fails-always")
|
|
.xfail(.always("must always fail")).code {
|
|
expectEqual(1, 2)
|
|
}
|
|
|
|
// CHECK: [ OK ] XFailsAndSkips.fails-never{{$}}
|
|
XFailsAndSkips.test("fails-never")
|
|
.xfail(.never).code {
|
|
expectEqual(1, 1)
|
|
}
|
|
|
|
// CHECK: [ XFAIL ] XFailsAndSkips.xfail 10.9.3 passes{{$}}
|
|
XFailsAndSkips.test("xfail 10.9.3 passes")
|
|
.xfail(.osxBugFix(10, 9, 3, reason: "")).code {
|
|
expectEqual(1, 2)
|
|
}
|
|
|
|
// CHECK: [ XFAIL ] XFailsAndSkips.xfail 10.9.3 fails{{$}}
|
|
XFailsAndSkips.test("xfail 10.9.3 fails")
|
|
.xfail(.osxBugFix(10, 9, 3, reason: "")).code {
|
|
expectEqual(1, 2)
|
|
}
|
|
|
|
// CHECK: [ SKIP ] XFailsAndSkips.skipAlways (skip: [Always(reason: skip)]){{$}}
|
|
XFailsAndSkips.test("skipAlways")
|
|
.skip(.always("skip")).code {
|
|
fatalError("should not happen")
|
|
}
|
|
|
|
// CHECK: [ OK ] XFailsAndSkips.skipNever{{$}}
|
|
XFailsAndSkips.test("skipNever")
|
|
.skip(.never).code {
|
|
expectEqual(1, 1)
|
|
}
|
|
|
|
// CHECK: [ FAIL ] XFailsAndSkips.skip 10.9.2 passes{{$}}
|
|
XFailsAndSkips.test("skip 10.9.2 passes")
|
|
.skip(.osxBugFix(10, 9, 2, reason: "")).code {
|
|
expectEqual(1, 2)
|
|
}
|
|
|
|
// CHECK: [ FAIL ] XFailsAndSkips.skip 10.9.2 fails{{$}}
|
|
XFailsAndSkips.test("skip 10.9.2 fails")
|
|
.skip(.osxBugFix(10, 9, 2, reason: "")).code {
|
|
expectEqual(1, 2)
|
|
}
|
|
|
|
// CHECK: [ SKIP ] XFailsAndSkips.skip 10.9.3 (skip: [osx(10.9.3, reason: )]){{$}}
|
|
XFailsAndSkips.test("skip 10.9.3")
|
|
.skip(.osxBugFix(10, 9, 3, reason: "")).code {
|
|
expectEqual(1, 2)
|
|
fatalError("should not be executed")
|
|
}
|
|
|
|
// CHECK: XFailsAndSkips: Some tests failed, aborting
|
|
// CHECK: abort()
|
|
|
|
//
|
|
// Test custom XFAIL predicates
|
|
//
|
|
|
|
var XFailsCustomPredicates = TestSuite("XFailsCustomPredicates")
|
|
|
|
// CHECK: [ XFAIL ] XFailsCustomPredicates.matches{{$}}
|
|
XFailsCustomPredicates.test("matches")
|
|
.xfail(.custom({ true }, reason: "")).code {
|
|
expectEqual(1, 2)
|
|
}
|
|
|
|
// CHECK: [ OK ] XFailsCustomPredicates.not matches{{$}}
|
|
XFailsCustomPredicates.test("not matches")
|
|
.xfail(.custom({ false }, reason: "")).code {
|
|
expectEqual(1, 1)
|
|
}
|
|
|
|
// CHECK: XFailsCustomPredicates: All tests passed
|
|
|
|
//
|
|
// Test version comparison rules
|
|
//
|
|
|
|
var XFailsOSX = TestSuite("XFailsOSX")
|
|
|
|
// CHECK: [ UXPASS ] XFailsOSX.xfail OSX passes{{$}}
|
|
XFailsOSX.test("xfail OSX passes").xfail(.osxAny("")).code {
|
|
expectEqual(1, 1)
|
|
}
|
|
|
|
// CHECK: [ XFAIL ] XFailsOSX.xfail OSX fails{{$}}
|
|
XFailsOSX.test("xfail OSX fails").xfail(.osxAny("")).code {
|
|
expectEqual(1, 2)
|
|
}
|
|
|
|
// CHECK: [ OK ] XFailsOSX.xfail 9.*{{$}}
|
|
XFailsOSX.test("xfail 9.*").xfail(.osxMajor(9, reason: "")).code {
|
|
expectEqual(1, 1)
|
|
}
|
|
|
|
// CHECK: [ XFAIL ] XFailsOSX.xfail 10.*{{$}}
|
|
XFailsOSX.test("xfail 10.*").xfail(.osxMajor(10, reason: "")).code {
|
|
expectEqual(1, 2)
|
|
}
|
|
|
|
// CHECK: [ OK ] XFailsOSX.xfail 10.8{{$}}
|
|
XFailsOSX.test("xfail 10.8").xfail(.osxMinor(10, 8, reason: "")).code {
|
|
expectEqual(1, 1)
|
|
}
|
|
|
|
// CHECK: [ XFAIL ] XFailsOSX.xfail 10.9{{$}}
|
|
XFailsOSX.test("xfail 10.9").xfail(.osxMinor(10, 9, reason: "")).code {
|
|
expectEqual(1, 2)
|
|
}
|
|
|
|
// CHECK: [ OK ] XFailsOSX.xfail 10.[7-8]{{$}}
|
|
XFailsOSX.test("xfail 10.[7-8]")
|
|
.xfail(.osxMinorRange(10, 7...8, reason: "")).code {
|
|
expectEqual(1, 1)
|
|
}
|
|
|
|
// CHECK: [ XFAIL ] XFailsOSX.xfail 10.[9-10]{{$}}
|
|
XFailsOSX.test("xfail 10.[9-10]")
|
|
.xfail(.osxMinorRange(10, 9...10, reason: "")).code {
|
|
expectEqual(1, 2)
|
|
}
|
|
|
|
// CHECK: [ OK ] XFailsOSX.xfail 10.9.2{{$}}
|
|
XFailsOSX.test("xfail 10.9.2")
|
|
.xfail(.osxBugFix(10, 9, 2, reason: "")).code {
|
|
expectEqual(1, 1)
|
|
}
|
|
|
|
// CHECK: [ XFAIL ] XFailsOSX.xfail 10.9.3{{$}}
|
|
XFailsOSX.test("xfail 10.9.3")
|
|
.xfail(.osxBugFix(10, 9, 3, reason: "")).code {
|
|
expectEqual(1, 2)
|
|
}
|
|
|
|
// CHECK: [ OK ] XFailsOSX.xfail 10.9.[1-2]{{$}}
|
|
XFailsOSX.test("xfail 10.9.[1-2]")
|
|
.xfail(.osxBugFixRange(10, 9, 1...2, reason: "")).code {
|
|
expectEqual(1, 1)
|
|
}
|
|
|
|
// CHECK: [ XFAIL ] XFailsOSX.xfail 10.9.[3-4]{{$}}
|
|
XFailsOSX.test("xfail 10.9.[3-4]")
|
|
.xfail(.osxBugFixRange(10, 9, 3...4, reason: "")).code {
|
|
expectEqual(1, 2)
|
|
}
|
|
|
|
// CHECK: XFailsOSX: Some tests failed, aborting
|
|
// CHECK: abort()
|
|
|
|
//
|
|
// Check that we pass through stdout and stderr
|
|
//
|
|
|
|
var PassThroughStdoutStderr = TestSuite("PassThroughStdoutStderr")
|
|
|
|
PassThroughStdoutStderr.test("hasNewline") {
|
|
print("stdout first")
|
|
print("stdout second")
|
|
print("stdout third")
|
|
|
|
var stderr = _Stderr()
|
|
print("stderr first", to: &stderr)
|
|
print("stderr second", to: &stderr)
|
|
print("stderr third", to: &stderr)
|
|
}
|
|
// CHECK: [ RUN ] PassThroughStdoutStderr.hasNewline
|
|
// CHECK-DAG: stdout>>> stdout first
|
|
// CHECK-DAG: stdout>>> stdout second
|
|
// CHECK-DAG: stdout>>> stdout third
|
|
// CHECK-DAG: stderr>>> stderr first
|
|
// CHECK-DAG: stderr>>> stderr second
|
|
// CHECK-DAG: stderr>>> stderr third
|
|
// CHECK: [ OK ] PassThroughStdoutStderr.hasNewline
|
|
|
|
PassThroughStdoutStderr.test("noNewline") {
|
|
print("stdout first")
|
|
print("stdout second")
|
|
print("stdout third", terminator: "")
|
|
|
|
var stderr = _Stderr()
|
|
print("stderr first", to: &stderr)
|
|
print("stderr second", to: &stderr)
|
|
print("stderr third", terminator: "", to: &stderr)
|
|
}
|
|
// CHECK: [ RUN ] PassThroughStdoutStderr.noNewline
|
|
// CHECK-DAG: stdout>>> stdout first
|
|
// CHECK-DAG: stdout>>> stdout second
|
|
// CHECK-DAG: stdout>>> stdout third
|
|
// CHECK-DAG: stderr>>> stderr first
|
|
// CHECK-DAG: stderr>>> stderr second
|
|
// CHECK-DAG: stderr>>> stderr third
|
|
// CHECK: [ OK ] PassThroughStdoutStderr.noNewline
|
|
// CHECK: PassThroughStdoutStderr: All tests passed
|
|
|
|
//
|
|
// Test 'setUp' and 'tearDown'
|
|
//
|
|
|
|
var TestSuiteWithSetUp = TestSuite("TestSuiteWithSetUp")
|
|
var TestSuiteWithSetUpTimesCalled = 0
|
|
|
|
TestSuiteWithSetUp.setUp {
|
|
print("setUp")
|
|
if TestSuiteWithSetUpTimesCalled == 1 || TestSuiteWithSetUpTimesCalled == 3 {
|
|
expectEqual(1, 2)
|
|
}
|
|
TestSuiteWithSetUpTimesCalled += 1
|
|
}
|
|
|
|
// CHECK: [ RUN ] TestSuiteWithSetUp.passes
|
|
// CHECK: stdout>>> setUp
|
|
// CHECK: stdout>>> test body
|
|
// CHECK: [ OK ] TestSuiteWithSetUp.passes
|
|
TestSuiteWithSetUp.test("passes") {
|
|
print("test body")
|
|
}
|
|
|
|
// CHECK: [ RUN ] TestSuiteWithSetUp.fails
|
|
// CHECK: stdout>>> setUp
|
|
// CHECK-NEXT: stdout>>> check failed at {{.*}}{{[/\\]}}StdlibUnittest{{[/\\]}}Common.swift, line
|
|
// CHECK: stdout>>> test body
|
|
// CHECK: [ FAIL ] TestSuiteWithSetUp.fails
|
|
TestSuiteWithSetUp.test("fails") {
|
|
print("test body")
|
|
}
|
|
|
|
// CHECK: [ RUN ] TestSuiteWithSetUp.passesFails/parameterized/0
|
|
// CHECK: stdout>>> setUp
|
|
// CHECK: stdout>>> test body
|
|
// CHECK: [ OK ] TestSuiteWithSetUp.passesFails/parameterized/0
|
|
// CHECK: [ RUN ] TestSuiteWithSetUp.passesFails/parameterized/1
|
|
// CHECK: stdout>>> setUp
|
|
// CHECK-NEXT: stdout>>> check failed at {{.*}}{{[/\\]}}StdlibUnittest{{[/\\]}}Common.swift, line
|
|
// CHECK: stdout>>> test body
|
|
// CHECK: [ FAIL ] TestSuiteWithSetUp.passesFails/parameterized/1
|
|
TestSuiteWithSetUp.test("passesFails/parameterized")
|
|
.forEach(in: [1010, 2020]) {
|
|
(parameter) in
|
|
|
|
print("test body")
|
|
}
|
|
|
|
var TestSuiteWithTearDown = TestSuite("TestSuiteWithTearDown")
|
|
var TestSuiteWithTearDownShouldFail = false
|
|
|
|
TestSuiteWithTearDown.tearDown {
|
|
print("tearDown")
|
|
if TestSuiteWithTearDownShouldFail {
|
|
expectEqual(1, 2)
|
|
TestSuiteWithTearDownShouldFail = false
|
|
}
|
|
}
|
|
|
|
// CHECK: [ RUN ] TestSuiteWithTearDown.passes
|
|
// CHECK: stdout>>> test body
|
|
// CHECK: stdout>>> tearDown
|
|
// CHECK: [ OK ] TestSuiteWithTearDown.passes
|
|
TestSuiteWithTearDown.test("passes") {
|
|
print("test body")
|
|
}
|
|
|
|
// CHECK: [ RUN ] TestSuiteWithTearDown.fails
|
|
// CHECK: stdout>>> test body
|
|
// CHECK: stdout>>> tearDown
|
|
// CHECK-NEXT: stdout>>> check failed at {{.*}}{{[/\\]}}StdlibUnittest{{[/\\]}}Common.swift, line
|
|
// CHECK: [ FAIL ] TestSuiteWithTearDown.fails
|
|
TestSuiteWithTearDown.test("fails") {
|
|
print("test body")
|
|
TestSuiteWithTearDownShouldFail = true
|
|
}
|
|
|
|
// CHECK: [ RUN ] TestSuiteWithTearDown.passesFails/parameterized/0
|
|
// CHECK: stdout>>> test body
|
|
// CHECK: stdout>>> tearDown
|
|
// CHECK: [ OK ] TestSuiteWithTearDown.passesFails/parameterized/0
|
|
// CHECK: [ RUN ] TestSuiteWithTearDown.passesFails/parameterized/1
|
|
// CHECK: stdout>>> test body
|
|
// CHECK: stdout>>> tearDown
|
|
// CHECK-NEXT: stdout>>> check failed at {{.*}}{{[/\\]}}StdlibUnittest{{[/\\]}}Common.swift, line
|
|
// CHECK: [ FAIL ] TestSuiteWithTearDown.passesFails/parameterized/1
|
|
TestSuiteWithTearDown.test("passesFails/parameterized")
|
|
.forEach(in: [1010, 2020]) {
|
|
(parameter) in
|
|
|
|
print("test body")
|
|
if parameter != 1010 {
|
|
TestSuiteWithTearDownShouldFail = true
|
|
}
|
|
}
|
|
|
|
//
|
|
// Test assertions
|
|
//
|
|
|
|
var AssertionsTestSuite = TestSuite("Assertions")
|
|
|
|
AssertionsTestSuite.test("expectFailure/Pass") {
|
|
expectFailure {
|
|
expectEqual(1, 2)
|
|
return ()
|
|
}
|
|
}
|
|
// CHECK: [ RUN ] Assertions.expectFailure/Pass
|
|
// CHECK-NEXT: stdout>>> check failed at {{.*}}{{[/\\]}}StdlibUnittest{{[/\\]}}Common.swift, line
|
|
// CHECK: stdout>>> expected: 1 (of type Swift.Int)
|
|
// CHECK: stdout>>> actual: 2 (of type Swift.Int)
|
|
// CHECK: [ OK ] Assertions.expectFailure/Pass
|
|
|
|
AssertionsTestSuite.test("expectFailure/UXPass")
|
|
.xfail(.custom({ true }, reason: "test"))
|
|
.code {
|
|
expectFailure {
|
|
expectEqual(1, 2)
|
|
return ()
|
|
}
|
|
}
|
|
// CHECK: [ RUN ] Assertions.expectFailure/UXPass ({{X}}FAIL: [Custom(reason: test)])
|
|
// CHECK-NEXT: stdout>>> check failed at {{.*}}{{[/\\]}}StdlibUnittest{{[/\\]}}Common.swift, line
|
|
// CHECK: stdout>>> expected: 1 (of type Swift.Int)
|
|
// CHECK: stdout>>> actual: 2 (of type Swift.Int)
|
|
// CHECK: [ UXPASS ] Assertions.expectFailure/UXPass
|
|
|
|
AssertionsTestSuite.test("expectFailure/Fail") {
|
|
expectFailure {
|
|
return ()
|
|
}
|
|
}
|
|
// CHECK: [ RUN ] Assertions.expectFailure/Fail
|
|
// CHECK-NEXT: stdout>>> check failed at {{.*}}{{[/\\]}}StdlibUnittest{{[/\\]}}Common.swift, line
|
|
// CHECK: stdout>>> expected: true
|
|
// CHECK: stdout>>> running `body` should produce an expected failure
|
|
// CHECK: [ FAIL ] Assertions.expectFailure/Fail
|
|
|
|
AssertionsTestSuite.test("expectFailure/XFail")
|
|
.xfail(.custom({ true }, reason: "test"))
|
|
.code {
|
|
expectFailure {
|
|
return ()
|
|
}
|
|
}
|
|
// CHECK: [ RUN ] Assertions.expectFailure/XFail ({{X}}FAIL: [Custom(reason: test)])
|
|
// CHECK-NEXT: stdout>>> check failed at {{.*}}{{[/\\]}}StdlibUnittest{{[/\\]}}Common.swift, line
|
|
// CHECK: stdout>>> expected: true
|
|
// CHECK: stdout>>> running `body` should produce an expected failure
|
|
// CHECK: [ XFAIL ] Assertions.expectFailure/XFail
|
|
|
|
AssertionsTestSuite.test("expectFailure/AfterFailure/Fail") {
|
|
expectEqual(1, 2)
|
|
expectFailure {
|
|
expectEqual(3, 4)
|
|
return ()
|
|
}
|
|
}
|
|
// CHECK: [ RUN ] Assertions.expectFailure/AfterFailure/Fail
|
|
// CHECK-NEXT: stdout>>> check failed at {{.*}}{{[/\\]}}StdlibUnittest{{[/\\]}}Common.swift, line
|
|
// CHECK: stdout>>> expected: 1 (of type Swift.Int)
|
|
// CHECK: stdout>>> actual: 2 (of type Swift.Int)
|
|
// CHECK: stdout>>> check failed at {{.*}}{{[/\\]}}StdlibUnittest{{[/\\]}}Common.swift, line
|
|
// CHECK: stdout>>> expected: 3 (of type Swift.Int)
|
|
// CHECK: stdout>>> actual: 4 (of type Swift.Int)
|
|
// CHECK: [ FAIL ] Assertions.expectFailure/AfterFailure/Fail
|
|
|
|
AssertionsTestSuite.test("expectFailure/AfterFailure/XFail")
|
|
.xfail(.custom({ true }, reason: "test"))
|
|
.code {
|
|
expectEqual(1, 2)
|
|
expectFailure {
|
|
expectEqual(3, 4)
|
|
return ()
|
|
}
|
|
}
|
|
// CHECK: [ RUN ] Assertions.expectFailure/AfterFailure/XFail ({{X}}FAIL: [Custom(reason: test)])
|
|
// CHECK-NEXT: stdout>>> check failed at {{.*}}{{[/\\]}}StdlibUnittest{{[/\\]}}Common.swift, line
|
|
// CHECK: stdout>>> expected: 1 (of type Swift.Int)
|
|
// CHECK: stdout>>> actual: 2 (of type Swift.Int)
|
|
// CHECK: stdout>>> check failed at {{.*}}{{[/\\]}}StdlibUnittest{{[/\\]}}Common.swift, line
|
|
// CHECK: stdout>>> expected: 3 (of type Swift.Int)
|
|
// CHECK: stdout>>> actual: 4 (of type Swift.Int)
|
|
// CHECK: [ XFAIL ] Assertions.expectFailure/AfterFailure/XFail
|
|
|
|
AssertionsTestSuite.test("expectUnreachable") {
|
|
expectUnreachable()
|
|
}
|
|
// CHECK: [ RUN ] Assertions.expectUnreachable
|
|
// CHECK-NEXT: stdout>>> check failed at {{.*}}{{[/\\]}}StdlibUnittest{{[/\\]}}Common.swift, line
|
|
// CHECK: stdout>>> this code should not be executed
|
|
// CHECK: [ FAIL ] Assertions.expectUnreachable
|
|
|
|
AssertionsTestSuite.test("expectCrashLater/Pass") {
|
|
let array: [Int] = _opaqueIdentity([])
|
|
expectCrashLater()
|
|
_blackHole(array[0])
|
|
}
|
|
// CHECK: [ RUN ] Assertions.expectCrashLater/Pass
|
|
// CHECK: stderr>>> OK: saw expected "crashed: sig{{.*}}
|
|
// CHECK: [ OK ] Assertions.expectCrashLater/Pass
|
|
|
|
AssertionsTestSuite.test("expectCrashLater/UXPass")
|
|
.xfail(.custom({ true }, reason: "test"))
|
|
.code {
|
|
let array: [Int] = _opaqueIdentity([])
|
|
expectCrashLater()
|
|
_blackHole(array[0])
|
|
}
|
|
// CHECK: [ RUN ] Assertions.expectCrashLater/UXPass ({{X}}FAIL: [Custom(reason: test)])
|
|
// CHECK: stderr>>> OK: saw expected "crashed: sig{{.*}}
|
|
// CHECK: [ UXPASS ] Assertions.expectCrashLater/UXPass
|
|
|
|
AssertionsTestSuite.test("expectCrashLater/Fail") {
|
|
expectCrashLater()
|
|
}
|
|
// CHECK: [ RUN ] Assertions.expectCrashLater/Fail
|
|
// CHECK: expecting a crash, but the test did not crash
|
|
// CHECK: [ FAIL ] Assertions.expectCrashLater/Fail
|
|
|
|
AssertionsTestSuite.test("expectCrashLater/XFail")
|
|
.xfail(.custom({ true }, reason: "test"))
|
|
.code {
|
|
expectCrashLater()
|
|
}
|
|
// CHECK: [ RUN ] Assertions.expectCrashLater/XFail ({{X}}FAIL: [Custom(reason: test)])
|
|
// CHECK: expecting a crash, but the test did not crash
|
|
// CHECK: [ XFAIL ] Assertions.expectCrashLater/XFail
|
|
|
|
AssertionsTestSuite.test("UnexpectedCrash/RuntimeTrap") {
|
|
let array: [Int] = _opaqueIdentity([])
|
|
_blackHole(array[0])
|
|
}
|
|
// CHECK: [ RUN ] Assertions.UnexpectedCrash/RuntimeTrap
|
|
// CHECK: stderr>>> CRASHED: SIG
|
|
// CHECK: the test crashed unexpectedly
|
|
// CHECK: [ FAIL ] Assertions.UnexpectedCrash/RuntimeTrap
|
|
|
|
AssertionsTestSuite.test("UnexpectedCrash/NullPointerDereference") {
|
|
let nilValue: UnsafePointer<Int>? = nil
|
|
let ptr: UnsafePointer<Int> =
|
|
_opaqueIdentity(unsafeBitCast(nilValue, to: UnsafePointer.self))
|
|
_blackHole(ptr.pointee)
|
|
}
|
|
// CHECK: [ RUN ] Assertions.UnexpectedCrash/NullPointerDereference
|
|
// CHECK: stderr>>> CRASHED: SIG
|
|
// CHECK: the test crashed unexpectedly
|
|
// CHECK: [ FAIL ] Assertions.UnexpectedCrash/NullPointerDereference
|
|
|
|
AssertionsTestSuite.test("expectTrapping(_: Bound, in: RangeProtocol)") {
|
|
expectTrapping(0, in: 1..<10)
|
|
}
|
|
// CHECK: [ RUN ] Assertions.expectTrapping(_: Bound, in: RangeProtocol)
|
|
// stderr>>> CRASHED: SIGABRT
|
|
// CHECK: stdout>>> check failed at {{.*}}.swift, line [[@LINE-4]]
|
|
// CHECK: stdout>>> 0 in 1..<10{{$}}
|
|
// CHECK: the test crashed unexpectedly
|
|
// CHECK: [ FAIL ] Assertions.expectTrapping(_: Bound, in: RangeProtocol)
|
|
|
|
AssertionsTestSuite.test("expectTrapping(_: RangeProtocol, in: RangeProtocol)") {
|
|
expectTrapping(0..<5, in: 1..<10)
|
|
}
|
|
// CHECK: [ RUN ] Assertions.expectTrapping(_: RangeProtocol, in: RangeProtocol)
|
|
// stderr>>> CRASHED: SIGABRT
|
|
// CHECK: stdout>>> check failed at {{.*}}.swift, line [[@LINE-4]]
|
|
// CHECK: stdout>>> 0..<5 in 1..<10{{$}}
|
|
// CHECK: the test crashed unexpectedly
|
|
// CHECK: [ FAIL ] Assertions.expectTrapping(_: RangeProtocol, in: RangeProtocol)
|
|
|
|
var TestSuiteLifetimeTracked = TestSuite("TestSuiteLifetimeTracked")
|
|
var leakMe: LifetimeTracked? = nil
|
|
TestSuiteLifetimeTracked.test("failsIfLifetimeTrackedAreLeaked") {
|
|
leakMe = LifetimeTracked(0)
|
|
}
|
|
// CHECK: [ RUN ] TestSuiteLifetimeTracked.failsIfLifetimeTrackedAreLeaked
|
|
// CHECK-NEXT: stdout>>> check failed at {{.*}}.swift, line [[@LINE-4]]
|
|
// CHECK: stdout>>> expected: 0 (of type Swift.Int)
|
|
// CHECK: stdout>>> actual: 1 (of type Swift.Int)
|
|
// CHECK: [ FAIL ] TestSuiteLifetimeTracked.failsIfLifetimeTrackedAreLeaked
|
|
|
|
TestSuiteLifetimeTracked.test("passesIfLifetimeTrackedAreResetAfterFailure") {}
|
|
// CHECK: [ RUN ] TestSuiteLifetimeTracked.passesIfLifetimeTrackedAreResetAfterFailure
|
|
// CHECK: [ OK ] TestSuiteLifetimeTracked.passesIfLifetimeTrackedAreResetAfterFailure
|
|
|
|
runAllTests()
|
|
|