swift - 详尽测试 Swift 结构与 Equatable 一致性的方法？

Question

标题几乎说明了一切。我的项目在 Swift 2.3 中。偶尔会引入自定义结构模型对象。由于各种原因，这必须符合 Equatable。

例如，让我们有一个包含 6 个不同值类型变量的结构，它们都来自 Swift 标准库。

struct Address: Equatable {

    let firstName: String
    let lastName: String
    let street: String
    let streetNumber: Int
    let city: String
    let countryCode: Int
}

func ==(lhs: Address, rhs: Address) -> Bool {

    return (
        lhs.firstName == rhs.firstName &&
        lhs.lastName == rhs.lastName &&
        lhs.street == rhs.street &&
        lhs.streetNumber == rhs.streetNumber &&
        lhs.city == rhs.city &&
        lhs.countryCode == rhs.countryCode)
}

确保我在单元测试中测试所有(不)等式组合的正确算法是什么？

排列/组合？也许更程序化？

Answer 1

在这种情况下，详尽地测试所有组合只是一个彻头彻尾的糟糕策略。这是不必要的，只会使单元测试更加麻烦，并使您不太可能做好它。

有了像这样一个非常简单的相等函数，就可以证明您根本不需要测试它。如果您必须对其进行测试，则测试一种情况下的平等情况和一种情况下的不平等情况就足够了。如果你真的想发疯，你可以对每个成员进行一次平等测试，并进行六次不平等测试。

最好单独手动编写测试用例，因为您应该能够相信单元测试的正确性，只需查看它即可。如果不能，那么您可能会陷入不得不对单元测试进行单元测试的相当荒谬的境地。

但是，如果您真的绝对坚持以错误的方式做事并详尽地测试每一种可能的组合，那么您可以这样做:

func makeAddressPair(sames: [Bool]) -> (Address, Address) {
    let firstName = ["John", sames[0] ? "John" : "Jane"]
    let secondName = ["Smith", sames[1] ? "Smith" : "Williams"]
    let street = ["Acacia Avenue", sames[2] ? "Acacia Avenue" : "Privet Close"]
    let streetNumber = [10, sames[3] ? 10 : 21]
    let city = ["Leeds", sames[4] ? "Leeds" : "Bolton"]
    let country = [1, sames[5] ? 1 : 2]

    return (Address(firstName: firstName[0], lastName: secondName[0], street: street[0],
                    streetNumber: streetNumber[0], city: city[0], countryCode: country[0]),
            Address(firstName: firstName[1], lastName: secondName[1], street: street[1],
                    streetNumber: streetNumber[1], city: city[1], countryCode: country[1]))

}

class AddressCompareTests: XCTestCase {

    func testAddressCompare() {
        var comparesEqual = 0
        var comparesInequal = 0

        for a in [true, false] {
            for b in [true, false] {
                for c in [true, false] {
                    for d in [true, false] {
                        for e in [true, false] {
                            for f in [true, false] {
                                let (first, second) = makeAddressPair(sames: [a, b, c, d, e, f])

                                if first == second {
                                    comparesEqual += 1
                                }
                                else {
                                    comparesInequal += 1
                                }
                            }
                        }
                    }
                }
            }
        }

        XCTAssertEqual(comparesEqual, 1)
        XCTAssertEqual(comparesInequal, 63)
    }

}

您有 2 ^ 6 = 64 种可能的组合，因为您有六个成员，并且在两个结构之间，每对成员可以相等，也可以不相等。在这里，我们有一个辅助函数来生成一对结构，该列表的成员之间应该相等，还有一个嵌套循环来生成所有可能的对组合。当你比较所有的对时，正好有一个应该比较相等，正好有 63 个应该比较不相等，所以这些是我们断言的测试条件，因为至少那时我们有某种糟糕的表亲来质量控制我们测试的正确性。

如果您改为手动测试两个或七个案例，与这样做相比，它会更简单、更清晰、更易于阅读和验证，并且代码行数会更少。