How to use testPositiveNegatedMatches method of ThrowErrorTest class

...29        return [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        }...

1var objThrowErrorTest = ThrowErrorTest()2objThrowErrorTest.testPositiveNegatedMatches()3var objThrowErrorTest = ThrowErrorTest()4objThrowErrorTest.testPositiveMatches()5var objThrowErrorTest = ThrowErrorTest()6objThrowErrorTest.testNegativeMatches()7var objThrowErrorTest = ThrowErrorTest()8objThrowErrorTest.testNegativeNegatedMatches()9var objThrowErrorTest = ThrowErrorTest()10objThrowErrorTest.testPositiveMatches()11var objThrowErrorTest = ThrowErrorTest()12objThrowErrorTest.testPositiveNegatedMatches()13var objThrowErrorTest = ThrowErrorTest()14objThrowErrorTest.testNegativeMatches()15var objThrowErrorTest = ThrowErrorTest()16objThrowErrorTest.testNegativeNegatedMatches()17var objThrowErrorTest = ThrowErrorTest()18objThrowErrorTest.testPositiveMatches()19var objThrowErrorTest = ThrowErrorTest()20objThrowErrorTest.testPositiveNegatedMatches()21var objThrowErrorTest = ThrowErrorTest()22objThrowErrorTest.testNegativeMatches()23var objThrowErrorTest = ThrowErrorTest()24objThrowErrorTest.testNegativeNegatedMatches()

1import XCTest2class ThrowErrorTest: XCTestCase {3    func testPositiveNegatedMatches() {4        XCTAssertThrowsError(try doSomething()) { error in5            XCTAssertFalse(error is MyError)6        }7    }8}9import XCTest10class ThrowErrorTest: XCTestCase {11    func testNegativeNegatedMatches() {12        XCTAssertThrowsError(try doSomething()) { error in13            XCTAssertFalse(error is MyError)14        }15    }16}17import XCTest18class ThrowErrorTest: XCTestCase {19    func testPositiveMatches() {20        XCTAssertThrowsError(try doSomething()) { error in21            XCTAssertTrue(error is MyError)22        }23    }24}25import XCTest26class ThrowErrorTest: XCTestCase {27    func testNegativeMatches() {28        XCTAssertThrowsError(try doSomething()) { error in29            XCTAssertTrue(error is MyError)30        }31    }32}33import XCTest34class ThrowErrorTest: XCTestCase {35    func testPositiveMatches() {36        XCTAssertThrowsError(try doSomething()) { error in37            XCTAssertTrue(error is MyError)38        }39    }40}41import XCTest42class ThrowErrorTest: XCTestCase {43    func testNegativeMatches() {44        XCTAssertThrowsError(try doSomething()) { error in45            XCTAssertTrue(error is MyError)46        }47    }48}49import XCTest50class ThrowErrorTest: XCTestCase {51    func testPositiveMatches() {52        XCTAssertThrowsError(try doSomething()) { error in53            XCTAssertTrue(error is MyError)54        }55    }56}57import XCTest58class ThrowErrorTest: XCTestCase {59    func testNegativeMatches() {60        XCTAssertThrowsError(try doSomething()) { error in61            XCTAssertTrue(error is MyError)62        }63    }64}

1import XCTest2class ThrowErrorTest: XCTestCase {3    func testPositiveNegatedMatches() {4        XCTAssertThrowsError(try doSomething())5    }6    func testPositiveMatches() {7        XCTAssertNoThrow(try doSomething())8    }9    func testNegativeMatches() {10        XCTAssertThrowsError(try doSomething())11    }12    func testNegativeMatches() {13        XCTAssertNoThrow(try doSomething())14    }15    func doSomething() throws {16    }17}18import XCTest19class ThrowErrorTest: XCTestCase {20    func testPositiveNegatedMatches() {21        XCTAssertThrowsError(try doSomething())22    }23    func testPositiveMatches() {24        XCTAssertNoThrow(try doSomething())25    }26    func testNegativeMatches() {27        XCTAssertThrowsError(try doSomething())28    }29    func testNegativeMatches() {30        XCTAssertNoThrow(try doSomething())31    }32    func doSomething() throws {33    }34}35import XCTest36class ThrowErrorTest: XCTestCase {37    func testPositiveNegatedMatches() {38        XCTAssertThrowsError(try doSomething())39    }40    func testPositiveMatches() {41        XCTAssertNoThrow(try doSomething())42    }43    func testNegativeMatches() {44        XCTAssertThrowsError(try doSomething())45    }46    func testNegativeMatches() {47        XCTAssertNoThrow(try doSomething())48    }49    func doSomething() throws {50    }51}

