如何用表驱动测试Go泛型函数？现有方案求优化及替代方法

当前方案的优劣 #

优点 #

• 实现简单，能快速覆盖多类型测试场景
• 表驱动结构清晰，测试用例一目了然，便于维护和扩展
• 通过类型断言明确处理每种输入类型，避免泛型类型不匹配问题

缺点 #

• 扩展性差：每新增一种支持类型，就需要在switch中新增对应case分支，代码冗余度高
• 类型安全不足：input和expectedOutput用interface{}存储，编译期无法校验类型匹配性，容易出现预期值类型错误
• 代码重复：每个case分支逻辑几乎一致，仅类型不同，违反DRY原则

替代方案 #

方案一：泛型测试函数封装 #

将测试逻辑封装为泛型函数，针对不同类型调用该函数，兼顾表驱动的清晰性与代码复用：

func TestPtrTo(t *testing.T) {
    testString := "abcd"
    testBool := true

    runTestCase := func[T any](t *testing.T, desc string, input T, expected *T) {
        t.Run(desc, func(t *testing.T) {
            output := PtrTo(input)
            assert.Equal(t, expected, output)
        })
    }

    runTestCase(t, "string", testString, &testString)
    runTestCase(t, "bool", testBool, &testBool)
}

优势：

• 类型安全：编译期即可校验输入与预期值的类型匹配性
• 无冗余代码：测试逻辑仅编写一次，支持任意符合约束的类型
• 扩展性好：新增类型只需新增一行runTestCase调用

方案二：泛型切片作为测试表 #

定义泛型测试用例结构体，按类型单独构建测试表，兼顾表驱动与泛型优势：

type testCase[T any] struct {
    desc     string
    input    T
    expected *T
}

func TestPtrTo(t *testing.T) {
    stringCases := []testCase[string]{
        {"string", "abcd", &[]string{"abcd"}[0]},
    }
    boolCases := []testCase[bool]{
        {"bool", true, &[]bool{true}[0]},
    }

    runTests := func[T any](t *testing.T, cases []testCase[T]) {
        for _, tc := range cases {
            t.Run(tc.desc, func(t *testing.T) {
                output := PtrTo(tc.input)
                assert.Equal(t, tc.expected, output)
            })
        }
    }

    runTests(t, stringCases)
    runTests(t, boolCases)
}

特点：

• 测试用例按类型分组，结构清晰
• 完全类型安全，编译期即可发现类型错误
• 测试逻辑复用，新增类型只需新增对应类型的测试表与runTests调用

方案三：反射实现（不推荐） #

通过反射调用泛型函数，虽能统一处理任意类型，但会丢失编译期类型检查，代码复杂度高，仅适合极端场景：

func TestPtrTo(t *testing.T) {
    testCases := []struct {
        desc     string
        input    interface{}
        expected interface{}
    }{
        {"string", "abcd", &[]string{"abcd"}[0]},
        {"bool", true, &[]bool{true}[0]},
    }

    for _, tc := range testCases {
        t.Run(tc.desc, func(t *testing.T) {
            ptrToFunc := reflect.ValueOf(PtrTo[interface{}])
            genericFunc := ptrToFunc.Type()
            concreteFunc := genericFunc.Instantiate(reflect.TypeOf(tc.input))
            result := concreteFunc.Call([]reflect.Value{reflect.ValueOf(tc.input)})
            assert.Equal(t, tc.expected, result[0].Interface())
        })
    }
}

问题：

• 代码晦涩，难以维护
• 丢失编译期类型安全，仅能在运行时发现错误
• 性能开销高于直接调用泛型函数

内容的提问来源于stack exchange，提问作者Marek Łukasik