[BREAKING] Make throwAssertion and throwError matchers generic and usable with non-void closures

Sources/Nimble/Matchers/ThrowAssertion.swift

@@ -6,7 +6,7 @@ import CwlPreconditionTesting
 import CwlPosixPreconditionTesting
 #endif
 
-public func throwAssertion() -> Predicate<Void> {
+public func throwAssertion<Out>() -> Predicate<Out> {
     return Predicate { actualExpression in
     #if arch(x86_64) && canImport(Darwin)
         let message = ExpectationMessage.expectedTo("throw an assertion")
@@ -30,7 +30,7 @@ public func throwAssertion() -> Predicate<Void> {
                 }
             #endif
             do {
-                try actualExpression.evaluate()
+                _ = try actualExpression.evaluate()
             } catch {
                 actualError = error
             }

Sources/Nimble/Matchers/ThrowError.swift

@@ -11,7 +11,7 @@ import Foundation
 ///
 /// nil arguments indicates that the matcher should not attempt to match against
 /// that parameter.
-public func throwError() -> Predicate<Any> {
+public func throwError<Out>() -> Predicate<Out> {
     return Predicate { actualExpression in
         var actualError: Error?
         do {
@@ -39,7 +39,7 @@ public func throwError() -> Predicate<Any> {
 ///
 /// nil arguments indicates that the matcher should not attempt to match against
 /// that parameter.
-public func throwError<T: Error>(_ error: T, closure: ((Error) -> Void)? = nil) -> Predicate<Any> {
+public func throwError<T: Error, Out>(_ error: T, closure: ((Error) -> Void)? = nil) -> Predicate<Out> {
     return Predicate { actualExpression in
         var actualError: Error?
         do {
@@ -87,7 +87,7 @@ public func throwError<T: Error>(_ error: T, closure: ((Error) -> Void)? = nil)
 ///
 /// nil arguments indicates that the matcher should not attempt to match against
 /// that parameter.
-public func throwError<T: Error & Equatable>(_ error: T, closure: ((T) -> Void)? = nil) -> Predicate<Any> {
+public func throwError<T: Error & Equatable, Out>(_ error: T, closure: ((T) -> Void)? = nil) -> Predicate<Out> {
     return Predicate { actualExpression in
         var actualError: Error?
         do {
@@ -135,9 +135,10 @@ public func throwError<T: Error & Equatable>(_ error: T, closure: ((T) -> Void)?
 ///
 /// nil arguments indicates that the matcher should not attempt to match against
 /// that parameter.
-public func throwError<T: Error>(
+public func throwError<T: Error, Out>(
     errorType: T.Type,
-    closure: ((T) -> Void)? = nil) -> Predicate<Any> {
+    closure: ((T) -> Void)? = nil
+) -> Predicate<Out> {
     return Predicate { actualExpression in
         var actualError: Error?
         do {
@@ -198,7 +199,7 @@ public func throwError<T: Error>(
 /// values of the existential type `Error` in the closure.
 ///
 /// The closure only gets called when an error was thrown.
-public func throwError(closure: @escaping ((Error) -> Void)) -> Predicate<Any> {
+public func throwError<Out>(closure: @escaping ((Error) -> Void)) -> Predicate<Out> {
     return Predicate { actualExpression in
         var actualError: Error?
         do {
@@ -234,7 +235,7 @@ public func throwError(closure: @escaping ((Error) -> Void)) -> Predicate<Any> {
 /// values of the existential type `Error` in the closure.
 ///
 /// The closure only gets called when an error was thrown.
-public func throwError<T: Error>(closure: @escaping ((T) -> Void)) -> Predicate<Any> {
+public func throwError<T: Error, Out>(closure: @escaping ((T) -> Void)) -> Predicate<Out> {
     return Predicate { actualExpression in
         var actualError: Error?
         do {

Tests/NimbleTests/Matchers/ThrowAssertionTest.swift

@@ -62,4 +62,10 @@ final class ThrowAssertionTest: XCTestCase {
         }
         #endif
     }
+
+    func testNonVoidClosure() {
+        #if canImport(Darwin)
+        expect { () -> Int in fatalError() }.to(throwAssertion())
+        #endif
+    }
 }

Tests/NimbleTests/Matchers/ThrowErrorTest.swift

@@ -6,7 +6,7 @@ enum NimbleError: Error {
     case cry
 }
 
-enum EquatableError: Error {
+enum EquatableError: Error, Equatable {
     case parameterized(x: Int)
 }
 
@@ -19,16 +19,6 @@ extension EquatableError: CustomDebugStringConvertible {
     }
 }
 
-extension EquatableError: Equatable {
-}
-
-func == (lhs: EquatableError, rhs: EquatableError) -> Bool {
-    switch (lhs, rhs) {
-    case (.parameterized(let l), .parameterized(let r)):
-        return l == r
-    }
-}
-
 enum CustomDebugStringConvertibleError: Error {
     // swiftlint:disable identifier_name
     case a
@@ -151,4 +141,27 @@ final class ThrowErrorTest: XCTestCase {
             expect { throw NimbleError.laugh }.to(throwError(NimbleError.laugh, closure: closure))
         }
     }
+
+    func testNonVoidClosure() {
+        expect { return 1 }.toNot(throwError())
+        expect { return 2 }.toNot(throwError(NimbleError.laugh))
+        expect { return 3 }.toNot(throwError(errorType: NimbleError.self))
+        expect { return 4 }.toNot(throwError(EquatableError.parameterized(x: 1)))
+        expect { return 5 }.toNot(throwError(EquatableError.parameterized(x: 2)))
+
+        // swiftlint:disable unused_closure_parameter
+
+        // Generic typed closure
+        expect { return "1" }.toNot(throwError { error in })
+        // Explicit typed closure
+        expect { return "2" }.toNot(throwError { (error: EquatableError) in })
+        // Typed closure over errorType argument
+        expect { return "3" }.toNot(throwError(errorType: EquatableError.self) { error in })
+        // Typed closure over error argument
+        expect { return "4" }.toNot(throwError(NimbleError.laugh) { (error: Error) in })
+        // Typed closure over error argument
+        expect { return "5" }.toNot(throwError(NimbleError.laugh) { (error: Error) in })
+
+        // swiftlint:enable unused_closure_parameter
+    }
 }

Tests/NimbleTests/XCTestManifests.swift

@@ -422,6 +422,7 @@ extension ThrowAssertionTest {
         ("testErrorThrown", testErrorThrown),
         ("testNegativeMatch", testNegativeMatch),
         ("testNegativeMessage", testNegativeMessage),
+        ("testNonVoidClosure", testNonVoidClosure),
         ("testPositiveMatch", testPositiveMatch),
         ("testPositiveMessage", testPositiveMessage),
         ("testPostAssertionCodeNotRun", testPostAssertionCodeNotRun),
@@ -437,6 +438,7 @@ extension ThrowErrorTest {
         ("testNegativeMatchesDoNotCallClosureWithoutError", testNegativeMatchesDoNotCallClosureWithoutError),
         ("testNegativeMatchesWithClosure", testNegativeMatchesWithClosure),
         ("testNegativeNegatedMatches", testNegativeNegatedMatches),
+        ("testNonVoidClosure", testNonVoidClosure),
         ("testPositiveMatches", testPositiveMatches),
         ("testPositiveMatchesWithClosures", testPositiveMatchesWithClosures),
         ("testPositiveNegatedMatches", testPositiveNegatedMatches),