How to use ClassUnderTest class

1//2//  MemoryGameViewModelTests.swift3//  MemoryGameTests4//5//  Created by Gary O'Donoghue on 08/10/2018.6//  Copyright © 2018 Gary O'Donoghue. All rights reserved.7//8import UIKit9import XCTest10/// Test class used to test the logic within MemoryGameViewModel11class MemoryGameViewModelTests: XCTestCase {12    var classUnderTest : MemoryGameViewModel?13    14    override func setUp() {15        classUnderTest = MemoryGameViewModel()16    }17    func testHandleCardSelectionWhenCardIsShown() {18        // Arrange.19        let card = MemoryGameCard()20        classUnderTest?.allImagesLoaded = true21        22        // Act.23        let response = classUnderTest!.handleCardSelection(selectedCard: card, difficulty: 16)24        25        // Assert.26        XCTAssertFalse(response)27    }28    29    func testHandleCardSelectionWhenAllImagesHaveNotYetLoaded() {30        // Arrange.31        let card = MemoryGameCard()32        card.isShown = true33        classUnderTest?.allImagesLoaded = false34        35        // Act.36        let response = classUnderTest!.handleCardSelection(selectedCard: card, difficulty: 16)37        38        // Assert.39        XCTAssertFalse(response)40    }41    42    func testUserFlipsFirstCard() {43        // Arrange.44        let card = MemoryGameCard()45        card.isShown = true46        classUnderTest?.allImagesLoaded = true47        48        // Act.49        let response = classUnderTest!.handleCardSelection(selectedCard: card, difficulty: 16)50        51        // Assert.52        XCTAssertFalse(response)53    }54    55    func testUserMatchesFirstPair() {56        // Arrange.57        classUnderTest?.allImagesLoaded = true58        let cardImage = UIImage()59        60        let card1 = MemoryGameCard()61        card1.isShown = false62        card1.cardImage = cardImage63        64        let card2 = MemoryGameCard()65        card2.isShown = false66        card2.cardImage = cardImage67        68        // Act.69        let response1 = classUnderTest!.handleCardSelection(selectedCard: card1, difficulty: 16)70        let response2 = classUnderTest!.handleCardSelection(selectedCard: card2, difficulty: 16)71        72        // Assert.73        XCTAssertFalse(response1)74        XCTAssertFalse(response2)75        XCTAssertEqual(classUnderTest?.userScore, 1)76    }77    78    func testUserMatchesAllCardsAndFinishesGame() {79        // Arrange.80        classUnderTest?.allImagesLoaded = true81        let cardImage = UIImage()82        83        let card1 = MemoryGameCard()84        card1.isShown = false85        card1.cardImage = cardImage86        87        let card2 = MemoryGameCard()88        card2.isShown = false89        card2.cardImage = cardImage90        91        // Act.92        let response1 = classUnderTest!.handleCardSelection(selectedCard: card1, difficulty: 2)93        let response2 = classUnderTest!.handleCardSelection(selectedCard: card2, difficulty: 2)94        95        // Assert.96        XCTAssertFalse(response1)97        XCTAssertTrue(response2)98        XCTAssertEqual(classUnderTest?.userScore, 6)99    }100    101    func testDecrementTimer(){102        // Arrange.103        104        // Act.105        let response = classUnderTest?.decrementTimer()106        107        // Assert.108        XCTAssertEqual(response, "59s")109    }110    111    func testDecrementTimerTimeUp(){112        // Arrange.113        classUnderTest?.remainingTime = 1114        115        // Act.116        let response = classUnderTest?.decrementTimer()117        118        // Assert.119        XCTAssertEqual(response, "0s")120        XCTAssertTrue((classUnderTest?.gameOver)!)121    }122}...

