| // RUN: %target-run-simple-swiftgyb |
| // REQUIRES: executable_test |
| |
| import StdlibUnittest |
| |
| // Also import modules which are used by StdlibUnittest internally. This |
| // workaround is needed to link all required libraries in case we compile |
| // StdlibUnittest with -sil-serialize-all. |
| import SwiftPrivate |
| #if _runtime(_ObjC) |
| import ObjectiveC |
| #endif |
| |
| var AssertionsTestSuite = TestSuite("Assertions") |
| |
| AssertionsTestSuite.test("expectNil(_: T?)") { |
| let none: OpaqueValue<Int>? = nil |
| expectNil(none) |
| |
| let some: OpaqueValue<Int>? = OpaqueValue(42) |
| expectFailure { |
| expectNil(some) |
| } |
| } |
| |
| AssertionsTestSuite.test("expectNotNil(_: T?)") { |
| let none: OpaqueValue<Int>? = nil |
| expectFailure { |
| expectNotNil(none) |
| } |
| |
| let some: OpaqueValue<Int>? = OpaqueValue(42) |
| expectNotNil(some) |
| } |
| |
| AssertionsTestSuite.test("expectTrapping(_: Bound, in: RangeProtocol)") { |
| _setTrappingExpectationFailedCallback() {} |
| defer { |
| // Reset the callback. |
| expectCrashLater() |
| fatalError() |
| } |
| |
| % for (Element, Range, ClosedRange) in [ |
| % ('MinimalComparableValue', 'Range', 'ClosedRange'), |
| % ('MinimalStrideableValue', 'CountableRange', 'CountableClosedRange'), |
| % ]: |
| do { |
| let _0 = ${Element}(0) |
| let _1 = ${Element}(1) |
| let _9 = ${Element}(9) |
| let _10 = ${Element}(10) |
| |
| expectTrapping(_0, in: _0..<_10 as ${Range}) |
| expectTrapping(_9, in: _0..<_10 as ${Range}) |
| expectFailure { |
| expectTrapping(_0, in: _1..<_10 as ${Range}) |
| } |
| expectFailure { |
| expectTrapping(_10, in: _1..<_10 as ${Range}) |
| } |
| |
| expectTrapping(_0, in: _0..._9 as ${ClosedRange}) |
| expectTrapping(_9, in: _0..._9 as ${ClosedRange}) |
| expectFailure { |
| expectTrapping(_0, in: _1..._9 as ${ClosedRange}) |
| } |
| expectFailure { |
| expectTrapping(_10, in: _1..._9 as ${ClosedRange}) |
| } |
| } |
| % end |
| } |
| |
| AssertionsTestSuite.test("expectTrapping(_: RangeProtocol, in: RangeProtocol)") { |
| _setTrappingExpectationFailedCallback() {} |
| defer { |
| // Reset the callback. |
| expectCrashLater() |
| fatalError() |
| } |
| |
| % for (Element, Range, ClosedRange) in [ |
| % ('MinimalComparableValue', 'Range', 'ClosedRange'), |
| % ('MinimalStrideableValue', 'CountableRange', 'CountableClosedRange'), |
| % ]: |
| do { |
| let _0 = ${Element}(0) |
| let _1 = ${Element}(1) |
| let _9 = ${Element}(9) |
| let _10 = ${Element}(10) |
| let _11 = ${Element}(11) |
| |
| expectTrapping(_0..<_10 as Range, in: _0..<_10 as Range) |
| expectTrapping(_0..<_9 as Range, in: _0..<_10 as Range) |
| expectTrapping(_1..<_10 as Range, in: _0..<_10 as Range) |
| |
| expectFailure { |
| expectTrapping(_0..<_10 as Range, in: _1..<_10 as Range) |
| } |
| expectFailure { |
| expectTrapping(_0..<_10 as Range, in: _0..<_9 as Range) |
| } |
| expectFailure { |
| expectTrapping(_0..<_10 as Range, in: _1..<_9 as Range) |
| } |
| |
| expectTrapping(_0..._10 as ClosedRange, in: _0..<_11 as Range) |
| expectTrapping(_0..._10 as ClosedRange, in: _0..._10 as ClosedRange) |
| expectTrapping(_0..._9 as ClosedRange, in: _0..<_10 as Range) |
| expectTrapping(_0..._9 as ClosedRange, in: _0..._10 as ClosedRange) |
| expectTrapping(_1..._10 as ClosedRange, in: _0..<_11 as Range) |
| expectTrapping(_1..._10 as ClosedRange, in: _0..._10 as ClosedRange) |
| |
| expectFailure { |
| expectTrapping(_0..._10 as ClosedRange, in: _1..._10 as ClosedRange) |
| } |
| expectFailure { |
| expectTrapping(_0..._10 as ClosedRange, in: _1..<_11 as Range) |
| } |
| expectFailure { |
| expectTrapping(_0..._10 as ClosedRange, in: _0..._9 as ClosedRange) |
| } |
| expectFailure { |
| expectTrapping(_0..._10 as ClosedRange, in: _0..<_10 as Range) |
| } |
| expectFailure { |
| expectTrapping(_0..._10 as ClosedRange, in: _1..._9 as ClosedRange) |
| } |
| expectFailure { |
| expectTrapping(_0..._10 as ClosedRange, in: _1..<_10 as Range) |
| } |
| } |
| % end |
| } |
| |
| AssertionsTestSuite.test("expectEqualsUnordered(Range<T>, [T])") { |
| % for Range in ['Range', 'CountableRange']: |
| expectEqualsUnordered(0..<0 as ${Range}, []) |
| expectFailure { |
| expectEqualsUnordered(0..<0 as ${Range}, [ 0 ]) |
| } |
| |
| expectEqualsUnordered(0..<1 as ${Range}, [ 0 ]) |
| expectFailure { |
| expectEqualsUnordered(0..<1 as ${Range}, []) |
| expectEqualsUnordered(0..<1 as ${Range}, [ 1 ]) |
| } |
| |
| expectEqualsUnordered(0..<2 as ${Range}, [ 0, 1 ]) |
| expectEqualsUnordered(0..<2 as ${Range}, [ 1, 0 ]) |
| expectFailure { |
| expectEqualsUnordered(0..<2 as ${Range}, []) |
| expectEqualsUnordered(0..<2 as ${Range}, [ 0 ]) |
| expectEqualsUnordered(0..<2 as ${Range}, [ 1 ]) |
| expectEqualsUnordered(0..<2 as ${Range}, [ 0, 2 ]) |
| expectEqualsUnordered(0..<2 as ${Range}, [ 2, 0 ]) |
| } |
| |
| expectEqualsUnordered(0..<3 as ${Range}, [ 0, 1, 2 ]) |
| expectEqualsUnordered(0..<3 as ${Range}, [ 0, 2, 1 ]) |
| expectEqualsUnordered(0..<3 as ${Range}, [ 1, 0, 2 ]) |
| expectEqualsUnordered(0..<3 as ${Range}, [ 1, 2, 0 ]) |
| expectEqualsUnordered(0..<3 as ${Range}, [ 2, 0, 1 ]) |
| expectEqualsUnordered(0..<3 as ${Range}, [ 2, 1, 0 ]) |
| expectFailure { |
| expectEqualsUnordered(0..<3 as ${Range}, []) |
| expectEqualsUnordered(0..<3 as ${Range}, [ 0 ]) |
| expectEqualsUnordered(0..<3 as ${Range}, [ 1 ]) |
| expectEqualsUnordered(0..<3 as ${Range}, [ 0, 1 ]) |
| expectEqualsUnordered(0..<3 as ${Range}, [ 1, 0 ]) |
| expectEqualsUnordered(0..<3 as ${Range}, [ 3, 0, 1 ]) |
| expectEqualsUnordered(0..<3 as ${Range}, [ 0, 3, 1 ]) |
| expectEqualsUnordered(0..<3 as ${Range}, [ 0, 1, 3 ]) |
| } |
| |
| % end |
| } |
| |
| AssertionsTestSuite.test("expectEqual<T : Equatable>") { |
| let _0 = MinimalEquatableValue(0) |
| let _1 = MinimalEquatableValue(1) |
| |
| expectEqual(_0, _0) |
| expectEqual(_1, _1) |
| expectFailure { |
| expectEqual(_0, _1) |
| expectEqual(_1, _0) |
| } |
| } |
| |
| AssertionsTestSuite.test("expectEqual<T : Equatable, U : Equatable>") { |
| let _0 = MinimalEquatableValue(0) |
| let _1 = MinimalEquatableValue(1) |
| |
| for a in [_0, _1] { |
| for b in [_0, _1] { |
| for c in [_0, _1] { |
| for d in [_0, _1] { |
| let lhs = (a, b) |
| let rhs = (c, d) |
| if lhs == rhs { |
| expectEqual(lhs, rhs) |
| } else { |
| expectFailure { |
| expectEqual(lhs, rhs) |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| AssertionsTestSuite.test("expectEqual<T : Equatable, U : Equatable, V : Equatable>") { |
| let _0 = MinimalEquatableValue(0) |
| let _1 = MinimalEquatableValue(1) |
| |
| for a in [_0, _1] { |
| for b in [_0, _1] { |
| for c in [_0, _1] { |
| for d in [_0, _1] { |
| for e in [_0, _1] { |
| for f in [_0, _1] { |
| let lhs = (a, b, c) |
| let rhs = (d, e, f) |
| if lhs == rhs { |
| expectEqual(lhs, rhs) |
| } else { |
| expectFailure { |
| expectEqual(lhs, rhs) |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| AssertionsTestSuite.test("expectEqual<T : Equatable, U : Equatable, V : Equatable, W : Equatable>") { |
| let _0 = MinimalEquatableValue(0) |
| let _1 = MinimalEquatableValue(1) |
| |
| for a in [_0, _1] { |
| for b in [_0, _1] { |
| for c in [_0, _1] { |
| for d in [_0, _1] { |
| for e in [_0, _1] { |
| for f in [_0, _1] { |
| for g in [_0, _1] { |
| for h in [_0, _1] { |
| let lhs = (a, b, c, d) |
| let rhs = (e, f, g, h) |
| if lhs == rhs { |
| expectEqual(lhs, rhs) |
| } else { |
| expectFailure { |
| expectEqual(lhs, rhs) |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| AssertionsTestSuite.test("expectEqual(_: Any.Type, _: Any.Type)") { |
| expectEqual(Int.self, Int.self) |
| expectFailure { |
| expectEqual(Int.self, Double.self) |
| } |
| |
| class B {} |
| class D : B {} |
| expectEqual(B.self, B.self) |
| expectFailure { |
| expectEqual(B.self, D.self) |
| } |
| expectFailure { |
| expectEqual(D.self, B.self) |
| } |
| expectEqual(D.self, D.self) |
| } |
| |
| runAllTests() |
| |