Quickの手習い

前回までのあらすじ

• Swiftで使える振る舞い駆動的テスティングフレームワーク「Quick」を導入した

今日やったこと

せっかくなので、Quickで使えるmatcherについて、いろいろ試してみました。

xUnitと違って、基本的にmatcherには動詞の原形が使われており、慣れるまではタイポしそうです。

等値判定 equal

    override func spec() {
        describe("等値のテスト") {
            it("2と3の和は5と等しい") {
                let value = 2 + 3
                expect(value).to(equal(5))
            }
            
            it("400と600の和は100とは異なる") {
                let value = 400 + 600
                expect(value).toNot(equal(100))
            }
        }
    }

ポインタ比較 beIdenticalTo

    override func spec() {
        describe("ポインタ比較のテスト") {
            class Hoge : NSObject { }

            it("二つのHogeは同じポインタ") {
                let obj: Hoge = Hoge()
                let obj2 = obj
                
                expect(obj).to(beIdenticalTo(obj2))
            }
            
            it("二つのHogeは異なるポインタ") {
                let obj: Hoge = Hoge()
                let obj2: Hoge = Hoge()
                
                expect(obj).toNot(beIdenticalTo(obj2))
            }
        }
    }

大小比較 beLessThan / beGreaterThan

    override func spec() {
        describe("大小比較のテスト") {
            
            describe("不等号で比較する場合"){
                it("99は100より小さい") {
                    expect(99).to(beLessThan(100))
                }
            
                it("100は100より小さくない") {
                    expect(100).toNot(beLessThan(100))
                }
            
                it("101は100より大きい") {
                    expect(101).to(beGreaterThan(100))
                }
            
                it("100は100より大きいくない") {
                    expect(100).toNot(beGreaterThan(100))
                }
            }
            
            describe("等号つき不等号で比較する場合") {
                it("100は100以下") {
                    expect(100).to(beLessThanOrEqualTo(100))
                }
                
                it("101は100以下ではない") {
                    expect(101).toNot(beLessThanOrEqualTo(100))
                }
                
                it("100は100以上") {
                    expect(100).to(beGreaterThanOrEqualTo(100))
                }
                
                it("99は100以上ではない") {
                    expect(99).toNot(beGreaterThanOrEqualTo(100))
                }
            }
        }
    }

誤差判定 beCloseTo

    override func spec() {
        describe("浮動小数点誤差のテスト") {
            it("1.0と0.99999の誤差が0.00001以内である") {
                expect(1.0).to(beCloseTo(0.99999, within: 0.00001))
            }
            it("1.0と1.000011の誤差が0.00001以内ではない") {
                expect(1.0).toNot(beCloseTo(1.000011, within: 0.00001))
            }
        }
    }

Is-aのテスト beAnInstanceOf / beAKindOf

    override func spec() {
        describe("Is-aのテスト") {
            it("文字列「HelloWorld」はNSStringのサブクラスである") {
                expect("HelloWorld").to(beAKindOf(NSString))
            }
            
            it("文字列「HelloWorld」はNSStringのインスタンスではない") {
                expect("HelloWorld").toNot(beAnInstanceOf(NSString))
            }
            
            it("文字列「HelloWorld」は_NSContiguousStringのインスタンスである") {
                expect("HelloWorld").to(beAnInstanceOf(_NSContiguousString))
            }
        }
    }

真理値 beTrue / beFalse

    override func spec() {
        describe("真理値のテスト") {
            it("TrueはTrueである") {
                expect(true).to(beTrue())
            }
            
            it("TrueはFalseではない") {
                expect(true).toNot(beFalse())
            }

            it("FalseはFalseである") {
                expect(false).to(beFalse())
            }
            
            it("FalseはTrueではない") {
                expect(false).toNot(beTrue())
            }
        }
    }

Nil判定 beNil

    override func spec() {
        describe("Nil判定") {
            it("NilはNilである") {
                let nilObj:NSObject? = nil
                expect(nilObj).to(beNil())
            }
        }
    }

空値判定 beEmpty

    override func spec() {
        describe("空値判定") {
            it("要素が1つも存在しない配列は空オブジェクトである") {
                let emptyObj:[String] = []
                
                expect(emptyObj).to(beEmpty())
            }
            
            it("要素が1つも存在しない辞書は空オブジェクトである") {
                let emptyObj: [String:Int] = [:]
                
                expect(emptyObj).to(beEmpty())
            }
            
            it("文字数0の文字列は空オブジェクトである") {
                let emptyString = ""
                
                expect(emptyString).to(beEmpty())
            }
        }
    }

前方一致 beginWith

    override func spec() {
        describe("前方一致判定") {
            it("配列「AAA, BBB, CCC」の最初の要素は「AAA」である") {
                let array:[String] = ["AAA", "BBB", "CCC"]
                
                expect(array).to(beginWith("AAA"))
            }
            
            it("文字列「HelloWorld」は「Hell」で始まる") {
                let helloString = "HelloWorld"
                
                expect(helloString).to(beginWith("Hell"))
            }
        }
    }

後方一致 endWith

    override func spec() {
        describe("後方一致判定") {
            it("配列は「AAA, BBB, CCC」の最後の要素は「CCC」である") {
                let array:[String] = ["AAA", "BBB", "CCC"]
                
                expect(array).to(endWith("CCC"))
            }
            
            it("文字列「HelloWorld」は「ld」で終わる") {
                let helloString = "HelloWorld"
                
                expect(helloString).to(endWith("ld"))
            }
        }
    }

含有判定 contain

    override func spec() {
        describe("含有判定") {
            it("文字列「イチゴミルク」は「ゴミ」を含む") {
                let ichigoMilk = "イチゴミルク"
                
                expect(ichigoMilk).to(contain("ゴミ"))
            }
            
            it("文字列「ポークソテー」は「クソ」を含む") {
                let porkSauté = "ポークソテー"
                
                expect(porkSauté).to(contain("クソ"))
            }
        }
    }