                 closure(actualError)
             }
             let messages = assertions.map { $0.message }
-            if messages.count > 0 {
+            if !messages.isEmpty {
                 matches = false
             }
         }
-        return matches
-    }
-}
+
+        return PredicateResult(bool: matches, message: failureMessage.toExpectationMessage())
+    }
+}

            errorType: errorType,
            closure: closure
        )
        var matches = false
        if let actualError = actualError {
            matches = true
            if let actualError = actualError as? T {
                if let closure = closure {
                    let assertions = gatherFailingExpectations {
                        closure(actualError)
                    }
                    let messages = assertions.map { $0.message }
                    if messages.count > 0 {
                        matches = false
                    }
                }

///
/// The closure only gets called when an error was thrown.
public func throwError<T: Error>(closure: @escaping ((T) -> Void)) -> Predicate<Any> {
    return Predicate { actualExpression in
        var actualError: Error?
        do {
            _ = try actualExpression.evaluate()
        } catch {
            actualError = error
        }

        let failureMessage = FailureMessage()
        setFailureMessageForError(failureMessage, actualError: actualError, closure: closure)

        var matches = false
