How to use testAllPassMatcher method of AllPassTest class

1import XCTest
2import Nimble
3
4/// Add operators to `Optional` for conforming `Comparable` that removed in Swift 3.0
5extension Optional where Wrapped: Comparable {
6    static func < (lhs: Optional, rhs: Optional) -> Bool {
7        switch (lhs, rhs) {
8        case let (l?, r?):
9            return l < r
10        case (nil, _?):
11            return true
12        default:
13            return false
14        }
15    }
16
17    static func > (lhs: Optional, rhs: Optional) -> Bool {
18        switch (lhs, rhs) {
19        case let (l?, r?):
20            return l > r
21        default:
22            return rhs < lhs
23        }
24    }
25
26    static func <= (lhs: Optional, rhs: Optional) -> Bool {
27        switch (lhs, rhs) {
28        case let (l?, r?):
29            return l <= r
30        default:
31            return !(rhs < lhs)
32        }
33    }
34
35    static func >= (lhs: Optional, rhs: Optional) -> Bool {
36        switch (lhs, rhs) {
37        case let (l?, r?):
38            return l >= r
39        default:
40            return !(lhs < rhs)
41        }
42    }
43}
44
45final class AllPassTest: XCTestCase, XCTestCaseProvider {
46    static var allTests: [(String, (AllPassTest) -> () throws -> Void)] {
47        return [
48            ("testAllPassArray", testAllPassArray),
49            ("testAllPassMatcher", testAllPassMatcher),
50            ("testAllPassCollectionsWithOptionalsDontWork", testAllPassCollectionsWithOptionalsDontWork),
51            ("testAllPassCollectionsWithOptionalsUnwrappingOneOptionalLayer", testAllPassCollectionsWithOptionalsUnwrappingOneOptionalLayer),
52            ("testAllPassSet", testAllPassSet),
53            ("testAllPassWithNilAsExpectedValue", testAllPassWithNilAsExpectedValue),
54        ]
55    }
56
57    func testAllPassArray() {
58        expect([1,2,3,4]).to(allPass({$0 < 5}))
59        expect([1,2,3,4]).toNot(allPass({$0 > 5}))
60
61        failsWithErrorMessage(
62            "expected to all pass a condition, but failed first at element <3> in <[1, 2, 3, 4]>") {
63                expect([1,2,3,4]).to(allPass({$0 < 3}))
64        }
65        failsWithErrorMessage("expected to not all pass a condition") {
66            expect([1,2,3,4]).toNot(allPass({$0 < 5}))
67        }
68        failsWithErrorMessage(
69            "expected to all be something, but failed first at element <3> in <[1, 2, 3, 4]>") {
70                expect([1,2,3,4]).to(allPass("be something", {$0 < 3}))
71        }
72        failsWithErrorMessage("expected to not all be something") {
73            expect([1,2,3,4]).toNot(allPass("be something", {$0 < 5}))
74        }
75    }
76
77    func testAllPassMatcher() {
78        expect([1,2,3,4]).to(allPass(beLessThan(5)))
79        expect([1,2,3,4]).toNot(allPass(beGreaterThan(5)))
80        
81        failsWithErrorMessage(
82            "expected to all be less than <3>, but failed first at element <3> in <[1, 2, 3, 4]>") {
83                expect([1,2,3,4]).to(allPass(beLessThan(3)))
84        }
85        failsWithErrorMessage("expected to not all be less than <5>") {
86            expect([1,2,3,4]).toNot(allPass(beLessThan(5)))
87        }
88    }
89
90    func testAllPassCollectionsWithOptionalsDontWork() {
91        failsWithErrorMessage("expected to all be nil, but failed first at element <nil> in <[nil, nil, nil]>") {
92            expect([nil, nil, nil] as [Int?]).to(allPass(beNil()))
93        }
94        failsWithErrorMessage("expected to all pass a condition, but failed first at element <nil> in <[nil, nil, nil]>") {
95            expect([nil, nil, nil] as [Int?]).to(allPass({$0 == nil}))
96        }
97    }
98
99    func testAllPassCollectionsWithOptionalsUnwrappingOneOptionalLayer() {
100        expect([nil, nil, nil] as [Int?]).to(allPass({$0! == nil}))
101        expect([nil, 1, nil] as [Int?]).toNot(allPass({$0! == nil}))
102        expect([1, 1, 1] as [Int?]).to(allPass({$0! == 1}))
103        expect([1, 1, nil] as [Int?]).toNot(allPass({$0! == 1}))
104        expect([1, 2, 3] as [Int?]).to(allPass({$0! < 4}))
105        expect([1, 2, 3] as [Int?]).toNot(allPass({$0! < 3}))
106        expect([1, 2, nil] as [Int?]).to(allPass({$0! < 3}))
107    }
108
109    func testAllPassSet() {
110        expect(Set([1,2,3,4])).to(allPass({$0 < 5}))
111        expect(Set([1,2,3,4])).toNot(allPass({$0 > 5}))
112
113        failsWithErrorMessage("expected to not all pass a condition") {
114            expect(Set([1,2,3,4])).toNot(allPass({$0 < 5}))
115        }
116        failsWithErrorMessage("expected to not all be something") {
117            expect(Set([1,2,3,4])).toNot(allPass("be something", {$0 < 5}))
118        }
119    }
120
121    func testAllPassWithNilAsExpectedValue() {
122        failsWithErrorMessageForNil("expected to all pass") {
123            expect(nil as [Int]?).to(allPass(beLessThan(5)))
124        }
125    }
126}
127

