Implement assertion chaining

Sources/Nimble/Expectation.swift

@@ -101,22 +101,27 @@ public struct Expectation<T> {
     ////////////////// NEW API /////////////////////
 
     /// Tests the actual value using a matcher to match.
-    public func to(_ predicate: Predicate<T>, description: String? = nil) {
+    @discardableResult
+    public func to(_ predicate: Predicate<T>, description: String? = nil) -> Self {
         let (pass, msg) = execute(expression, .toMatch, predicate, to: "to", description: description)
         verify(pass, msg)
+        return self
     }
 
     /// Tests the actual value using a matcher to not match.
-    public func toNot(_ predicate: Predicate<T>, description: String? = nil) {
+    @discardableResult
+    public func toNot(_ predicate: Predicate<T>, description: String? = nil) -> Self {
         let (pass, msg) = execute(expression, .toNotMatch, predicate, to: "to not", description: description)
         verify(pass, msg)
+        return self
     }
 
     /// Tests the actual value using a matcher to not match.
     ///
     /// Alias to toNot().
-    public func notTo(_ predicate: Predicate<T>, description: String? = nil) {
-        toNot(predicate, description: description)
+    @discardableResult
+    public func notTo(_ predicate: Predicate<T>, description: String? = nil) -> Self {
+        return toNot(predicate, description: description)
     }
 
     // see:

Tests/NimbleTests/Matchers/ThrowAssertionTest.swift

@@ -68,4 +68,10 @@ final class ThrowAssertionTest: XCTestCase {
         expect { () -> Int in fatalError() }.to(throwAssertion())
         #endif
     }
+
+    func testChainOnThrowAssertion() {
+        #if canImport(Darwin)
+        expect { () -> Int in return 5 }.toNot(throwAssertion()).to(equal(5))
+        #endif
+    }
 }

Tests/NimbleTests/Matchers/ThrowErrorTest.swift

@@ -125,7 +125,7 @@ final class ThrowErrorTest: XCTestCase {
     func testNegativeMatchesWithClosure() {
         let moduleName = "NimbleTests"
         let innerFailureMessage = "expected to equal <foo>, got <\(moduleName).NimbleError>"
-        let closure = { (error: Error) in
+        let closure = { (error: Error) -> Void in
             expect(error._domain).to(equal("foo"))
         }
 
@@ -164,4 +164,8 @@ final class ThrowErrorTest: XCTestCase {
 
         // swiftlint:enable unused_closure_parameter
     }
+
+    func testChainOnThrowError() {
+        expect { () throws -> Int in return 5 }.toNot(throwError()).to(equal(5))
+    }
 }

Tests/NimbleTests/SynchronousTest.swift

@@ -139,4 +139,16 @@ final class SynchronousTest: XCTestCase {
         expect(1).notTo(MatcherFunc { _, _ in false }.predicate)
         expect(1).notTo(Predicate.simple("match") { _ in .doesNotMatch })
     }
+
+    // MARK: Assertion chaining
+
+    func testChain() {
+        expect(2).toNot(equal(1)).to(equal(2)).notTo(equal(3))
+    }
+
+    func testChainFailOnFirstError() {
+        failsWithErrorMessage("expected to not equal <2>, got <2>") {
+            expect(2).toNot(equal(1)).toNot(equal(2)).to(equal(3))
+        }
+    }
 }