How to use testNegativeNegatedMatches method of ThrowErrorTest class

...30            ("testPositiveMatches", testPositiveMatches),31            ("testPositiveMatchesWithClosures", testPositiveMatchesWithClosures),32            ("testNegativeMatches", testNegativeMatches),33            ("testPositiveNegatedMatches", testPositiveNegatedMatches),34            ("testNegativeNegatedMatches", testNegativeNegatedMatches),35            ("testNegativeMatchesDoNotCallClosureWithoutError", testNegativeMatchesDoNotCallClosureWithoutError),36            ("testNegativeMatchesWithClosure", testNegativeMatchesWithClosure),37        ]38    }39    func testPositiveMatches() {40        expect { throw NimbleError.laugh }.to(throwError())41        expect { throw NimbleError.laugh }.to(throwError(NimbleError.laugh))42        expect { throw NimbleError.laugh }.to(throwError(errorType: NimbleError.self))43        expect { throw EquatableError.parameterized(x: 1) }.to(throwError(EquatableError.parameterized(x: 1)))44    }45    func testPositiveMatchesWithClosures() {46        // Generic typed closure47        expect { throw EquatableError.parameterized(x: 42) }.to(throwError { error in48            guard case EquatableError.parameterized(let x) = error else { fail(); return }49            expect(x) >= 150        })51        // Explicit typed closure52        expect { throw EquatableError.parameterized(x: 42) }.to(throwError { (error: EquatableError) in53            guard case .parameterized(let x) = error else { fail(); return }54            expect(x) >= 155        })56        // Typed closure over errorType argument57        expect { throw EquatableError.parameterized(x: 42) }.to(throwError(errorType: EquatableError.self) { error in58            guard case .parameterized(let x) = error else { fail(); return }59            expect(x) >= 160        })61        // Typed closure over error argument62        expect { throw NimbleError.laugh }.to(throwError(NimbleError.laugh) { (error: Error) in63            expect(error._domain).to(beginWith("Nim"))64        })65        // Typed closure over error argument66        expect { throw NimbleError.laugh }.to(throwError(NimbleError.laugh) { (error: Error) in67            expect(error._domain).toNot(beginWith("as"))68        })69    }70    func testNegativeMatches() {71        // Same case, different arguments72        failsWithErrorMessage("expected to throw error <parameterized(2)>, got <parameterized(1)>") {73            expect { throw EquatableError.parameterized(x: 1) }.to(throwError(EquatableError.parameterized(x: 2)))74        }75        // Same case, different arguments76        failsWithErrorMessage("expected to throw error <parameterized(2)>, got <parameterized(1)>") {77            expect { throw EquatableError.parameterized(x: 1) }.to(throwError(EquatableError.parameterized(x: 2)))78        }79        // Different case80        failsWithErrorMessage("expected to throw error <cry>, got <laugh>") {81            expect { throw NimbleError.laugh }.to(throwError(NimbleError.cry))82        }83        // Different case with closure84        failsWithErrorMessage("expected to throw error <cry> that satisfies block, got <laugh>") {85            expect { throw NimbleError.laugh }.to(throwError(NimbleError.cry) { _ in return })86        }87        // Different case, implementing CustomDebugStringConvertible88        failsWithErrorMessage("expected to throw error <code=1>, got <code=0>") {89            expect { throw CustomDebugStringConvertibleError.a }.to(throwError(CustomDebugStringConvertibleError.b))90        }91    }92    func testPositiveNegatedMatches() {93        // No error at all94        expect { return }.toNot(throwError())95        // Different case96        expect { throw NimbleError.laugh }.toNot(throwError(NimbleError.cry))97    }98    func testNegativeNegatedMatches() {99        // No error at all100        failsWithErrorMessage("expected to not throw any error, got <laugh>") {101            expect { throw NimbleError.laugh }.toNot(throwError())102        }103        // Different error104        failsWithErrorMessage("expected to not throw error <laugh>, got <laugh>") {105            expect { throw NimbleError.laugh }.toNot(throwError(NimbleError.laugh))106        }107    }108    func testNegativeMatchesDoNotCallClosureWithoutError() {109        failsWithErrorMessage("expected to throw error that satisfies block, got no error") {110            expect { return }.to(throwError { error in111                fail()112            })...

1let test = ThrowErrorTest()2test.testNegativeNegatedMatches()3let test = ThrowErrorTest()4test.testNegativeNegatedMatches()5let test = ThrowErrorTest()6test.testNegativeNegatedMatches()7let test = ThrowErrorTest()8test.testNegativeNegatedMatches()9let test = ThrowErrorTest()10test.testNegativeNegatedMatches()11let test = ThrowErrorTest()12test.testNegativeNegatedMatches()13let test = ThrowErrorTest()14test.testNegativeNegatedMatches()15let test = ThrowErrorTest()16test.testNegativeNegatedMatches()17let test = ThrowErrorTest()18test.testNegativeNegatedMatches()19let test = ThrowErrorTest()20test.testNegativeNegatedMatches()21let test = ThrowErrorTest()22test.testNegativeNegatedMatches()23let test = ThrowErrorTest()24test.testNegativeNegatedMatches()25let test = ThrowErrorTest()26test.testNegativeNegatedMatches()27let test = ThrowErrorTest()28test.testNegativeNegatedMatches()

1import XCTest2class ThrowErrorTest: XCTestCase {3    func testNegativeNegatedMatches() {4        XCTAssertThrowsError(try someThrowingFunction()) { error in5            XCTAssertFalse(error is SomeError)6        }7    }8}9import XCTest10class ThrowErrorTest: XCTestCase {11    func testNegativeNegatedMatches() {12        XCTAssertThrowsError(try someThrowingFunction()) { error in13            XCTAssertFalse(error is SomeOtherError)14        }15    }16}17import XCTest18class ThrowErrorTest: XCTestCase {19    func testNegativeNegatedMatches() {20        XCTAssertThrowsError(try someThrowingFunction()) { error in21            XCTAssertFalse(error is AnotherError)22        }23    }24}25import XCTest26class ThrowErrorTest: XCTestCase {27    func testNegativeNegatedMatches() {28        XCTAssertThrowsError(try someThrowingFunction()) { error in29            XCTAssertFalse(error is YetAnotherError)30        }31    }32}33import XCTest34class ThrowErrorTest: XCTestCase {35    func testNegativeNegatedMatches() {36        XCTAssertThrowsError(try someThrowingFunction()) { error in37            XCTAssertFalse(error is SomeError)38        }39    }40}41import XCTest42class ThrowErrorTest: XCTestCase {43    func testNegativeNegatedMatches() {44        XCTAssertThrowsError(try someThrowingFunction()) { error in45            XCTAssertFalse(error is SomeOtherError)46        }47    }48}49import XCTest50class ThrowErrorTest: XCTestCase {51    func testNegativeNegatedMatches() {52        XCTAssertThrowsError(try someThrowingFunction()) { error in53            XCTAssertFalse(error is AnotherError)54        }55    }56}57import XCTest

1import XCTest2import Foundation3class ThrowErrorTest: XCTestCase {4    func testNegativeNegatedMatches() {5        XCTAssertThrowsError(try someThrowingFunction()) { error in6            XCTAssertNotEqual(error as NSError, NSError(domain: "MyDomain", code: 0, userInfo: nil))7        }8    }9}10import XCTest11class ThrowErrorTest: XCTestCase {12    func testNegativeNegatedMatches() {13        XCTAssertThrowsError(try someThrowingFunction()) { error in14            XCTAssertNotEqual(error as NSError, NSError(domain: "MyDomain", code: 0, userInfo: nil))15        }16    }17}18error: ThrowErrorTest.testNegativeNegatedMatches : failed - The operation couldn’t be completed. (XCTest.XCTContextError error 0.)19public enum XCTContextError : Int, _ObjectiveCBridgeableError {20}21extension XCTContextError : _ObjectiveCBridgeableError {22    public func _nsError() -> NSError {23        return NSError(domain: "XCTestErrorDomain", code: self.rawValue, userInfo: nil)24    }25}26import XCTest27import Foundation28class ThrowErrorTest: XCTestCase {29    func testNegativeNegatedMatches() {30        XCTAssertThrowsError(try someThrowingFunction()) { error in31            XCTAssertNotEqual(error as NSError, NSError(domain: "MyDomain", code: 0, userInfo: nil))32        }33    }34}

1class ThrowErrorTest {2    func testNegativeNegatedMatches() {3        let error = NSError(domain: "domain", code: 0, userInfo: nil)4        do {5        } catch _ as NSError {6        } catch {7        }8    }9}10class ThrowErrorTest {11    func testNegativeNegatedMatches() {12        let error = NSError(domain: "domain", code: 0, userInfo: nil)13        do {14        } catch _ as NSError {15        } catch {16        }17    }18}19class ThrowErrorTest {20    func testNegativeNegatedMatches() {21        let error = NSError(domain: "domain", code: 0, userInfo: nil)22        do {23        } catch _ as NSError {24        } catch {25        }26    }27}28class ThrowErrorTest {29    func testNegativeNegatedMatches() {30        let error = NSError(domain: "domain", code: 0, userInfo: nil)31        do {32        } catch _ as NSError {33        } catch {34        }35    }36}37class ThrowErrorTest {38    func testNegativeNegatedMatches() {39        let error = NSError(domain: "domain", code: 0, userInfo: nil)40        do {41        } catch _ as NSError {42        } catch {43        }44    }45}46class ThrowErrorTest {47    func testNegativeNegatedMatches() {48        let error = NSError(domain: "domain", code: 0

1import XCTest2class ThrowErrorTest: XCTestCase {3    func testNegativeNegatedMatches() {4        XCTAssertThrowsError(try throwAnError()) { error in5            XCTAssertNotEqual(error as! TestError, TestError.testError)6        }7    }8}9import XCTest10enum TestError: Error {11}12class ThrowErrorTest: XCTestCase {13    func throwAnError() throws {14    }15}

1import XCTest2class ThrowErrorTest: XCTestCase {3    func testNegativeNegatedMatches() {4        XCTAssertThrowsError(try throwMyError()) { error in5            XCTAssertNotEqual(error as? MyError, MyError.foo)6        }7    }8}9import XCTest10class ThrowErrorTest: XCTestCase {11    func testNegativeNegatedMatches() {12        XCTAssertThrowsError(try throwMyError()) { error in13            XCTAssertNotEqual(error as? MyError, MyError.foo)14        }15    }16}17import XCTest18class ThrowErrorTest: XCTestCase {19    func testNegativeNegatedMatches() {20        XCTAssertThrowsError(try throwMyError()) { error in21            XCTAssertNotEqual(error as? MyError, MyError.foo)22        }23    }24}25import XCTest26class ThrowErrorTest: XCTestCase {27    func testNegativeNegatedMatches() {28        XCTAssertThrowsError(try throwMyError()) { error in29            XCTAssertNotEqual(error as? MyError, MyError.foo)30        }31    }32}33import XCTest34class ThrowErrorTest: XCTestCase {35    func testNegativeNegatedMatches() {36        XCTAssertThrowsError(try throwMyError()) { error in37            XCTAssertNotEqual(error as? MyError, MyError.foo)38        }39    }40}41import XCTest42class ThrowErrorTest: XCTestCase {43    func testNegativeNegatedMatches() {44        XCTAssertThrowsError(try throwMy

1import XCTest2@testable import MyProject3class ThrowErrorTest: XCTestCase {4    func testNegativeNegatedMatches() {5        XCTAssertThrowsError(try Foo().bar()) { error in6            XCTAssertFalse(error is BarError)7        }8    }9}10import XCTest11@testable import MyProject12class ThrowErrorTest: XCTestCase {13    func testNegativeNegatedMatches() {14        XCTAssertThrowsError(try Foo().bar()) { error in15            XCTAssertFalse(error is BarError)16        }17    }18}19error: MyProjectTests.ThrowErrorTest : failed - testNegativeNegatedMatches threw error "XCTAssertFalse failed: ("BarError") is true" - testNegativeNegatedMatches() threw error "XCTAssertFalse failed: ("BarError") is true" - XCTAssertFalse failed: ("BarError") is true