Adding toNever expectation

Author: Rodrigo Kreutz

Sources/Nimble/Matchers/Async.swift

@@ -48,6 +48,43 @@ private func async<T>(style: ExpectationStyle, predicate: Predicate<T>, timeout:
     }
 }
 
+private func toNeverPredicate<T>(predicate: Predicate<T>, timeout: DispatchTimeInterval, poll: DispatchTimeInterval, fnName: String) -> Predicate<T> {
+    return Predicate { actualExpression in
+        let uncachedExpression = actualExpression.withoutCaching()
+        let fnName = "expect(...).\(fnName)(...)"
+        var lastPredicateResult: PredicateResult?
+        let result = pollBlock(
+            pollInterval: poll,
+            timeoutInterval: timeout,
+            file: actualExpression.location.file,
+            line: actualExpression.location.line,
+            fnName: fnName) {
+                lastPredicateResult = try predicate.satisfies(uncachedExpression)
+                return lastPredicateResult!.toBoolean(expectation: .toMatch)
+        }
+        switch result {
+            case .completed:
+                return PredicateResult(
+                    status: .fail,
+                    message: lastPredicateResult?.message ?? .fail("matched the predicate when it shouldn't have")
+                )
+            case .timedOut:
+                return PredicateResult(status: .doesNotMatch, message: .expectedTo("never match the predicate"))
+            case let .errorThrown(error):
+                return PredicateResult(status: .fail, message: .fail("unexpected error thrown: <\(error)>"))
+            case let .raisedException(exception):
+                return PredicateResult(status: .fail, message: .fail("unexpected exception raised: \(exception)"))
+            case .blockedRunLoop:
+                // swiftlint:disable:next line_length
+                let message = lastPredicateResult?.message.appended(message: " (timed out, but main run loop was unresponsive).") ??
+                    .fail("main run loop was unresponsive")
+                return PredicateResult(status: .fail, message: message)
+            case .incomplete:
+                internalError("Reached .incomplete state for \(fnName)(...).")
+        }
+    }
+}
+
 private let toEventuallyRequiresClosureError = FailureMessage(
     stringValue: """
         expect(...).toEventually(...) requires an explicit closure (eg - expect { ... }.toEventually(...) )
@@ -113,4 +150,23 @@ extension Expectation {
     public func toNotEventually(_ predicate: Predicate<T>, timeout: DispatchTimeInterval = AsyncDefaults.timeout, pollInterval: DispatchTimeInterval = AsyncDefaults.pollInterval, description: String? = nil) {
         return toEventuallyNot(predicate, timeout: timeout, pollInterval: pollInterval, description: description)
     }
+
+    public func toNever(_ predicate: Predicate<T>, until: DispatchTimeInterval = AsyncDefaults.timeout, pollInterval: DispatchTimeInterval = AsyncDefaults.pollInterval, description: String? = nil) {
+        nimblePrecondition(expression.isClosure, "NimbleInternalError", toEventuallyRequiresClosureError.stringValue)
+
+
+        let (pass, msg) = execute(
+            expression,
+            .toNotMatch,
+            toNeverPredicate(predicate: predicate, timeout: until, poll: pollInterval, fnName: "toNever"),
+            to: "to never",
+            description: description,
+            captureExceptions: false
+        )
+        verify(pass, msg)
+    }
+
+    public func neverTo(_ predicate: Predicate<T>, until: DispatchTimeInterval = AsyncDefaults.timeout, pollInterval: DispatchTimeInterval = AsyncDefaults.pollInterval, description: String? = nil) {
+        return toNever(predicate, until: until, pollInterval: pollInterval, description: description)
+    }
 }

Tests/NimbleTests/AsynchronousTest.swift

@@ -250,4 +250,38 @@ final class AsyncTest: XCTestCase {
         }
     }
 
+    func testToNeverPositiveMatches() {
+
+        var value = 0
+        deferToMainQueue { value = 1 }
+        expect { value }.toNever(beGreaterThan(1))
+
+        deferToMainQueue { value = 0 }
+        expect { value }.neverTo(beGreaterThan(1))
+    }
+
+    func testToNeverNegativeMatches() {
+
+        var value = 0
+        failsWithErrorMessage("expected to never equal <0>, got <0>") {
+            expect { value }.toNever(equal(0))
+        }
+        failsWithErrorMessage("expected to never equal <0>, got <0>") {
+            expect { value }.neverTo(equal(0))
+        }
+        failsWithErrorMessage("expected to never equal <1>, got <1>") {
+            deferToMainQueue { value = 1 }
+            expect { value }.toNever(equal(1))
+        }
+        failsWithErrorMessage("expected to never equal <1>, got <1>") {
+            deferToMainQueue { value = 1 }
+            expect { value }.neverTo(equal(1))
+        }
+        failsWithErrorMessage("unexpected error thrown: <\(errorToThrow)>") {
+            expect { try self.doThrowError() }.toNever(equal(0))
+        }
+        failsWithErrorMessage("unexpected error thrown: <\(errorToThrow)>") {
+            expect { try self.doThrowError() }.neverTo(equal(0))
+        }
+    }
 }