1import XCTest2class ThrowErrorTest: XCTestCase {3    func testPositiveNegatedMatches() {4        XCTAssertThrowsError(try ThrowErrorTest.throwError()) { error in5            XCTAssertFalse(error is MyError)6        }7    }8    static func throwError() throws {9    }10}11enum MyError: Error {12}13import XCTest14class ThrowErrorTest: XCTestCase {15    func testPositiveNegatedMatches() {16        XCTAssertThrowsError(try ThrowErrorTest.throwError()) { error in17            XCTAssertFalse(error is MyError)18        }19    }20    static func throwError() throws {21    }22}23enum MyError: Error {24}25import XCTest26class ThrowErrorTest: XCTestCase {27    func testPositiveNegatedMatches() {28        XCTAssertThrowsError(try ThrowErrorTest.throwError()) { error in29            XCTAssertFalse(error is MyError)30        }31    }32    static func throwError() throws {33    }34}35enum MyError: Error {36}37import XCTest38class ThrowErrorTest: XCTestCase {39    func testPositiveNegatedMatches() {40        XCTAssertThrowsError(try ThrowErrorTest.throwError()) { error in41            XCTAssertFalse(error is MyError)42        }43    }44    static func throwError() throws {45    }46}47enum MyError: Error {48}49import XCTest50class ThrowErrorTest: XCTestCase {51    func testPositiveNegatedMatches() {52        XCTAssertThrowsError(try ThrowErrorTest.throwError()) { error in53            XCTAssertFalse(error is MyError)54        }55    }56    static func throwError() throws {57    }58}59enum MyError: Error {60}61import XCTest

1import XCTest2import Foundation3class ThrowErrorTest: XCTestCase {4    func testPositiveNegatedMatches() {5        XCTAssertThrowsError(try ThrowErrorTest.throwError()) { error in6            XCTAssertFalse(error is NSError)7        }8    }9}10ThrowErrorTest.testPositiveNegatedMatches()

1import Foundation2import XCTest3class ThrowErrorTest: XCTestCase {4    func testPositiveNegatedMatches() throws {5        XCTAssertThrowsError(try positiveNegatedMatches())6    }7    func positiveNegatedMatches() throws {8        throw NSError(domain: "com.example", code: 1, userInfo: nil)9    }10}11import Foundation12import XCTest13class ThrowErrorTest: XCTestCase {14    func testNegativeNegatedMatches() throws {15        XCTAssertThrowsError(try negativeNegatedMatches())16    }17    func negativeNegatedMatches() throws {18        throw NSError(domain: "com.example", code: 1, userInfo: nil)19    }20}21import Foundation22import XCTest23class ThrowErrorTest: XCTestCase {24    func testPositiveMatches() throws {25        XCTAssertThrowsError(try positiveMatches())26    }27    func positiveMatches() throws {28        throw NSError(domain: "com.example", code: 1, userInfo: nil)29    }30}31import Foundation32import XCTest33class ThrowErrorTest: XCTestCase {34    func testNegativeMatches() throws {35        XCTAssertThrowsError(try negativeMatches())36    }37    func negativeMatches() throws {38        throw NSError(domain: "com.example", code: 1, userInfo: nil)39    }40}41import Foundation42import XCTest43class ThrowErrorTest: XCTestCase {44    func testPositiveNegatedMatches() throws {45        XCTAssertThrowsError(try positiveNegatedMatches())46    }47    func positiveNegatedMatches() throws {48        throw NSError(domain: "com.example", code: 1, userInfo: nil)49    }50}51import Foundation52import XCTest53class ThrowErrorTest: XCTestCase {54    func testNegativeNegatedMatches() throws {55        XCTAssertThrowsError(try negativeNegatedMatches())56    }

1import XCTest2@testable import TestTarget3class ThrowErrorTestTests: XCTestCase {4    func testPositiveNegatedMatches() {5        let thrower = ThrowErrorTest()6        XCTAssertThrowsError(try thrower.thrower()) { error in7            XCTAssertNotEqual(error as? ThrowErrorTest.ThrowError, ThrowErrorTest.ThrowError.error1)8        }9    }10}11import XCTest12@testable import TestTarget13class ThrowErrorTestTests: XCTestCase {14    func testPositiveNegatedMatches() {15        let thrower = ThrowErrorTest()16        XCTAssertThrowsError(try thrower.thrower()) { error in17            XCTAssertNotEqual(error as? ThrowErrorTest.ThrowError, ThrowErrorTest.ThrowError.error2)18        }19    }20}21import XCTest22@testable import TestTarget23class ThrowErrorTestTests: XCTestCase {24    func testPositiveNegatedMatches() {25        let thrower = ThrowErrorTest()26        XCTAssertThrowsError(try thrower.thrower()) { error in27            XCTAssertNotEqual(error as? ThrowErrorTest.ThrowError, ThrowErrorTest.ThrowError.error3)28        }29    }30}31import XCTest32@testable import TestTarget33class ThrowErrorTestTests: XCTestCase {34    func testPositiveNegatedMatches() {35        let thrower = ThrowErrorTest()36        XCTAssertThrowsError(try thrower.thrower()) { error in37            XCTAssertNotEqual(error as? ThrowErrorTest.ThrowError, ThrowErrorTest.ThrowError.error4)38        }39    }40}41import XCTest42@testable import TestTarget43class ThrowErrorTestTests: XCTestCase {44    func testPositiveNegatedMatches() {45        let thrower = ThrowErrorTest()46        XCTAssertThrowsError(try thrower.thrower()) { error in47            XCTAssertNotEqual(error as? ThrowErrorTest.ThrowError, ThrowErrorTest.ThrowError.error5)48        }49    }50}51import XCTest52@testable import TestTarget

1import XCTest2@testable import ThrowErrorTest3class ThrowErrorTestTests: XCTestCase {4    func testPositiveNegatedMatches() {5        let test = ThrowErrorTest()6        XCTAssertNoThrow(try test.testPositiveNegatedMatches())7    }8}