参数化测试

参数化测试入门

仓颉 unittest 框架支持参数化测试，格式为数据 DSL ，测试中框架自动插入输入参数。

如下为复杂代码示例，用函数对数组排序：

package example

func sort(array: Array<Int64>): Unit {
    for (i in 0..array.size) {
        var minIndex = i
        for (j in i..array.size) {
            if (array[j] < array[minIndex]) {
                minIndex = j
            }
        }
        (array[i], array[minIndex]) = (array[minIndex], array[i])
    }
}

这个函数不是最优最高效的排序实现，但仍可以达成目的。来测试一下。

package example

@Test
func testSort() {
    let arr = [45, 5, -1, 0, 1, 2]
    sort(arr)
    @Expect(arr, [-1, 0, 1, 2, 5, 45])
}

测试结果显示，函数在单个输入的情况下可用。接下来测试，如果数组只包含等值元素，排序函数还是否可用。

@Test
func testAllEqual() {
    let arr = [0, 0, 0, 0]
    let expected = [0, 0, 0, 0]
    sort(arr)
    @Expect(expected, arr)
}

测试结果显示函数可用，但还是不能确认是否适用于所有大小的数组。接下来测试参数化数组的大小。

@Test[size in [0, 1, 50, 100, 1000]]
func testAllEqual(size: Int64) {
    let arr = Array(size, item: 0)
    let expected = Array(size, item: 0)
    sort(arr)
    @Expect(expected, arr)
}

至此，参数化测试已完成。这种是最简单的参数化测试，即值驱动测试，直接在代码中列出测试运行的值。参数化测试的参数可以不止一个。不仅可以指定排序函数的大小，还可以指定待测试的元素。

@Test[
    size in [0, 1, 50, 100, 1000],
    item in (-1..20)
]
func testAllEqual(size: Int64, item: Int64) {
    let arr = Array(size, item: item)
    let expected = Array(size, item: item)
    sort(arr)
    @Expect(expected, arr)
}

注意，item 的取值范围为 -1..20 ，不是一个数组。那么，运行这个测试，结果会如何？参数 size 和 item 的取值会进行组合再测试和返回结果。因此，测试函数时，不要配置过多参数；否则组合数量过大，导致测试变慢。上述例子中，size 参数值有5个，item 参数值有21个，共有21×5=105种组合。

注意，值驱动测试不限于整型或内置类型。也可以和任何仓颉类型一起使用。参考如下测试：

@Test[
    array in [
        [],
        [1, 2, 3],
        [1, 2, 3, 4, 5],
        [5, 4, 3, 2, 1],
        [-1, 0],
        [-20]
    ]
]
func testDifferentArrays(array: Array<Int64>) {
    //测试数组是否已排序
    for (i in 0..(array.size - 1)) {
        @Expect(array[i] <= array[i + 1])
    }
}

这里，直接以参数的形式提供测试的数据。

当然，用数组来测试代码可能过于笨重。有时，对于这样的泛型函数，随机生成数据可能会更容易些。接下来看一种更高级的参数化测试：随机测试。通过调用函数 unittest.random<T>() 替换值驱动测试的数组或范围来创建随机测试：

@Test[
    array in random()
]
func testRandomArrays(array: Array<Int64>) {
    //测试数组是否已排序
    for (i in 0..(array.size - 1)) {
        @Expect(array[i] <= array[i + 1])
    }
}

这个测试本质上是生成大量完全随机的数值（默认为200个），用这些值来测试代码。数值并不完全随机，偏向于边界值，如特定类型的零、最大值和最小值、空集合等。

特别注明：通常建议随机化测试与手工编写的测试混用，实践表明可以互为补充。

为了更好地描述随机测试，先把排序函数放一边，编写下面这样一个测试：

@Test[
    array in random()
]
func testNonsense(array: Array<Int64>) {
    if (array.size < 2) { return }
    @Expect(array[0] <= array[1] + 500)
}

运行后，会生成如下类似输出:

[ FAILED ] CASE: testNonsense (1159229 ns)
    REASON: After 4 generation steps and 200 reduction steps:
        array = [0, -453923686263, 0]
    with randomSeed = 1702373121372171563

    Expect Failed: `(array [ 0 ] <= array [ 1 ] + 500 == true)`
       left: false
      right: true

结果可见，数组[0, -453923686263, 0]测试失败。再运行一次：

