How to use _qck_testMethodSelectors method of func class

...45    XCTAssertGreaterThanOrEqual(resultOffsetX, 0)46    XCTAssertGreaterThanOrEqual(resultOffsetY, 0)47  }48  49  override class func _qck_testMethodSelectors() -> [_QuickSelectorWrapper] {50    51    //generate parameters52    53    let sizes = [50, 100, 200]54    var testsParameters: [(originalSize: CGSize, targetSize: CGSize)] = []55    var originalSizes: [CGSize] = []56    var targetSizes: [CGSize] = []57    58    for width in sizes {59      for height in sizes {60        originalSizes.append(CGSize(width: width, height: height))61        targetSizes.append(CGSize(width: width, height: height))62      }63    }64    65    for originalSize in originalSizes {66      for targetSize in targetSizes {67        testsParameters.append((originalSize: originalSize, targetSize: targetSize))68      }69    }70    71    return testsParameters.map { parameter in72      /// first we wrap our test method in block that takes TestCase instance73      let block: @convention(block) (Self) -> Void = { $0.methodToTestWithParameters(originalSize: parameter.originalSize, targetSize: parameter.targetSize) }74      /// with help of ObjC runtime we add new test method to class75      let implementation = imp_implementationWithBlock(block)76      let selectorName = "test_\(parameter)"77      let selector = NSSelectorFromString(selectorName)78      class_addMethod(self, selector, implementation, "v@:")79      /// and return wrapped selector on new created method80      return _QuickSelectorWrapper(selector: selector)81    }82  }83}84class VideoTransformationComposerAspectFillOnlyCropTests: ParametrizedTestCase {85  func methodToTestWithParameters(originalSize: CGSize, crop: Crop) {86    87    //only crop, no additional resize to fill occur88    let targetWidth = (originalSize.width * (1.0 - (crop.left + crop.right) / 100.0)).rounded()89    let targetHeight = (originalSize.height * (1.0 - (crop.top + crop.bottom) / 100.0)).rounded()90    91    let targetSize = CGSize(width: targetWidth,92                            height: targetHeight)93    94    let resizeContentMode = ResizeContentMode.aspectFill(targetSize)95    96    let transformationComposer = VideoTransformationComposer(originalSize: originalSize,97                                                             cropPerCent: crop,98                                                             resizeContentMode: resizeContentMode)99    100    101    let transformationParameters = transformationComposer.transformationParameters102    103    let inputWidth = originalSize.width104    let inputHeight = originalSize.height105    106    let resultOffsetX = transformationParameters.crop.x107    let resultOffsetY = transformationParameters.crop.y108    109    let resultRemainedWidth = inputWidth - resultOffsetX - (targetSize.width / transformationParameters.scale.x)110    let resultRemainedHeight = inputHeight - resultOffsetY - (targetSize.height / transformationParameters.scale.y)111    112    XCTAssertLessThanOrEqual(abs(resultOffsetX - (crop.left * originalSize.width / 100.0)).rounded(), 1)113    XCTAssertLessThanOrEqual(abs(resultOffsetY - (crop.top * originalSize.height / 100.0)).rounded(), 1)114    XCTAssertLessThanOrEqual(abs(resultRemainedWidth - (crop.right * originalSize.width / 100.0)).rounded(), 1)115    XCTAssertLessThanOrEqual(abs(resultRemainedHeight - (crop.bottom * originalSize.height / 100.0)).rounded(), 1)116    117    XCTAssertEqual(transformationParameters.targetSize, targetSize)118  }119  120  override class func _qck_testMethodSelectors() -> [_QuickSelectorWrapper] {121    122    //generate parameters123    124    let sizes: [CGFloat] = [50, 100, 200]125    let cropAmounts: [CGFloat] = [5, 0]126    127    var testsParameters: [(originalSize: CGSize, crop: Crop)] = []128    var originalSizes: [CGSize] = []129    130    var crops: [Crop] = []131    132    for width in sizes {133      for height in sizes {134        originalSizes.append(CGSize(width: width, height: height))135      }136    }137    138    for top in cropAmounts {139      for bottom in cropAmounts {140        for left in cropAmounts {141          for right in cropAmounts {142            let crop = Crop(top: top, left: left, bottom: bottom, right: right)143            crops.append(crop)144          }145        }146      }147    }148    149    for originalSize in originalSizes {150      for crop in crops {151        testsParameters.append((originalSize: originalSize, crop: crop))152      }153    }154    155    return testsParameters.map { parameter in156      /// first we wrap our test method in block that takes TestCase instance157      let block: @convention(block) (Self) -> Void = { $0.methodToTestWithParameters(originalSize: parameter.originalSize, crop: parameter.crop) }158      /// with help of ObjC runtime we add new test method to class159      let implementation = imp_implementationWithBlock(block)160      161      let selectorName = "test_\(parameter)"162      let selector = NSSelectorFromString(selectorName)163      class_addMethod(self, selector, implementation, "v@:")164      /// and return wrapped selector on new created method165      return _QuickSelectorWrapper(selector: selector)166    }167  }168}169class VideoTransformationComposerAspectFillResizeWithCropTests: ParametrizedTestCase {170  func methodToTestWithParameters(originalSize: CGSize, targetSize: CGSize, crop: Crop) {171    //step1 - perform crop only transformation172    173    let cropTargetWidth = (originalSize.width * (1.0 - (crop.left + crop.right) / 100.0)).rounded()174    let cropTargetHeight = (originalSize.height * (1.0 - (crop.top + crop.bottom) / 100.0)).rounded()175    176    let cropTargetSize = CGSize(width: cropTargetWidth,177                                height: cropTargetHeight)178    179    let cropResizeContentMode = ResizeContentMode.aspectFill(cropTargetSize)180    181    let cropTransformationComposer = VideoTransformationComposer(originalSize: originalSize,182                                                                 cropPerCent: crop,183                                                                 resizeContentMode: cropResizeContentMode)184    185    let cropTransformationParameters = cropTransformationComposer.transformationParameters186    187    let originalSizeInputWidthToCrop = originalSize.width188    let originalSizeInputHeightToCrop = originalSize.height189    190    let cropResultOffsetX = cropTransformationParameters.crop.x191    let cropResultOffsetY = cropTransformationParameters.crop.y192    193    let cropResultRemainedWidth = originalSizeInputWidthToCrop - cropResultOffsetX - (cropTargetSize.width / cropTransformationParameters.scale.x)194    let cropResultRemainedHeight = originalSizeInputHeightToCrop - cropResultOffsetY - (cropTargetSize.height / cropTransformationParameters.scale.y)195    196    197    XCTAssertLessThanOrEqual(abs(cropResultOffsetX - (crop.left * originalSize.width / 100.0)).rounded(), 1)198    XCTAssertLessThanOrEqual(abs(cropResultOffsetY - (crop.top * originalSize.height / 100.0)).rounded(), 1)199    XCTAssertLessThanOrEqual(abs(cropResultRemainedWidth - (crop.right * originalSize.width / 100.0)).rounded(), 1)200    XCTAssertLessThanOrEqual(abs(cropResultRemainedHeight - (crop.bottom * originalSize.height / 100.0)).rounded(), 1)201    202    XCTAssertEqual(cropTransformationParameters.targetSize, cropTargetSize)203    204    205    206    //step2 - resize cropped result207    208    let croppedResultResizeContentMode = ResizeContentMode.aspectFill(targetSize)209    210    let croppedResultTransformationComposer = VideoTransformationComposer(originalSize: cropTargetSize,211                                                                          cropPerCent: Crop.zero,212                                                                          resizeContentMode: croppedResultResizeContentMode)213    214    let croppedResultTransformationParameters = croppedResultTransformationComposer.transformationParameters215    216    let inputWidth = cropTargetSize.width217    let inputHeight = cropTargetSize.height218    219    let croppedResultOffsetX = croppedResultTransformationParameters.crop.x220    let croppedResultOffsetY = croppedResultTransformationParameters.crop.y221    222    let croppedResultRemainedWidth = inputWidth - croppedResultOffsetX - (targetSize.width / croppedResultTransformationParameters.scale.x)223    let croppedResultRemainedHeight = inputHeight - croppedResultOffsetY - (targetSize.height / croppedResultTransformationParameters.scale.y)224    225    226    227    XCTAssertEqual(croppedResultTransformationParameters.targetSize, targetSize)228  229    //at least any of cropX, cropY should be zero, because aspect fill resize should be centered230    XCTAssertEqual((croppedResultOffsetX + croppedResultRemainedWidth) * (croppedResultOffsetY + croppedResultRemainedHeight), 0)231    232    233    //step3 -  perform crop and resize at once234    235    let resizeContentMode = ResizeContentMode.aspectFill(targetSize)236    237    let transformationComposer = VideoTransformationComposer(originalSize: originalSize,238                                                             cropPerCent: crop,239                                                             resizeContentMode: resizeContentMode)240    241    let transformationParameters = transformationComposer.transformationParameters242    243    let originalSizeInputWidth = originalSize.width244    let originalSizeInputHeight = originalSize.height245    246    let resultOffsetX = transformationParameters.crop.x247    let resultOffsetY = transformationParameters.crop.y248    249    let resultRemainedWidth = originalSizeInputWidth - resultOffsetX - (targetSize.width / transformationParameters.scale.x)250    let resultRemainedHeight = originalSizeInputHeight - resultOffsetY - (targetSize.height / transformationParameters.scale.y)251    252    XCTAssertEqual(transformationParameters.targetSize, targetSize)253    254    //compare step1 + step2 with step3255    XCTAssertLessThanOrEqual(abs(resultOffsetX - (cropResultOffsetX + croppedResultOffsetX)), 1)256    XCTAssertLessThanOrEqual(abs(resultOffsetY - (cropResultOffsetY + croppedResultOffsetY)), 1)257    XCTAssertLessThanOrEqual(abs(resultRemainedWidth - (croppedResultRemainedWidth + cropResultRemainedWidth)).rounded(),1)258    XCTAssertLessThanOrEqual(abs(resultRemainedHeight - (croppedResultRemainedHeight + cropResultRemainedHeight)).rounded(), 1)259  }260  261  override class func _qck_testMethodSelectors() -> [_QuickSelectorWrapper] {262    263    //generate parameters264    265    let sizes: [CGFloat] = [50, 100, 200]266    let cropAmounts: [CGFloat] = [5, 0]267    268    var testsParameters: [(originalSize: CGSize, targetSize: CGSize, crop: Crop)] = []269    var originalSizes: [CGSize] = []270    var targetSizes: [CGSize] = []271    var crops: [Crop] = []272    273    for width in sizes {274      for height in sizes {275        originalSizes.append(CGSize(width: width, height: height))...

...43    XCTAssertLessThanOrEqual(resultOffsetX, 0)44    XCTAssertLessThanOrEqual(resultOffsetY, 0)45  }46  47  override class func _qck_testMethodSelectors() -> [_QuickSelectorWrapper] {48    49    //generate parameters50    51    let sizes = [50, 100, 200]52    var testsParameters: [(originalSize: CGSize, targetSize: CGSize)] = []53    var originalSizes: [CGSize] = []54    var targetSizes: [CGSize] = []55    56    for width in sizes {57      for height in sizes {58        originalSizes.append(CGSize(width: width, height: height))59        targetSizes.append(CGSize(width: width, height: height))60      }61    }62    63    for originalSize in originalSizes {64      for targetSize in targetSizes {65        testsParameters.append((originalSize: originalSize, targetSize: targetSize))66      }67    }68    69    return testsParameters.map { parameter in70      /// first we wrap our test method in block that takes TestCase instance71      let block: @convention(block) (Self) -> Void = { $0.methodToTestWithParameters(originalSize: parameter.originalSize, targetSize: parameter.targetSize) }72      /// with help of ObjC runtime we add new test method to class73      let implementation = imp_implementationWithBlock(block)74      let selectorName = "test_\(parameter)"75      let selector = NSSelectorFromString(selectorName)76      class_addMethod(self, selector, implementation, "v@:")77      /// and return wrapped selector on new created method78      return _QuickSelectorWrapper(selector: selector)79    }80  }81}82class VideoTransformationComposerAspectFitOnlyCropTests: ParametrizedTestCase {83  func methodToTestWithParameters(originalSize: CGSize, crop: Crop) {84    85    //only crop, no additional resize to fit occur86    let targetWidth = (originalSize.width * (1.0 - (crop.left + crop.right) / 100.0)).rounded()87    let targetHeight = (originalSize.height * (1.0 - (crop.top + crop.bottom) / 100.0)).rounded()88    89    let targetSize = CGSize(width: targetWidth,90                            height: targetHeight)91    92    let resizeContentMode = ResizeContentMode.aspectFit(targetSize)93    94    let transformationComposer = VideoTransformationComposer(originalSize: originalSize,95                                                             cropPerCent: crop,96                                                             resizeContentMode: resizeContentMode)97    98    99    let transformationParameters = transformationComposer.transformationParameters100    101    let inputWidth = originalSize.width102    let inputHeight = originalSize.height103    104    let resultOffsetX = transformationParameters.crop.x105    let resultOffsetY = transformationParameters.crop.y106    107    let resultRemainedWidth = inputWidth - resultOffsetX - (targetSize.width / transformationParameters.scale.x)108    let resultRemainedHeight = inputHeight - resultOffsetY - (targetSize.height / transformationParameters.scale.y)109    110    XCTAssertLessThanOrEqual(abs(resultOffsetX - (crop.left * originalSize.width / 100.0)).rounded(), 1)111    XCTAssertLessThanOrEqual(abs(resultOffsetY - (crop.top * originalSize.height / 100.0)).rounded(), 1)112    XCTAssertLessThanOrEqual(abs(resultRemainedWidth - (crop.right * originalSize.width / 100.0)).rounded(), 1)113    XCTAssertLessThanOrEqual(abs(resultRemainedHeight - (crop.bottom * originalSize.height / 100.0)).rounded(), 1)114    115    XCTAssertEqual(transformationParameters.targetSize, targetSize)116  }117  118  override class func _qck_testMethodSelectors() -> [_QuickSelectorWrapper] {119    120    //generate parameters121    122    let sizes: [CGFloat] = [50, 100, 200]123    let cropAmounts: [CGFloat] = [5, 0]124    125    var testsParameters: [(originalSize: CGSize, crop: Crop)] = []126    var originalSizes: [CGSize] = []127    128    var crops: [Crop] = []129    130    for width in sizes {131      for height in sizes {132        originalSizes.append(CGSize(width: width, height: height))133      }134    }135    136    for top in cropAmounts {137      for bottom in cropAmounts {138        for left in cropAmounts {139          for right in cropAmounts {140            let crop = Crop(top: top, left: left, bottom: bottom, right: right)141            crops.append(crop)142          }143        }144      }145    }146    147    for originalSize in originalSizes {148      for crop in crops {149        testsParameters.append((originalSize: originalSize, crop: crop))150      }151    }152    153    return testsParameters.map { parameter in154      /// first we wrap our test method in block that takes TestCase instance155      let block: @convention(block) (Self) -> Void = { $0.methodToTestWithParameters(originalSize: parameter.originalSize, crop: parameter.crop) }156      /// with help of ObjC runtime we add new test method to class157      let implementation = imp_implementationWithBlock(block)158      159      let selectorName = "test_\(parameter)"160      let selector = NSSelectorFromString(selectorName)161      class_addMethod(self, selector, implementation, "v@:")162      /// and return wrapped selector on new created method163      return _QuickSelectorWrapper(selector: selector)164    }165  }166}167class VideoTransformationComposerAspectFitResizeWithCropTests: ParametrizedTestCase {168  func methodToTestWithParameters(originalSize: CGSize, targetSize: CGSize, crop: Crop) {169    //step1 - perform crop only transformation170    171    let cropTargetWidth = (originalSize.width * (1.0 - (crop.left + crop.right) / 100.0)).rounded()172    let cropTargetHeight = (originalSize.height * (1.0 - (crop.top + crop.bottom) / 100.0)).rounded()173    174    let cropTargetSize = CGSize(width: cropTargetWidth,175                                height: cropTargetHeight)176    177    let cropResizeContentMode = ResizeContentMode.aspectFill(cropTargetSize)178    179    let cropTransformationComposer = VideoTransformationComposer(originalSize: originalSize,180                                                                 cropPerCent: crop,181                                                                 resizeContentMode: cropResizeContentMode)182    183    let cropTransformationParameters = cropTransformationComposer.transformationParameters184    185    let originalSizeInputWidthToCrop = originalSize.width186    let originalSizeInputHeightToCrop = originalSize.height187    188    let cropResultOffsetX = cropTransformationParameters.crop.x189    let cropResultOffsetY = cropTransformationParameters.crop.y190    191    let cropResultRemainedWidth = originalSizeInputWidthToCrop - cropResultOffsetX - (cropTargetSize.width / cropTransformationParameters.scale.x)192    let cropResultRemainedHeight = originalSizeInputHeightToCrop - cropResultOffsetY - (cropTargetSize.height / cropTransformationParameters.scale.y)193    194    195    XCTAssertLessThanOrEqual(abs(cropResultOffsetX - (crop.left * originalSize.width / 100.0)).rounded(), 1)196    XCTAssertLessThanOrEqual(abs(cropResultOffsetY - (crop.top * originalSize.height / 100.0)).rounded(), 1)197    XCTAssertLessThanOrEqual(abs(cropResultRemainedWidth - (crop.right * originalSize.width / 100.0)).rounded(), 1)198    XCTAssertLessThanOrEqual(abs(cropResultRemainedHeight - (crop.bottom * originalSize.height / 100.0)).rounded(), 1)199    200    XCTAssertEqual(cropTransformationParameters.targetSize, cropTargetSize)201    202    203    204    //step2 - resize cropped result205    206    let croppedResultResizeContentMode = ResizeContentMode.aspectFill(targetSize)207    208    let croppedResultTransformationComposer = VideoTransformationComposer(originalSize: cropTargetSize,209                                                                          cropPerCent: Crop.zero,210                                                                          resizeContentMode: croppedResultResizeContentMode)211    212    let croppedResultTransformationParameters = croppedResultTransformationComposer.transformationParameters213    214    let inputWidth = cropTargetSize.width215    let inputHeight = cropTargetSize.height216    217    let croppedResultOffsetX = croppedResultTransformationParameters.crop.x218    let croppedResultOffsetY = croppedResultTransformationParameters.crop.y219    220    let croppedResultRemainedWidth = inputWidth - croppedResultOffsetX - (targetSize.width / croppedResultTransformationParameters.scale.x)221    let croppedResultRemainedHeight = inputHeight - croppedResultOffsetY - (targetSize.height / croppedResultTransformationParameters.scale.y)222    223    224    225    XCTAssertEqual(croppedResultTransformationParameters.targetSize, targetSize)226  227    //at least any of cropX, cropY should be zero, because aspect fill resize should be centered228    XCTAssertEqual((croppedResultOffsetX + croppedResultRemainedWidth) * (croppedResultOffsetY + croppedResultRemainedHeight), 0)229    230    231    //step3 -  perform crop and resize at once232    233    let resizeContentMode = ResizeContentMode.aspectFill(targetSize)234    235    let transformationComposer = VideoTransformationComposer(originalSize: originalSize,236                                                             cropPerCent: crop,237                                                             resizeContentMode: resizeContentMode)238    239    let transformationParameters = transformationComposer.transformationParameters240    241    let originalSizeInputWidth = originalSize.width242    let originalSizeInputHeight = originalSize.height243    244    let resultOffsetX = transformationParameters.crop.x245    let resultOffsetY = transformationParameters.crop.y246    247    let resultRemainedWidth = originalSizeInputWidth - resultOffsetX - (targetSize.width / transformationParameters.scale.x)248    let resultRemainedHeight = originalSizeInputHeight - resultOffsetY - (targetSize.height / transformationParameters.scale.y)249    250    XCTAssertEqual(transformationParameters.targetSize, targetSize)251    252    //compare step1 + step2 with step3253    XCTAssertLessThanOrEqual(abs(resultOffsetX - (cropResultOffsetX + croppedResultOffsetX)), 1)254    XCTAssertLessThanOrEqual(abs(resultOffsetY - (cropResultOffsetY + croppedResultOffsetY)), 1)255    XCTAssertLessThanOrEqual(abs(resultRemainedWidth - (croppedResultRemainedWidth + cropResultRemainedWidth)).rounded(),1)256    XCTAssertLessThanOrEqual(abs(resultRemainedHeight - (croppedResultRemainedHeight + cropResultRemainedHeight)).rounded(), 1)257  }258  259  override class func _qck_testMethodSelectors() -> [_QuickSelectorWrapper] {260    261    //generate parameters262    263    let sizes: [CGFloat] = [50, 100, 200]264    let cropAmounts: [CGFloat] = [5, 0]265    266    var testsParameters: [(originalSize: CGSize, targetSize: CGSize, crop: Crop)] = []267    var originalSizes: [CGSize] = []268    var targetSizes: [CGSize] = []269    var crops: [Crop] = []270    271    for width in sizes {272      for height in sizes {273        originalSizes.append(CGSize(width: width, height: height))...

...12  func p(_ s: String) {13    print("Magic: \(s)")14  }15  16  override class func _qck_testMethodSelectors() -> [_QuickSelectorWrapper] {17    /// For this example we create 3 runtime tests "test_a", "test_b" and "test_c" with corresponding parameter18    return ["a", "b", "c"].map { parameter in19      /// first we wrap our test method in block that takes TestCase instance20      let block: @convention(block) (RuntimeTestsExample) -> Void = { $0.p(parameter) }21      /// with help of ObjC runtime we add new test method to class22      let implementation = imp_implementationWithBlock(block)23      let selectorName = "test_\(parameter)"24      let selector = NSSelectorFromString(selectorName)25      class_addMethod(self, selector, implementation, "v@:")26      /// and return wrapped selector on new created method27      return _QuickSelectorWrapper(selector: selector)28    }29  }30}...

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

1class func _qck_testMethodSelectors() -> [Selector] {2        #selector(testExample),3        #selector(testPerformanceExample),4}5class func _qck_testMethodSelectors() -> [Selector] {6        #selector(testExample),7        #selector(testPerformanceExample),8}9class _1Tests: XCTestCase {10    func testExample() {11    }12    func testPerformanceExample() {13        self.measure {14        }15    }16}17class _2Tests: XCTestCase {18    func testExample() {19    }20    func testPerformanceExample() {21        self.measure {22        }23    }24}25#if !canImport(ObjectiveC)26public func allTests() -> [XCTestCaseEntry] {27        testCase(_1Tests.allTests),28        testCase(_2Tests.allTests),29}30import XCTest31import _1Tests32var tests = [XCTestCaseEntry]()33tests += _1Tests.allTests()34tests += _2Tests.allTests()35XCTMain(tests)36import PackageDescription37let package = Package(38        .library(39        .package(url: "

1import XCTest2class TestClass: XCTestCase {3    func test1() {4        print("test1")5    }6    func test2() {7        print("test2")8    }9    func test3() {10        print("test3")11    }12    func test4() {13        print("test4")14    }15    func test5() {16        print("test5")17    }18    func test6() {19        print("test6")20    }21    func test7() {22        print("test7")23    }24    func test8() {25        print("test8")26    }27    func test9() {28        print("test9")29    }30    func test10() {31        print("test10")32    }33    func test11() {34        print("test11")35    }36    func test12() {37        print("test12")38    }39    func test13() {40        print("test13")41    }42    func test14() {43        print("test14")44    }45    func test15() {46        print("test15")47    }48    func test16() {49        print("test16")50    }51    func test17() {52        print("test17")53    }54    func test18() {55        print("test18")56    }57    func test19() {58        print("test19")59    }60    func test20() {61        print("test20")62    }63    func test21() {64        print("test21")65    }66    func test22() {67        print("test22")68    }69    func test23() {70        print("test23")71    }72    func test24() {73        print("test24")74    }75    func test25() {76        print("test25")77    }78    func test26() {79        print("test26")80    }81    func test27() {82        print("test27")83    }84    func test28() {85        print("test28")86    }87    func test29() {88        print("test29")89    }90    func test30() {91        print("test30")92    }93    func test31() {94        print("test31")95    }96    func test32() {97        print("test32")98    }99    func test33() {100        print("test33")101    }102    func test34() {103        print("test34")104    }105    func test35() {

1import XCTest2import Quick3class MyQuickSpec: QuickSpec {4    override func spec() {5        describe("MyQuickSpec") {6            it("works") {7                print("works")8            }9        }10    }11}12class MyXCTestCase: XCTestCase {13    func testMethodSelectors() {14        let selectors = MyQuickSpec._qck_testMethodSelectors()15        XCTAssertEqual(selectors.count, 1)16        XCTAssertEqual(selectors[0].description, "testWorks")17    }18}19import XCTest20import Quick21class MyQuickSpec: QuickSpec {22    override func spec() {23        describe("MyQuickSpec") {24            it("works") {25                print("works")26            }27        }28    }29}30class MyXCTestCase: XCTestCase {31    func testMethodSelectors() {32        let selectors = MyQuickSpec._qck_testMethodSelectors()33        XCTAssertEqual(selectors.count, 1)34        XCTAssertEqual(selectors[0].description, "testWorks")35    }36}37import XCTest38import Quick39class MyQuickSpec: QuickSpec {40    override func spec() {41        describe("MyQuickSpec") {42            it("works") {43                print("works")44            }45        }46    }47}48class MyXCTestCase: XCTestCase {49    func testMethodSelectors() {50        let selectors = MyQuickSpec._qck_testMethodSelectors()51        XCTAssertEqual(selectors.count, 1)52        XCTAssertEqual(selectors[0].description, "testWorks")53    }54}55import XCTest56import Quick57class MyQuickSpec: QuickSpec {58    override func spec() {59        describe("MyQuickSpec") {60            it("works") {61                print("works")62            }63        }64    }65}66class MyXCTestCase: XCTestCase {67    func testMethodSelectors() {68        let selectors = MyQuickSpec._qck_testMethodSelectors()69        XCTAssertEqual(selectors.count, 1)70        XCTAssertEqual(selectors[0].description, "testWorks")71    }72}73import XCTest74import Quick

1import XCTest2import Quick3class TestClass: QuickSpec {4    override func spec() {5        describe("TestClass") {6            it("test method 1") {7                print("test method 1")8            }9            it("test method 2") {10                print("test method 2")11            }12        }13    }14}15let testClass = TestClass()16let testMethods = testClass._qck_testMethodSelectors()17for testMethod in testMethods {18    testClass.perform(testMethod)19}20import XCTest21import Quick22class TestClass: QuickSpec {23    override func spec() {24        describe("TestClass") {25            it("test method 1") {26                print("test method 1")27            }28            it("test method 2") {29                print("test method 2")30            }31        }32    }33}34let testClass = TestClass()35let testMethods = testClass._qck_testMethodSelectors()36for testMethod in testMethods {37    testClass.perform(testMethod)38}39import XCTest40import Quick41class TestClass: QuickSpec {42    override func spec() {43        describe("TestClass") {44            it("test method 1") {45                print("test method 1")46            }47            it("test method 2") {48                print("test method 2")49            }50        }51    }52}53let testClass = TestClass()54let testMethods = testClass._qck_testMethodSelectors()55for testMethod in testMethods {56    testClass.perform(testMethod)57}58import XCTest59import Quick60class TestClass: QuickSpec {61    override func spec() {62        describe("TestClass") {63            it("test method 1") {64                print("test method 1")65            }66            it("