Merge pull request #895 from Quick/allpass-passfunc-nonnull-arg

[BREAKING] `passFunc` of `allPass` matcher now takes `S.Element` over `S.Element?`

Author: ikesyo

README.md

@@ -1112,7 +1112,7 @@ In Swift, the collection must be an instance of a type conforming to
 // Swift
 
 // Providing a custom function:
-expect([1, 2, 3, 4]).to(allPass { $0! < 5 })
+expect([1, 2, 3, 4]).to(allPass { $0 < 5 })
 
 // Composing the expectation with another matcher:
 expect([1, 2, 3, 4]).to(allPass(beLessThan(5)))

Sources/Nimble/Matchers/AllPass.swift

@@ -1,18 +1,24 @@
 public func allPass<S: Sequence>(
-    _ passFunc: @escaping (S.Element?) throws -> Bool
+    _ passFunc: @escaping (S.Element) throws -> Bool
 ) -> Predicate<S> {
-    let matcher = Predicate.simpleNilable("pass a condition") { actualExpression in
-        return PredicateStatus(bool: try passFunc(try actualExpression.evaluate()))
+    let matcher = Predicate<S.Element>.define("pass a condition") { actualExpression, message in
+        guard let actual = try actualExpression.evaluate() else {
+            return PredicateResult(status: .fail, message: message)
+        }
+        return PredicateResult(bool: try passFunc(actual), message: message)
     }
     return createPredicate(matcher)
 }
 
 public func allPass<S: Sequence>(
     _ passName: String,
-    _ passFunc: @escaping (S.Element?) throws -> Bool
+    _ passFunc: @escaping (S.Element) throws -> Bool
 ) -> Predicate<S> {
-    let matcher = Predicate.simpleNilable(passName) { actualExpression in
-        return PredicateStatus(bool: try passFunc(try actualExpression.evaluate()))
+    let matcher = Predicate<S.Element>.define(passName) { actualExpression, message in
+        guard let actual = try actualExpression.evaluate() else {
+            return PredicateResult(status: .fail, message: message)
+        }
+        return PredicateResult(bool: try passFunc(actual), message: message)
     }
     return createPredicate(matcher)
 }
@@ -33,7 +39,9 @@ private func createPredicate<S: Sequence>(_ elementMatcher: Predicate<S.Element>
         var failure: ExpectationMessage = .expectedTo("all pass")
         for currentElement in actualValue {
             let exp = Expression(
-                expression: {currentElement}, location: actualExpression.location)
+                expression: { currentElement },
+                location: actualExpression.location
+            )
             let predicateResult = try elementMatcher.satisfies(exp)
             if predicateResult.status == .matches {
                 failure = predicateResult.message.prepended(expectation: "all ")

Tests/NimbleTests/Matchers/AllPassTest.swift

@@ -44,15 +44,15 @@ extension Optional where Wrapped: Comparable {
 
 final class AllPassTest: XCTestCase {
     func testAllPassArray() {
-        expect([1, 2, 3, 4]).to(allPass({$0 < 5}))
-        expect([1, 2, 3, 4]).toNot(allPass({$0 > 5}))
+        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}))
+                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}))
+            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]>") {
@@ -78,31 +78,24 @@ final class AllPassTest: XCTestCase {
 
     func testAllPassCollectionsWithOptionals() {
         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}))
+        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}))
+        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}))
+            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}))
+            expect(Set([1, 2, 3, 4])).toNot(allPass("be something") { $0 < 5 })
         }
     }