1import XCTest2@testable import SchedulerDemo3class DelayerTests: XCTestCase {4    func testOriginalDelayer() throws {5        // Given6        // Pick any of three Delayers - the test works with all of them.7        let classUnderTest = OriginalDelayer()8//        let classUnderTest = CombineDelayer()9//        let classUnderTest = ReactiveSwiftDelayer()10        // When11        let exp1 = XCTestExpectation(description: "")12        let exp2 = XCTestExpectation(description: "")13        classUnderTest.recordDelayed("testString")14        // Then15        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {16            XCTAssertEqual(classUnderTest.recorded, "")17            exp1.fulfill()18        }19        DispatchQueue.main.asyncAfter(deadline: .now() + 1.2) {20            XCTAssertEqual(classUnderTest.recorded, "testString")21            exp2.fulfill()22        }23        wait(for: [exp1, exp2], timeout: 2)24    }25    func testCombineDelayer() throws {26        // Set up for this test only:27        let testScheduler = DispatchQueue.test28        // Given29        let classUnderTest = CombineDelayer(scheduler: testScheduler.eraseToAnyScheduler())30        // When31        classUnderTest.recordDelayed("testString")32        testScheduler.advance(by: 0.5)33        XCTAssertEqual(classUnderTest.recorded, "")34        testScheduler.advance(by: 0.7)35        XCTAssertEqual(classUnderTest.recorded, "testString")36    }37    func testReactiveSwiftDelayer() throws {38        // Set up for this test only.39        // This changes the global variable ReactiveScheduler.main40        let testScheduler = ReactiveScheduler.setUpTest()41        // Given42        let classUnderTest = ReactiveSwiftDelayer()43        // When44        classUnderTest.recordDelayed("testString")45        // Then46        testScheduler.advance(by: 0.5)47        XCTAssertEqual(classUnderTest.recorded, "")48        testScheduler.advance(by: 0.7)49        XCTAssertEqual(classUnderTest.recorded, "testString")50        // Tear down for this test only:51        ReactiveScheduler.tearDownTest()52    }53}...

1import XCTest2@testable import PicsLock3class FileServiceTests: XCTestCase {4//  5//  let classUnderTest = FileService()6//  7//8//  func testFoldersAtNonEmptyDir() throws {9//    guard let testUrl = testURL else { XCTFail(); return }10//    11//    classUnderTest.createFolder(folderName: "test", codeHash: nil, at: testURL)12//    let folders = classUnderTest.folders(at: testUrl)13//    14//    XCTAssertEqual(folders.count, 1)15//    16//    for folder in folders {17//      try? FileManager.default.removeItem(atPath: "\(folder.path)")18//    }19//    20//    let folders2 = classUnderTest.folders(at: testUrl)21//    XCTAssertEqual(folders2.count, 0)22//  }23// 24//  25//  private var testURL: URL? {26//    try? FileManager.default.url(for: .developerDirectory, in: .userDomainMask, appropriateFor: nil, create: false)27//  }28//  29//  30//  31//  func deleteAll(){32//    let folders = classUnderTest.folders(at: testURL)33//34//    for folder in folders {35//      try? FileManager.default.removeItem(atPath: "\(folder.path)")36//    }37//  }38}...

1import Nimble2import Quick3class ClassUnderTestSpec: QuickSpec {4    override func spec() {5        describe("ClassUnderTest") {6            beforeEach {7                classUnderTest = ClassUnderTest()8            }9            afterEach {10            }11            describe("methodUnderTest") {12                it("should return true") {13                    expect(classUnderTest.methodUnderTest()).to(beTrue())14                }15            }16        }17    }18}19import Quick20import Nimble21class ClassUnderTestSpec: QuickSpec {22    override func spec() {23        describe("ClassUnderTest") {24            beforeEach {25                classUnderTest = ClassUnderTest()26            }27            afterEach {28            }29            describe("methodUnderTest") {30                it("should return true") {31                    expect(classUnderTest.methodUnderTest()).to(beTrue())32                }33            }34        }35    }36}37import Quick38import Nimble39class ClassUnderTestSpec: QuickSpec {40    override func spec() {41        describe("ClassUnderTest") {42            beforeEach {43                classUnderTest = ClassUnderTest()44            }45            afterEach {46            }47            describe("methodUnderTest") {48                it("should return true") {49                    expect(classUnderTest.methodUnderTest()).to(beTrue())50                }51            }52        }53    }54}55import Quick56import Nimble57class ClassUnderTestSpec: QuickSpec {58    override func spec() {59        describe("ClassUnderTest") {60            beforeEach {61                classUnderTest = ClassUnderTest()62            }63            afterEach {64            }65            describe("methodUnderTest") {66                it("should return true") {67                    expect(classUnderTest.methodUnderTest()).to(beTrue())68                }69            }70        }71    }72}73import Quick74import Nimble75class ClassUnderTestSpec: QuickSpec {76    override func spec() {77        describe("ClassUnderTest") {78            beforeEach {79                classUnderTest = ClassUnderTest()80            }81            afterEach {

1import Nimble2import Quick3class ClassUnderTestSpec: QuickSpec {4    override func spec() {5        describe("ClassUnderTest") {6            beforeEach {7                sut = ClassUnderTest()8            }9            context("when initialized") {10                it("should have a name") {11                    expect(sut.name).to(equal("John"))12                }13            }14        }15    }16}17import Nimble18import Quick19class ClassUnderTestSpec: QuickSpec {20    override func spec() {21        describe("ClassUnderTest") {22            beforeEach {23                sut = ClassUnderTest()24            }25            context("when initialized") {26                it("should have a name") {27                    expect(sut.name).to(equal("John"))28                }29            }30        }31    }32}33import Nimble34import Quick35class ClassUnderTestSpec: QuickSpec {36    override func spec() {37        describe("ClassUnderTest") {38            beforeEach {39                sut = ClassUnderTest()40            }41            context("when initialized") {42                it("should have a name") {43                    expect(sut.name).to(equal("John"))44                }45            }46        }47    }48}49import Nimble50import Quick51class ClassUnderTestSpec: QuickSpec {52    override func spec() {53        describe("ClassUnderTest") {54            beforeEach {55                sut = ClassUnderTest()56            }57            context("when initialized") {58                it("should have a name") {59                    expect(sut.name).to(equal("John"))60                }61            }62        }63    }64}65import Nimble66import Quick67class ClassUnderTestSpec: QuickSpec {68    override func spec() {69        describe("ClassUnderTest") {70            beforeEach {71                sut = ClassUnderTest()72            }73            context("when initialized") {74                it("should have a name") {75                    expect(sut.name).to(equal("John"))76                }77            }78        }79    }80}

1import Nimble2import Quick3class ClassUnderTestSpec: QuickSpec {4    override func spec() {5        describe("ClassUnderTest") {6            beforeEach {7                sut = ClassUnderTest()8            }9            context("when initialized") {10                it("has a default property") {11                    expect(sut.property).to(equal("default"))12                }13            }14        }15    }16}17import Quick18import Nimble19class ClassUnderTestSpec: QuickSpec {20    override func spec() {21        describe("ClassUnderTest") {22            beforeEach {23                sut = ClassUnderTest()24            }25            context("when initialized") {26                it("has a default property") {27                    expect(sut.property).to(equal("default"))28                }29            }30        }31    }32}33import Quick34import Nimble35class ClassUnderTestSpec: QuickSpec {36    override func spec() {37        describe("ClassUnderTest") {38            beforeEach {39                sut = ClassUnderTest()40            }41            context("when initialized") {42                it("has a default property") {43                    expect(sut.property).to(equal("default"))44                }45            }46        }47    }48}49import Nimble50import Quick51class ClassUnderTestSpec: QuickSpec {52    override func spec() {53        describe("ClassUnderTest") {54            beforeEach {55                sut = ClassUnderTest()56            }57            context("when initialized") {58                it("has a default property") {59                    expect(sut.property).to(equal("default"))60                }61            }62        }63    }64}65import Quick66import Nimble67class ClassUnderTestSpec: QuickSpec {68    override func spec() {69        describe("ClassUnderTest") {70            beforeEach {71                sut = ClassUnderTest()72            }73            context("when initialized") {74                it("has a default property") {75                    expect(sut.property).to(equal("default"))76                }77            }78        }79    }80}81import

1import Nimble2import Quick3import XCTest4class ClassUnderTestTests: QuickSpec {5    override func spec() {6        describe("ClassUnderTest") {7            beforeEach {8                sut = ClassUnderTest()9            }10            context("when initialized") {11                it("should have a default value") {12                    expect(sut.value) == "default"13                }14            }15            context("when set to a new value") {16                it("should have the new value") {17                    expect(sut.value) == "new"18                }19            }20        }21    }22}23import Nimble24import Quick25import XCTest26class ClassUnderTestTests: QuickSpec {27    override func spec() {28        describe("ClassUnderTest") {29            beforeEach {30                sut = ClassUnderTest()31            }32            context("when initialized") {33                it("should have a default value") {34                    expect(sut.value) == "default"35                }36            }37            context("when set to a new value") {38                it("should have the new value") {39                    expect(sut.value) == "new"40                }41            }42        }43    }44}45import Nimble46import Quick47import XCTest48class ClassUnderTestTests: QuickSpec {49    override func spec() {50        describe("ClassUnderTest") {51            beforeEach {52                sut = ClassUnderTest()53            }54            context("when initialized") {55                it("should have a default value") {56                    expect(sut.value) == "default"57                }58            }59            context("when set to a new value") {60                it("should have the new value") {61                    expect(sut.value) == "new"62                }63            }64        }65    }66}67import Nimble68import Quick69import XCTest70class ClassUnderTestTests: QuickSpec {71    override func spec() {72        describe("ClassUnderTest") {73            beforeEach {74                sut = ClassUnderTest()75            }76            context("when initialized") {77                it("should have a default value") {

1import Nimble2import Quick3import XCTest4class ClassUnderTestSpec: QuickSpec {5    override func spec() {6        describe("ClassUnderTest") {7            beforeEach {8                sut = ClassUnderTest()9            }10            it("should return 42") {11                expect(sut.get42()).to(equal(42))12            }13        }14    }15}16import Nimble17import Quick18import XCTest19class ClassUnderTestSpec: QuickSpec {20    override func spec() {21        describe("ClassUnderTest") {22            beforeEach {23                sut = ClassUnderTest()24            }25            it("should return 42") {26                expect(sut.get42()).to(equal(42))27            }28        }29    }30}31import Nimble32import Quick33import XCTest34class ClassUnderTestSpec: QuickSpec {35    override func spec() {36        describe("ClassUnderTest") {37            beforeEach {38                sut = ClassUnderTest()39            }40            it("should return 42") {41                expect(sut.get42()).to(equal(42))42            }43        }44    }45}46import Nimble47import Quick48import XCTest49class ClassUnderTestSpec: QuickSpec {50    override func spec() {51        describe("ClassUnderTest") {52            beforeEach {53                sut = ClassUnderTest()54            }55            it("should return 42") {56                expect(sut.get42()).to(equal(42))57            }58        }59    }60}61import Nimble62import Quick63import XCTest64class ClassUnderTestSpec: QuickSpec {65    override func spec() {66        describe("ClassUnderTest") {67            beforeEach {68                sut = ClassUnderTest()69            }70            it("should return 42") {71                expect(sut.get42()).to(equal(42))72            }73        }74    }75}76import Nimble77import Quick78import XCTest79class ClassUnderTestSpec: QuickSpec {

1import ClassUnderTest2import Nimble3import Quick4class ClassUnderTestSpec: QuickSpec {5    override func spec() {6        describe("ClassUnderTest") {7            it("is a test") {8                expect(true).to(beTrue())9            }10        }11    }12}13import ClassUnderTest14import Nimble15import Quick16class ClassUnderTestSpec: QuickSpec {17    override func spec() {18        describe("ClassUnderTest") {19            it("is a test") {20                expect(true).to(beTrue())21            }22        }23    }24}25import ClassUnderTest26import Nimble27import Quick28class ClassUnderTestSpec: QuickSpec {29    override func spec() {30        describe("ClassUnderTest") {31            it("is a test") {32                expect(true).to(beTrue())33            }34        }35    }36}37import ClassUnderTest38import Nimble39import Quick40class ClassUnderTestSpec: QuickSpec {41    override func spec() {42        describe("ClassUnderTest") {43            it("is a test") {44                expect(true).to(beTrue())45            }46        }47    }48}49import ClassUnderTest50import Nimble51import Quick52class ClassUnderTestSpec: QuickSpec {53    override func spec() {54        describe("ClassUnderTest") {55            it("is a test") {56                expect(true).to(beTrue())57            }58        }59    }60}61import ClassUnderTest62import Nimble63import Quick64class ClassUnderTestSpec: QuickSpec {65    override func spec() {66        describe("ClassUnderTest") {67            it("is a test") {68                expect(true).to(beTrue())69            }70        }71    }72}73import ClassUnderTest74import Nimble75import Quick76class ClassUnderTestSpec: QuickSpec {77    override func spec() {78        describe("ClassUnderTest") {79            it("is a test") {80                expect(true).to(beTrue())81            }82        }

1import Nimble2import Quick3@testable import ClassUnderTest4class ClassUnderTestSpec: QuickSpec {5    override func spec() {6        describe("ClassUnderTest") {7            context("when initialized with a string") {8                it("should return the string") {9                    let classUnderTest = ClassUnderTest(string: "Hello")10                    expect(classUnderTest.string).to(equal("Hello"))11                }12            }13        }14    }15}16import Nimble17import Quick18@testable import ClassUnderTest19class ClassUnderTestSpec: QuickSpec {20    override func spec() {21        describe("ClassUnderTest") {22            context("when initialized with a string") {23                it("should return the string") {24                    let classUnderTest = ClassUnderTest(string: "Hello")25                    expect(classUnderTest.string).to(equal("Hello"))26                }27            }28        }29    }30}31import Nimble32import Quick33@testable import ClassUnderTest34class ClassUnderTestSpec: QuickSpec {35    override func spec() {36        describe("ClassUnderTest") {37            context("when initialized with a string") {38                it("should return the string") {39                    let classUnderTest = ClassUnderTest(string: "Hello")40                    expect(classUnderTest.string).to(equal("Hello"))41                }42            }43        }44    }45}46import Nimble47import Quick48@testable import ClassUnderTest49class ClassUnderTestSpec: QuickSpec {50    override func spec() {51        describe("ClassUnderTest") {52            context("when initialized with a string") {53                it("should return the string") {54                    let classUnderTest = ClassUnderTest(string: "Hello")55                    expect(classUnderTest.string).to(equal("Hello"))56                }57            }58        }59    }60}61import Nimble62import Quick63@testable import ClassUnderTest64class ClassUnderTestSpec: QuickSpec {65    override func spec() {66        describe("ClassUnderTest") {67            context("when initialized with a string") {68                it("should return the string") {69                    let classUnderTest = ClassUnderTest(string: "Hello")70                    expect(classUnderTest.string).to(equal("Hello"))71                }72            }73        }74    }75}

1import Nimble2import Quick3@testable import ClassUnderTest4class ClassUnderTestSpec: QuickSpec {5    override func spec() {6        describe("ClassUnderTest") {7            it("should return true") {8                expect(ClassUnderTest().isTrue()).to(beTrue())9            }10        }11    }12}13import Nimble14import Quick15@testable import ClassUnderTest16class ClassUnderTestSpec: QuickSpec {17    override func spec() {18        describe("ClassUnderTest") {19            it("should return true") {20                expect(ClassUnderTest().isTrue()).to(beTrue())21            }22        }23    }24}25import Nimble26import Quick27@testable import ClassUnderTest28class ClassUnderTestSpec: QuickSpec {29    override func spec() {30        describe("ClassUnderTest") {31            it("should return true") {32                expect(ClassUnderTest().isTrue()).to(beTrue())33            }34        }35    }36}37import Nimble38import Quick39@testable import ClassUnderTest40class ClassUnderTestSpec: QuickSpec {41    override func spec() {42        describe("ClassUnderTest") {43            it("should return true") {44                expect(ClassUnderTest().isTrue()).to(beTrue())45            }46        }47    }48}49import Nimble50import Quick51@testable import ClassUnderTest52class ClassUnderTestSpec: QuickSpec {53    override func spec() {54        describe("ClassUnderTest") {55            it("should return true") {56                expect(ClassUnderTest().isTrue()).to(beTrue())57            }58        }59    }60}61import Nimble62import Quick63@testable import ClassUnderTest64class ClassUnderTestSpec: QuickSpec {65    override func spec() {66        describe("ClassUnderTest") {67            it("should return true") {68                expect(ClassUnderTest().isTrue()).to(beTrue())69            }70        }71    }72}73import Nimble74import Quick75@testable import ClassUnderTest76class ClassUnderTestSpec: QuickSpec {77    override func spec() {78        describe("ClassUnderTest") {79            it("

1import Nimble2import Quick3class ClassUnderTestSpec: QuickSpec {4    override func spec() {5        describe("ClassUnderTest") {6            context("when it is initialized") {7                it("should have a property called 'property'") {8                    let sut = ClassUnderTest()9                    expect(sut.property).to(equal("property"))10                }11            }12        }13    }14}15import Nimble16import Quick17class ClassUnderTestSpec: QuickSpec {18    override func spec() {19        describe("ClassUnderTest") {20            context("when it is initialized") {21                it("should have a property called 'property'") {22                    let sut = ClassUnderTest()23                    expect(sut.property).to(equal("property"))24                }25            }26        }27    }28}29import Nimble30import Quick31class ClassUnderTestSpec: QuickSpec {32    override func spec() {33        describe("ClassUnderTest") {34            context("when it is initialized") {35                it("should have a property called 'property'") {36                    let sut = ClassUnderTest()37                    expect(sut.property).to(equal("property"))38                }39            }40        }41    }42}43import Nimble44import Quick45class ClassUnderTestSpec: QuickSpec {46    override func spec() {47        describe("ClassUnderTest") {48            context("when it is initialized") {49                it("should have a property called 'property'") {50                    let sut = ClassUnderTest()51                    expect(sut.property).to(equal("property"))52                }53            }54        }55    }56}57import Nimble58import Quick59class ClassUnderTestSpec: QuickSpec {60    override func spec() {61        describe("ClassUnderTest") {62            context("when it is initialized") {63                it("should have a property called 'property'") {64                    let sut = ClassUnderTest()65                    expect(sut.property).to(equal("property"))66                }67            }68        }69    }70}71@testable import ClassUnderTest72class ClassUnderTestSpec: QuickSpec {73    override func spec() {74        describe("ClassUnderTest") {75            context("when initialized with a string") {76                it("should return the string") {77                    let classUnderTest = ClassUnderTest(string: "Hello")78                    expect(classUnderTest.string).to(equal("Hello"))79                }80            }81        }82    }83}84import Nimble85import Quick86@testable import ClassUnderTest87class ClassUnderTestSpec: QuickSpec {88    override func spec() {89        describe("ClassUnderTest") {90            context("when initialized with a string") {91                it("should return the string") {92                    let classUnderTest = ClassUnderTest(string: "Hello")93                    expect(classUnderTest.string).to(equal("Hello"))94                }95            }96        }97    }98}99import Nimble100import Quick101@testable import ClassUnderTest102class ClassUnderTestSpec: QuickSpec {103    override func spec() {104        describe("ClassUnderTest") {105            context("when initialized with a string") {106                it("should return the string") {107                    let classUnderTest = ClassUnderTest(string: "Hello")108                    expect(classUnderTest.string).to(equal("Hello"))109                }110            }111        }112    }113}114import Nimble115import Quick116@testable import ClassUnderTest117class ClassUnderTestSpec: QuickSpec {118    override func spec() {119        describe("ClassUnderTest") {120            context("when initialized with a string") {121                it("should return the string") {122                    let classUnderTest = ClassUnderTest(string: "Hello")123                    expect(classUnderTest.string).to(equal("Hello"))124                }125            }126        }127    }128}129import Nimble130import Quick131@testable import ClassUnderTest132class ClassUnderTestSpec: QuickSpec {133    override func spec() {134        describe("ClassUnderTest") {135            context("when initialized with a string") {136                it("should return the string") {137                    let classUnderTest = ClassUnderTest(string: "Hello")138                    expect(classUnderTest.string).to(equal("Hello"))139                }140            }141        }142    }143}

1import Nimble2import Quick3@testable import ClassUnderTest4class ClassUnderTestSpec: QuickSpec {5    override func spec() {6        describe("ClassUnderTest") {7            it("should return true") {8                expect(ClassUnderTest().isTrue()).to(beTrue())9            }10        }11    }12}13import Nimble14import Quick15@testable import ClassUnderTest16class ClassUnderTestSpec: QuickSpec {17    override func spec() {18        describe("ClassUnderTest") {19            it("should return true") {20                expect(ClassUnderTest().isTrue()).to(beTrue())21            }22        }23    }24}25import Nimble26import Quick27@testable import ClassUnderTest28class ClassUnderTestSpec: QuickSpec {29    override func spec() {30        describe("ClassUnderTest") {31            it("should return true") {32                expect(ClassUnderTest().isTrue()).to(beTrue())33            }34        }35    }36}37import Nimble38import Quick39@testable import ClassUnderTest40class ClassUnderTestSpec: QuickSpec {41    override func spec() {42        describe("ClassUnderTest") {43            it("should return true") {44                expect(ClassUnderTest().isTrue()).to(beTrue())45            }46        }47    }48}49import Nimble50import Quick51@testable import ClassUnderTest52class ClassUnderTestSpec: QuickSpec {53    override func spec() {54        describe("ClassUnderTest") {55            it("should return true") {56                expect(ClassUnderTest().isTrue()).to(beTrue())57            }58        }59    }60}61import Nimble62import Quick63@testable import ClassUnderTest64class ClassUnderTestSpec: QuickSpec {65    override func spec() {66        describe("ClassUnderTest") {67            it("should return true") {68                expect(ClassUnderTest().isTrue()).to(beTrue())69            }70        }71    }72}73import Nimble74import Quick75@testable import ClassUnderTest76class ClassUnderTestSpec: QuickSpec {77    override func spec() {78        describe("ClassUnderTest") {79            it("

1import Nimble2import Quick3class ClassUnderTestSpec: QuickSpec {4    override func spec() {5        describe("ClassUnderTest") {6            context("when it is initialized") {7                it("should have a property called 'property'") {8                    let sut = ClassUnderTest()9                    expect(sut.property).to(equal("property"))10                }11            }12        }13    }14}15import Nimble16import Quick17class ClassUnderTestSpec: QuickSpec {18    override func spec() {19        describe("ClassUnderTest") {20            context("when it is initialized") {21                it("should have a property called 'property'") {22                    let sut = ClassUnderTest()23                    expect(sut.property).to(equal("property"))24                }25            }26        }27    }28}29import Nimble30import Quick31class ClassUnderTestSpec: QuickSpec {32    override func spec() {33        describe("ClassUnderTest") {34            context("when it is initialized") {35                it("should have a property called 'property'") {36                    let sut = ClassUnderTest()37                    expect(sut.property).to(equal("property"))38                }39            }40        }41    }42}43import Nimble44import Quick45class ClassUnderTestSpec: QuickSpec {46    override func spec() {47        describe("ClassUnderTest") {48            context("when it is initialized") {49                it("should have a property called 'property'") {50                    let sut = ClassUnderTest()51                    expect(sut.property).to(equal("property"))52                }53            }54        }55    }56}57import Nimble58import Quick59class ClassUnderTestSpec: QuickSpec {60    override func spec() {61        describe("ClassUnderTest") {62            context("when it is initialized") {63                it("should have a property called 'property'") {64                    let sut = ClassUnderTest()65                    expect(sut.property).to(equal("property"))66                }67            }68        }69    }70}

1import Nimble2import Quick3@testable import ClassUnderTest4class ClassUnderTestSpec: QuickSpec {5    override func spec() {6        describe("ClassUnderTest") {7            context("when initialized with a string") {8                it("should return the string") {9                    let classUnderTest = ClassUnderTest(string: "Hello")10                    expect(classUnderTest.string).to(equal("Hello"))11                }12            }13        }14    }15}16import Nimble17import Quick18@testable import ClassUnderTest19class ClassUnderTestSpec: QuickSpec {20    override func spec() {21        describe("ClassUnderTest") {22            context("when initialized with a string") {23                it("should return the string") {24                    let classUnderTest = ClassUnderTest(string: "Hello")25                    expect(classUnderTest.string).to(equal("Hello"))26                }27            }28        }29    }30}31import Nimble32import Quick33@testable import ClassUnderTest34class ClassUnderTestSpec: QuickSpec {35    override func spec() {36        describe("ClassUnderTest") {37            context("when initialized with a string") {38                it("should return the string") {39                    let classUnderTest = ClassUnderTest(string: "Hello")40                    expect(classUnderTest.string).to(equal("Hello"))41                }42            }43        }44    }45}46import Nimble47import Quick48@testable import ClassUnderTest49class ClassUnderTestSpec: QuickSpec {50    override func spec() {51        describe("ClassUnderTest") {52            context("when initialized with a string") {53                it("should return the string") {54                    let classUnderTest = ClassUnderTest(string: "Hello")55                    expect(classUnderTest.string).to(equal("Hello"))56                }57            }58        }59    }60}61import Nimble62import Quick63@testable import ClassUnderTest64class ClassUnderTestSpec: QuickSpec {65    override func spec() {66        describe("ClassUnderTest") {67            context("when initialized with a string") {68                it("should return the string") {69                    let classUnderTest = ClassUnderTest(string: "Hello")70                    expect(classUnderTest.string).to(equal("Hello"))71                }72            }73        }74    }75}

1import Nimble2import Quick3@testable import ClassUnderTest4class ClassUnderTestSpec: QuickSpec {5    override func spec() {6        describe("ClassUnderTest") {7            it("should return true") {8                expect(ClassUnderTest().isTrue()).to(beTrue())9            }10        }11    }12}13import Nimble14import Quick15@testable import ClassUnderTest16class ClassUnderTestSpec: QuickSpec {17    override func spec() {18        describe("ClassUnderTest") {19            it("should return true") {20                expect(ClassUnderTest().isTrue()).to(beTrue())21            }22        }23    }24}25import Nimble26import Quick27@testable import ClassUnderTest28class ClassUnderTestSpec: QuickSpec {29    override func spec() {30        describe("ClassUnderTest") {31            it("should return true") {32                expect(ClassUnderTest().isTrue()).to(beTrue())33            }34        }35    }36}37import Nimble38import Quick39@testable import ClassUnderTest40class ClassUnderTestSpec: QuickSpec {41    override func spec() {42        describe("ClassUnderTest") {43            it("should return true") {44                expect(ClassUnderTest().isTrue()).to(beTrue())45            }46        }47    }48}49import Nimble50import Quick51@testable import ClassUnderTest52class ClassUnderTestSpec: QuickSpec {53    override func spec() {54        describe("ClassUnderTest") {55            it("should return true") {56                expect(ClassUnderTest().isTrue()).to(beTrue())57            }58        }59    }60}61import Nimble62import Quick63@testable import ClassUnderTest64class ClassUnderTestSpec: QuickSpec {65    override func spec() {66        describe("ClassUnderTest") {67            it("should return true") {68                expect(ClassUnderTest().isTrue()).to(beTrue())69            }70        }71    }72}73import Nimble74import Quick75@testable import ClassUnderTest76class ClassUnderTestSpec: QuickSpec {77    override func spec() {78        describe("ClassUnderTest") {79            it("