[ FAILED ] CASE: testNonsense (1904718 ns)
    REASON: After 5 generation steps and 200 reduction steps:
        array = [0, -1196768422]
    with randomSeed = 1702373320782980551

    Expect Failed: `(array [ 0 ] <= array [ 1 ] + 500 == true)`
       left: false
      right: true

同样，测试失败，但值都不同。为什么会这样呢？因为随机测试本质上是随机的，所以每次都会生成新的随机值。在各种不同的数据上测试函数，可能很好用；但是对于某些测试，这意味着多次运行中，有时成功，有时失败，不利于共享测试结果。随机测试是一个强大的工具，但在使用时也需要了解这些弊端。

测试结果每次都不一样，如何向其他开发者展示结果呢？答案很简单，就在运行测试时得到的输出中：

with randomSeed = 1702373320782980551

以上提供了一个随机种子，可以在测试中用作配置项。改写测试如下：

@Test[
    array in random()
]
@Configure[randomSeed: 1702373320782980551]
func testNonsense(array: Array<Int64>) {
    if (array.size < 2) { return }
    @Expect(array[0] <= array[1] + 500)
}

运行结果如下：

[ FAILED ] CASE: testNonsense (1910109 ns)
    REASON: After 5 generation steps and 200 reduction steps:
        array = [0, -1196768422]
    with randomSeed = 1702373320782980551

    Expect Failed: `(array [ 0 ] <= array [ 1 ] + 500 == true)`
       left: false
      right: true

注意，此次运行生成的值、生成值所用的步骤和随机种子与上次运行完全相同。这种机制让随机测试可重复，可以保存在测试套件中与其他开发人员共享。您也可以只从随机测试中获取数据（如本例中的数组值[0, -1196768422]），用这些值编写新测试。

快速看看失败的测试生成的输出。

    REASON: After 5 generation steps and 200 reduction steps:
        array = [0, -1196768422]
    with randomSeed = 1702373320782980551

输出中包含几个重要信息：

测试失败前数据生成的步骤数：即测试失败前运行的迭代次数。
数据减量的步骤数：随机测试有缩减测试数据的机制，数据量减小后更方便操作，且提升了可读性。
导致测试失败的实际数据：按顺序列出所有参数（在本例中，只有一个参数 array ）以及它们实际导致测试失败的值。其中参数应实现 ToString 接口，否则将只打印占位符。
以及前面提到的随机种子，用于重现随机测试。

有些测试比较棘手，需要调整随机生成的步骤数。可以通过如下两个配置项控制：generationSteps 和 reductionSteps 。随机测试一个最大的优点是，只要设置了足够多的步骤，它可以运行很长时间，这样就可以检查数百万个值。

为了不使测试太耗时，默认 generationSteps 和 reductionSteps 的最大值都是200。通过这两个配置参数，就可以设置框架的最大步骤数。例如，对于上面的这个小测试，参数设置为一个大的数值可能没有多大意义。之前的运行已经表明，通常不到10步，测试就会失败。

类型参数化测试

虽然当前排序实现仅针对整型数组排序，但本质上也可以对其他任何类型排序。可以改写 sort 函数变成泛型函数，允许它对任意类型进行排序。注意，元素必须是可比较的，这样才能排序。

package example

func sort<T>(array: Array<T>): Unit where T <: Comparable<T> {
    for (i in 0..array.size) {
        var minIndex = i
        for (j in i..array.size) {
            if (array[j] < array[minIndex]) {
                minIndex = j
            }
        }
        (array[i], array[minIndex]) = (array[minIndex], array[i])
    }
}

所有测试均继续正常运行，可知排序函数已广泛适用。但是，是否真的适用于整型以外的类型呢？

用示例中的 testDifferentArrays 编写一个新的测试，对其他类型（如字符串）进行测试：

@Test[
    array in [
        [],
        ["1","2","3"],
        ["1","2","3","4","5"],
        ["5","4","3","2","1"]
    ]
]
func testDifferentArraysString(array: Array<String>) {
    //测试数组是否已排序
    let sorted = array.clone()
    sort(sorted)
    for (i in 0..(sorted.size - 1)) {
        @Expect(sorted[i] <= sorted[i + 1])
    }
}

运行测试可知，测试正常。注意，两个测试的主体和断言完全相同。试想，如果泛型函数的测试也可以泛型，不是更方便吗？

回到之前的随机测试示例：

@Test[array in random()]
func testRandomArrays(array: Array<Int64>) {
    let sorted = array.clone()
    sort(sorted)
    for (i in 0..(sorted.size - 1)) {
        @Expect(sorted[i] <= sorted[i + 1])
    }
}

