Go：如何创建可用于类型约束外的有序类型接口以合并测试用例？

你需要将int和string类型的排序测试用例合并到一个变量中，用单个循环完成测试，但由于constraints.Ordered仅能作为类型约束，无法直接用来定义可容纳多种有序类型的结构体字段。

核心限制说明 #

• Go不存在内置的Sortable接口能直接兼容int、string等所有有序类型，这些原生类型本身没有实现统一的比较方法接口。
• []int和[]string是完全独立的切片类型，无法直接赋值给同一个接口类型的切片变量。
• 泛型TestCase[T constraints.Ordered]必须实例化后才能使用，无法直接混合不同实例的测试用例。

方案1：用闭包包装测试用例，统一存储为测试函数 #

通过将每个测试用例的执行逻辑包装成闭包，把所有测试项统一存储为func(t *testing.T)类型的集合，实现单循环执行：

func TestMergeSort(t *testing.T) {
    type testCase struct {
        name string
        run  func(t *testing.T)
    }

    var tests []testCase

    // 添加整数类型测试用例
    intInput := []int{3, 2, 5, 1, 4, 6}
    intExpected := []int{1, 2, 3, 4, 5, 6}
    tests = append(tests, testCase{
        name: "#1 整数排序",
        run: func(t *testing.T) {
            output := MergeSort(intInput)
            if !cmp.Equal(intExpected, output) {
                t.Fatalf("预期结果 %v，实际输出 %v", intExpected, output)
            }
        },
    })

    // 添加字符串类型测试用例
    strInput := []string{"hello", "bonjour"}
    strExpected := []string{"bonjour", "hello"}
    tests = append(tests, testCase{
        name: "#2 字符串排序",
        run: func(t *testing.T) {
            output := MergeSort(strInput)
            if !cmp.Equal(strExpected, output) {
                t.Fatalf("预期结果 %v，实际输出 %v", strExpected, output)
            }
        },
    })

    // 统一执行所有测试
    for _, test := range tests {
        t.Run(test.name, test.run)
    }
}

方案2：用泛型辅助函数生成测试函数，减少重复代码 #

通过泛型函数批量生成不同类型的测试执行逻辑，进一步简化代码冗余：

func TestMergeSort(t *testing.T) {
    // 泛型辅助函数：根据输入和预期结果生成测试执行函数
    makeTestFunc := func[T constraints.Ordered](input, expected []T) func(t *testing.T) {
        return func(t *testing.T) {
            output := MergeSort(input)
            if !cmp.Equal(expected, output) {
                t.Fatalf("预期结果 %v，实际输出 %v", expected, output)
            }
        }
    }

    // 统一存储所有测试用例
    tests := map[string]func(t *testing.T){
        "#1 整数排序":    makeTestFunc([]int{3, 2, 5, 1, 4, 6}, []int{1, 2, 3, 4, 5, 6}),
        "#2 字符串排序": makeTestFunc([]string{"hello", "bonjour"}, []string{"bonjour", "hello"}),
    }

    // 单循环执行所有测试
    for name, runTest := range tests {
        t.Run(name, runTest)
    }
}

这两种方案都不需要修改原有的MergeSort泛型函数，完美适配constraints.Ordered约束，同时实现了测试用例的统一管理和单循环执行。

内容的提问来源于stack exchange，提问作者CodeIntern