Source: AllPassTest.swift

import XCTest
import Nimble

/// Add operators to `Optional` for conforming `Comparable` that removed in Swift 3.0
extension Optional where Wrapped: Comparable {
    static func < (lhs: Optional, rhs: Optional) -> Bool {
        switch (lhs, rhs) {
        case let (l?, r?):
            return l < r
        case (nil, _?):
            return true
        default:
            return false
        }
    }

    static func > (lhs: Optional, rhs: Optional) -> Bool {
        switch (lhs, rhs) {
        case let (l?, r?):
            return l > r
        default:
            return rhs < lhs
        }
    }

    static func <= (lhs: Optional, rhs: Optional) -> Bool {
        switch (lhs, rhs) {
        case let (l?, r?):
            return l <= r
        default:
            return !(rhs < lhs)
        }
    }

    static func >= (lhs: Optional, rhs: Optional) -> Bool {
        switch (lhs, rhs) {
        case let (l?, r?):
            return l >= r
        default:
            return !(lhs < rhs)
        }
    }
}

final class AllPassTest: XCTestCase, XCTestCaseProvider {
    static var allTests: [(String, (AllPassTest) -> () throws -> Void)] {
        return [
            ("testAllPassArray", testAllPassArray),
            ("testAllPassMatcher", testAllPassMatcher),
            ("testAllPassCollectionsWithOptionalsDontWork", testAllPassCollectionsWithOptionalsDontWork),
            ("testAllPassCollectionsWithOptionalsUnwrappingOneOptionalLayer", testAllPassCollectionsWithOptionalsUnwrappingOneOptionalLayer),
            ("testAllPassSet", testAllPassSet),
            ("testAllPassWithNilAsExpectedValue", testAllPassWithNilAsExpectedValue),
        ]
    }

    func testAllPassArray() {
        expect([1,2,3,4]).to(allPass({$0 < 5}))
        expect([1,2,3,4]).toNot(allPass({$0 > 5}))

        failsWithErrorMessage(
            "expected to all pass a condition, but failed first at element <3> in <[1, 2, 3, 4]>") {
                expect([1,2,3,4]).to(allPass({$0 < 3}))
        }
        failsWithErrorMessage("expected to not all pass a condition") {
            expect([1,2,3,4]).toNot(allPass({$0 < 5}))
        }
        failsWithErrorMessage(
            "expected to all be something, but failed first at element <3> in <[1, 2, 3, 4]>") {
                expect([1,2,3,4]).to(allPass("be something", {$0 < 3}))
        }
        failsWithErrorMessage("expected to not all be something") {
            expect([1,2,3,4]).toNot(allPass("be something", {$0 < 5}))
        }
    }

    func testAllPassMatcher() {
        expect([1,2,3,4]).to(allPass(beLessThan(5)))
        expect([1,2,3,4]).toNot(allPass(beGreaterThan(5)))
        
        failsWithErrorMessage(
            "expected to all be less than <3>, but failed first at element <3> in <[1, 2, 3, 4]>") {
                expect([1,2,3,4]).to(allPass(beLessThan(3)))
        }
        failsWithErrorMessage("expected to not all be less than <5>") {
            expect([1,2,3,4]).toNot(allPass(beLessThan(5)))
        }
    }

    func testAllPassCollectionsWithOptionalsDontWork() {
        failsWithErrorMessage("expected to all be nil, but failed first at element <nil> in <[nil, nil, nil]>") {
            expect([nil, nil, nil] as [Int?]).to(allPass(beNil()))
        }
        failsWithErrorMessage("expected to all pass a condition, but failed first at element <nil> in <[nil, nil, nil]>") {
            expect([nil, nil, nil] as [Int?]).to(allPass({$0 == nil}))
        }
    }

    func testAllPassCollectionsWithOptionalsUnwrappingOneOptionalLayer() {
        expect([nil, nil, nil] as [Int?]).to(allPass({$0! == nil}))
        expect([nil, 1, nil] as [Int?]).toNot(allPass({$0! == nil}))
        expect([1, 1, 1] as [Int?]).to(allPass({$0! == 1}))
        expect([1, 1, nil] as [Int?]).toNot(allPass({$0! == 1}))
        expect([1, 2, 3] as [Int?]).to(allPass({$0! < 4}))
        expect([1, 2, 3] as [Int?]).toNot(allPass({$0! < 3}))
        expect([1, 2, nil] as [Int?]).to(allPass({$0! < 3}))
    }

    func testAllPassSet() {
        expect(Set([1,2,3,4])).to(allPass({$0 < 5}))
        expect(Set([1,2,3,4])).toNot(allPass({$0 > 5}))

        failsWithErrorMessage("expected to not all pass a condition") {
            expect(Set([1,2,3,4])).toNot(allPass({$0 < 5}))
        }
        failsWithErrorMessage("expected to not all be something") {
            expect(Set([1,2,3,4])).toNot(allPass("be something", {$0 < 5}))
        }
    }

    func testAllPassWithNilAsExpectedValue() {
        failsWithErrorMessageForNil("expected to all pass") {
            expect(nil as [Int]?).to(allPass(beLessThan(5)))
        }
    }
}