测试是广泛适用的，可以看到元素类型不限于 Int64 ，也可以是任何类型 T ，例如：

可以比较：需要实现 Comparable<T> ；
可以随机生成实例：需要实现 Arbitrary<T> ；

将这个测试改写为一个泛型函数：

@Test[array in random()]
func testRandomArrays<T>(array: Array<T>) where T <: Comparable<T> & Arbitrary<T> {
    let sorted = array.clone()
    sort(sorted)
    for (i in 0..(sorted.size - 1)) {
        @Expect(sorted[i] <= sorted[i + 1])
    }
}

编译运行后，遇到了一个问题：

An exception has occurred:
MacroException: Generic function testRandomArrays requires a @Types macro to set up generic arguments

当然，要运行测试某些类型，需要先有这些类型。用 @Types 宏设置测试，这样就可以运行测试 Int64、 Float64 和 String 这些类型了。

@Test[array in random()]
@Types[T in <Int64, Float64, String>]
func testRandomArrays<T>(array: Array<T>) where T <: Comparable<T> & Arbitrary<T> {
    let sorted = array.clone()
    sort(sorted)
    for (i in 0..(sorted.size - 1)) {
        @Expect(sorted[i] <= sorted[i + 1])
    }
}

现在，运行测试，将编译并生成以下输出：

    TCS: TestCase_testRandomArrays, time elapsed: 2491737752 ns, RESULT:
    [ PASSED ] CASE: testRandomArrays<Int64> (208846446 ns)
    [ PASSED ] CASE: testRandomArrays<Float64> (172845910 ns)
    [ PASSED ] CASE: testRandomArrays<String> (2110037787 ns)

注意，每个类型，测试都是单独运行的，因为行为可能大不相同。 @Types 宏可以用于任何参数化的测试用例，包括测试函数和测试类。

重用、组合和映射参数策略

现在以 HashSet 为例。从测试 contains 开始。

@Test[data in random()]
func testHashSetContains(data: Array<Int64>) {
    let hashSet = HashSet(len)
    hashSet.putAll(data)
 
    for (element in data){
        @Assert(hashSet.contains(element))
    }
}

效果很好。现在尝试测试 remove 。

@Test[data in random()]
func testHashSetRemove(data: Array<Int64>) {
    let hashSet = HashSet(len)
    hashSet.putAll(data)
 
    for (element in data){
        @Assert(hashSet.remove(element))
    }
}

表面上看应该可以正常工作。然而很快就可以注意到它无法正常工作，因为随机生成的数组可能包含重复项，这会导致第二次删除调用失败。所以这里想要的是生成一些没有重复的数组。

var counter = 0
@OverflowWrapping
func generateUniqArray(len: Int64, start: Int64){
    let rng = Random(start)
    let step = Int64.Max / len
    counter = 0
    Array(len, { _ => 
        counter += rng.nextInt64()%step 
        counter
    } )
}

@Test[len in random(), start in random()]
func testHashSetRemove(len: Int64, start: Int64) {
    let data = generateUniqArray(len,start)
    let hashSet = HashSet(len)
    hashSet.putAll(data)
 
    for (element in data){
        @Assert(hashSet.remove(element))
    }
}

然而，即使将数据生成转移到一个单独的函数中，如果想在多个不同的测试之间重用它，它仍然会有相当多的重复。此外，在准备代码和测试代码之间的界限非常不明确。因此，为了解决上述问题，测试框架以 @Strategy 宏的形式提供了方便的 API，允许组合和映射现有策略。

var counter = 0
@Strategy[len in random(), start in random()]
@OverflowWrapping
func generateUniqArray(len: Int64, start: Int64): Array<Int64>{
    let rng = Random(start)
    let step = Int64.Max / len
    counter = 0
    Array(len, { _ => 
        counter += rng.nextInt64()%step 
        counter
    } )
}

现在，只需要这样的输入，就可以使用该策略：

@Test[data in generateUniqArray]
func testHashSetRemove(data: Array<Int64>) {
    let hashSet = HashSet()
    hashSet.putAll(data)
 
    for (element in data){
        @Assert(hashSet.remove(element))
    }
}
 
@Test[data in generateUniqArray]
func testHashSetToArray(data: Array<Int64>) {
    let hashSet = HashSet()
    hashSet.putAll(data)
 
    let result = hashSet.toArray()
    result.sort()
    data.sort()
    @Assert(result == data)
}

仓颉语言库 API

参数化测试