How to use testSkippingExamplesAreCorrectlyReported method of ItTests class

...117    static var allTests: [(String, (ItTests) -> () throws -> Void)] {118        return [119            ("testAllExamplesAreExecuted", testAllExamplesAreExecuted),120            ("testImplicitErrorHandling", testImplicitErrorHandling),121            ("testSkippingExamplesAreCorrectlyReported", testSkippingExamplesAreCorrectlyReported),122        ]123    }124    override func setUp() {125        super.setUp()126        isRunningFunctionalTests = true127    }128    override func tearDown() {129        isRunningFunctionalTests = false130        super.tearDown()131    }132    func testAllExamplesAreExecuted() {133        let result = qck_runSpec(FunctionalTests_ItSpec.self)134        #if canImport(Darwin)135        #if SWIFT_PACKAGE136        XCTAssertEqual(result?.executionCount, 7)137        #else138        XCTAssertEqual(result?.executionCount, 10)139        #endif140        #else141        XCTAssertEqual(result?.executionCount, 2)142        #endif143    }144    func testImplicitErrorHandling() {145        let result = qck_runSpec(FunctionalTests_ImplicitErrorItSpec.self)!146        XCTAssertFalse(result.hasSucceeded)147        XCTAssertEqual(result.executionCount, 2)148        XCTAssertEqual(result.failureCount, 0)149        XCTAssertEqual(result.unexpectedExceptionCount, 1)150        XCTAssertEqual(result.totalFailureCount, 1)151    }152    func testSkippingExamplesAreCorrectlyReported() {153        let result = qck_runSpec(FunctionalTests_SkippingTestsSpec.self)!154        XCTAssertTrue(result.hasSucceeded)155        XCTAssertEqual(result.executionCount, 2)156        XCTAssertEqual(result.skipCount, 1)157        XCTAssertEqual(result.totalFailureCount, 0)158    }159}...

1import XCTest2import Quick3import Nimble4class ItTests: QuickSpec {5    override func spec() {6        it("testSkippingExamplesAreCorrectlyReported") {7            expect(1).to(equal(1))8        }9    }10}11import XCTest12import Quick13import Nimble14class ItTests: QuickSpec {15    override func spec() {16        it("testSkippingExamplesAreCorrectlyReported") {17            expect(1).to(equal(1))18        }19    }20}21	 Executed 2 tests, with 0 failures (0 unexpected) in 0.000 (0.000) seconds22	 Executed 2 tests, with 0 failures (0 unexpected) in 0.000 (0.000) seconds23	 Executed 2 tests, with 0 failures (0 unexpected) in 0.000 (0.000) seconds

1import Quick2import Nimble3class ItTests: QuickSpec {4    override func spec() {5        it("testSkippingExamplesAreCorrectlyReported") {6            expect(true).to(beTrue())7        }8    }9}10import Quick11import Nimble12class ItTests: QuickSpec {13    override func spec() {14        it("testSkippingExamplesAreCorrectlyReported") {15            expect(true).to(beTrue())16        }17    }18}19import Quick20import Nimble21class ItTests: QuickSpec {22    override func spec() {23        it("testSkippingExamplesAreCorrectlyReported") {24            expect(true).to(beTrue())25        }26    }27}28import Quick29import Nimble30class ItTests: QuickSpec {31    override func spec() {32        it("testSkippingExamplesAreCorrectlyReported") {33            expect(true).to(beTrue())34        }35    }36}37import Quick38import Nimble39class ItTests: QuickSpec {40    override func spec() {41        it("testSkippingExamplesAreCorrectlyReported") {42            expect(true).to(beTrue())43        }44    }45}46import Quick47import Nimble48class ItTests: QuickSpec {49    override func spec() {50        it("testSkippingExamplesAreCorrectlyReported") {51            expect(true).to(beTrue())52        }53    }54}55import Quick56import Nimble57class ItTests: QuickSpec {58    override func spec() {59        it("testSkippingExamplesAreCorrectlyReported") {

1import XCTest2import Quick3class ItTests: XCTestCase {4    func testSkippingExamplesAreCorrectedReported() {5        let exampleGroup = describe("an example group") {6            it("an example") {7                XCTFail()8            }9            it("another example") {10                XCTFail()11            }12        }13        let result = runSpecs([exampleGroup])14        XCTAssertEqual(result.exampleCount, 2)15        XCTAssertEqual(result.failureCount, 1)16        XCTAssertEqual(result.skippedExampleCount, 1)17        XCTAssertEqual(failure.example.name, "an example")18        XCTAssertEqual(failure.example, example)19        XCTAssertNotEqual(failure.example, example2)20    }21}22import XCTest23import Quick24class ItTests: XCTestCase {25    func testSkippingExamplesAreCorrectedReported() {26        let exampleGroup = describe("an example group") {27            it("an example") {28                XCTFail()29            }30            it("another example") {31                XCTFail()32            }33        }34        let result = runSpecs([exampleGroup])35        XCTAssertEqual(result.exampleCount, 2)36        XCTAssertEqual(result.failureCount, 1)37        XCTAssertEqual(result.skippedExampleCount, 1)38        XCTAssertEqual(failure.example.name, "an example")39        XCTAssertEqual(failure.example, example)40        XCTAssertNotEqual(failure.example, example2)41    }42}43import XCTest44import Quick45class ItTests: XCTestCase {46    func testSkippingExamplesAreCorrectedReported() {47        let exampleGroup = describe("an example group") {48            it("an example") {49                XCTFail()50            }51            it("another example") {52                XCTFail()53            }54        }55        let result = runSpecs([exampleGroup])56        XCTAssertEqual(result

1import XCTest2class ItTests: XCTestCase {3    func testSkippingExamplesAreCorrectedReported() {4        let example = It("should be skipped") {5            XCTFail("this should not be called")6        }7        example.run { report in8        }9        XCTAssertEqual(exampleReport?.status, .skipped)10        XCTAssertEqual(exampleReport?.example.name, example.name)11        XCTAssertNil(exampleReport?.failure)12    }13}14import XCTest15class ItTests: XCTestCase {16    func testSkippingExamplesAreCorrectedReported() {17        let example = It("should be skipped") {18            XCTFail("this should not be called")19        }20        example.run { report in21        }22        XCTAssertEqual(exampleReport?.status, .skipped)23        XCTAssertEqual(exampleReport?.example.name, example.name)24        XCTAssertNil(exampleReport?.failure)25    }26}27import XCTest28class ItTests: XCTestCase {29    func testSkippingExamplesAreCorrectedReported() {30        let example = It("should be skipped") {31            XCTFail("this should not be called")32        }33        example.run { report in34        }35        XCTAssertEqual(exampleReport?.status, .skipped)36        XCTAssertEqual(exampleReport?.example.name, example.name)37        XCTAssertNil(exampleReport?.failure)38    }39}40import XCTest41class ItTests: XCTestCase {42    func testSkippingExamplesAreCorrectedReported() {43        let example = It("should be skipped") {44            XCTFail("this should not be called")45        }46        example.run { report in47        }48        XCTAssertEqual(exampleReport?.status, .skipped)49        XCTAssertEqual(exampleReport?.example.name, example.name)50        XCTAssertNil(exampleReport?.failure)51    }

1import XCTest2import Quick3import Nimble4class ItTests: XCTestCase {5    func testSkippingExamplesAreCorrectlyReported() {6        let example = Example("example", closure: { pending("skip") })7        let exampleGroup = ExampleGroup("group", children: [example])8        let reporter = TestSuiteReporter()9        let world = World(reporter: reporter)10        world.runExampleGroups([exampleGroup])11        expect(reporter.exampleCount).to(equal(1))12        expect(reporter.pendingExampleCount).to(equal(1))13    }14}15import XCTest16import Quick17class TestSuiteReporter: QuickSpec {18    override func spec() {19        describe("TestSuiteReporter") {20            it("should report the number of examples") {21            }22            it("should report the number of pending examples") {23                pending("skip")24            }25        }26    }27}28import XCTest29import Quick30import Nimble31class ExampleTests: XCTestCase {32    func testPendingExamplesAreReported() {33        let example = Example("example", closure: {34            pending("skip")35        })36        let reporter = TestSuiteReporter()37        let world = World(reporter: reporter)38        world.runExampleGroups([example])39        expect(exampleWasRun).to(beFalse())40        expect(reporter.exampleCount).to(equal(1))41        expect(reporter.pendingExampleCount).to(equal(1))42    }43}44import XCTest45import Quick46import Nimble47class WorldTests: XCTestCase {48    func testRunExampleGroups() {49        let example = Example("example", closure: { exampleWasRun = true })50        let exampleGroup = ExampleGroup("group", children: [example])51        let reporter = TestSuiteReporter()52        let world = World(reporter: reporter)53        world.runExampleGroups([exampleGroup])54        expect(exampleWasRun).to(beTrue())55        expect(reporter.exampleCount).to(equal(1))

1import XCTest2import Quick3class ItTests: XCTestCase {4    func testSkippingExamplesAreCorrectlyReported() {5        let example = Example("an example that is skipped", { () -> () in6            XCTSkip("This example is skipped")7        })8        let result = example.run()9        XCTAssertTrue(result.skipped)10        XCTAssertEqual(result.failureMessage, "This example is skipped")11    }12}13import XCTest14import Quick15class ItTests: XCTestCase {16    func testSkippingExamplesAreCorrectlyReported() {17        let example = Example("an example that is skipped", { () -> () in18            XCTSkip("This example is skipped")19        })20        let result = example.run()21        XCTAssertTrue(result.skipped)22        XCTAssertEqual(result.failureMessage, "This example is skipped")23    }24}25import XCTest26import Quick27class ItTests: XCTestCase {28    func testSkippingExamplesAreCorrectlyReported() {29        let example = Example("an example that is skipped", { () -> () in30            XCTSkip("This example is skipped")31        })32        let result = example.run()33        XCTAssertTrue(result.skipped)34        XCTAssertEqual(result.failureMessage, "This example is skipped")35    }36}37import XCTest38import Quick39class ItTests: XCTestCase {40    func testSkippingExamplesAreCorrectlyReported() {41        let example = Example("an example that is skipped", { () -> () in42            XCTSkip("This example is skipped")43        })44        let result = example.run()45        XCTAssertTrue(result.skipped)46        XCTAssertEqual(result.failureMessage, "This example is skipped")47    }48}49import XCTest50import Quick51class ItTests: XCTestCase {52    func testSkippingExamplesAreCorrectlyReported() {53        let example = Example("an example that is skipped", { () -> () in54            XCTSkip("This example is skipped")55        })56        let result = example.run()57        XCTAssertTrue(result.skipped)58        XCTAssertEqual(result.failureMessage, "This

1import XCTest2class ItTests: XCTestCase {3    func testSkippingExamplesAreCorrectedReported() {4        let (output, status) = executeSwift("1.swift")5        XCTAssert(status == 0, "swift returned non-zero status")6        XCTAssert(output.contains("Test Case 'ItTests.testSkippingExamplesAreCorrectedReported' passed"), "output did not contain expected string")7    }8}9import XCTest10class ItTests: XCTestCase {11    func testFailingExamplesAreCorrectlyReported() {12        let (output, status) = executeSwift("2.swift")13        XCTAssert(status == 1, "swift returned non-zero status")14        XCTAssert(output.contains("Test Case 'ItTests.testFailingExamplesAreCorrectlyReported' failed"), "output did not contain expected string")15    }16}17import XCTest18class ItTests: XCTestCase {19    func testPendingExamplesAreCorrectlyReported() {20        let (output, status) = executeSwift("3.swift")21        XCTAssert(status == 0, "swift returned non-zero status")22        XCTAssert(output.contains("Test Case 'ItTests.testPendingExamplesAreCorrectlyReported' passed"), "output did not contain expected string")23    }24}25import XCTest26class ItTests: XCTestCase {27    func testPendingExamplesAreCorrectlyReported() {28        let (output, status) = executeSwift("4.swift")29        XCTAssert(status == 1, "swift returned non-zero status")30        XCTAssert(output.contains("Test Case 'ItTests.testPendingExamplesAreCorrectlyReported' failed"), "output did not contain expected string")31    }32}33import XCTest34class ItTests: XCTestCase {35    func testPendingExamplesAreCorrectlyReported() {36        let (output, status) = executeSwift("5.swift")37        XCTAssert(status == 0, "swift returned non-zero status")38        XCTAssert(output.contains("Test Case 'ItTests.testPendingExamplesAreCorrectlyReported' passed"), "39import Quick40class ItTests: XCTestCase {41    func testSkippingExamplesAreCorrectlyReported() {42        let example = Example("an example that is skipped", { () -> () in43            XCTSkip("This example is skipped")44        })45        let result = example.run()46        XCTAssertTrue(result.skipped)47        XCTAssertEqual(result.failureMessage, "This example is skipped")48    }49}50import XCTest51import Quick52class ItTests: XCTestCase {53    func testSkippingExamplesAreCorrectlyReported() {54        let example = Example("an example that is skipped", { () -> () in55            XCTSkip("This example is skipped")56        })57        let result = example.run()58        XCTAssertTrue(result.skipped)59        XCTAssertEqual(result.failureMessage, "This example is skipped")60    }61}62import XCTest63import Quick64class ItTests: XCTestCase {65    func testSkippingExamplesAreCorrectlyReported() {66        let example = Example("an example that is skipped", { () -> () in67            XCTSkip("This example is skipped")68        })69        let result = example.run()70        XCTAssertTrue(result.skipped)71        XCTAssertEqual(result.failureMessage, "This

1import XCTest2import Quick3import Nimble4class ItTests: XCTestCase {5    func testSkippingExamplesAreCorrectlyReported() {6        let example = Example("example", closure: { pending("skip") })7        let exampleGroup = ExampleGroup("group", children: [example])8        let reporter = TestSuiteReporter()9        let world = World(reporter: reporter)10        world.runExampleGroups([exampleGroup])11        expect(reporter.exampleCount).to(equal(1))12        expect(reporter.pendingExampleCount).to(equal(1))13    }14}15import XCTest16import Quick17class TestSuiteReporter: QuickSpec {18    override func spec() {19        describe("TestSuiteReporter") {20            it("should report the number of examples") {21            }22            it("should report the number of pending examples") {23                pending("skip")24            }25        }26    }27}28import XCTest29import Quick30import Nimble31class ExampleTests: XCTestCase {32    func testPendingExamplesAreReported() {33        let example = Example("example", closure: {34            pending("skip")35        })36        let reporter = TestSuiteReporter()37        let world = World(reporter: reporter)38        world.runExampleGroups([example])39        expect(exampleWasRun).to(beFalse())40        expect(reporter.exampleCount).to(equal(1))41        expect(reporter.pendingExampleCount).to(equal(1))42    }43}44import XCTest45import Quick46import Nimble47class WorldTests: XCTestCase {48    func testRunExampleGroups() {49        let example = Example("example", closure: { exampleWasRun = true })50        let exampleGroup = ExampleGroup("group", children: [example])51        let reporter = TestSuiteReporter()52        let world = World(reporter: reporter)53        world.runExampleGroups([exampleGroup])54        expect(exampleWasRun).to(beTrue())55        expect(reporter.exampleCount).to(equal(1))

1import Quick2import Nimble3class ItTests: QuickSpec {4    override func spec() {5        it("testSkippingExamplesAreCorrectlyReported") {6            expect(true).to(beTrue())7        }8    }9}10import Quick11import Nimble12class ItTests: QuickSpec {13    override func spec() {14        it("testSkippingExamplesAreCorrectlyReported") {15            expect(true).to(beTrue())16        }17    }18}19import Quick20import Nimble21class ItTests: QuickSpec {22    override func spec() {23        it("testSkippingExamplesAreCorrectlyReported") {24            expect(true).to(beTrue())25        }26    }27}28import Quick29import Nimble30class ItTests: QuickSpec {31    override func spec() {32        it("testSkippingExamplesAreCorrectlyReported") {33            expect(true).to(beTrue())34        }35    }36}37import Quick38import Nimble39class ItTests: QuickSpec {40    override func spec() {41        it("testSkippingExamplesAreCorrectlyReported") {42            expect(true).to(beTrue())43        }44    }45}46import Quick47import Nimble48class ItTests: QuickSpec {49    override func spec() {50        it("testSkippingExamplesAreCorrectlyReported") {51            expect(true).to(beTrue())52        }53    }54}55import Quick56import Nimble57class ItTests: QuickSpec {58    override func spec() {59        it("testSkippingExamplesAreCorrectlyReported") {

1import XCTest2import Quick3import Nimble4class ItTests: XCTestCase {5    func testSkippingExamplesAreCorrectlyReported() {6        let example = Example("example", closure: { pending("skip") })7        let exampleGroup = ExampleGroup("group", children: [example])8        let reporter = TestSuiteReporter()9        let world = World(reporter: reporter)10        world.runExampleGroups([exampleGroup])11        expect(reporter.exampleCount).to(equal(1))12        expect(reporter.pendingExampleCount).to(equal(1))13    }14}15import XCTest16import Quick17class TestSuiteReporter: QuickSpec {18    override func spec() {19        describe("TestSuiteReporter") {20            it("should report the number of examples") {21            }22            it("should report the number of pending examples") {23                pending("skip")24            }25        }26    }27}28import XCTest29import Quick30import Nimble31class ExampleTests: XCTestCase {32    func testPendingExamplesAreReported() {33        let example = Example("example", closure: {34            pending("skip")35        })36        let reporter = TestSuiteReporter()37        let world = World(reporter: reporter)38        world.runExampleGroups([example])39        expect(exampleWasRun).to(beFalse())40        expect(reporter.exampleCount).to(equal(1))41        expect(reporter.pendingExampleCount).to(equal(1))42    }43}44import XCTest45import Quick46import Nimble47class WorldTests: XCTestCase {48    func testRunExampleGroups() {49        let example = Example("example", closure: { exampleWasRun = true })50        let exampleGroup = ExampleGroup("group", children: [example])51        let reporter = TestSuiteReporter()52        let world = World(reporter: reporter)53        world.runExampleGroups([exampleGroup])54        expect(exampleWasRun).to(beTrue())55        expect(reporter.exampleCount).to(equal(1))