Golang表格驱动测试如何实现 展示参数化测试的编写技巧

package main

func CalculateSum(a, b int) int {
    return a + b
}

package main

import (
    "testing"
)

// 定义测试用例结构体
type sumTestCase struct {
    name     string
    a        int
    b        int
    expected int
}

func TestCalculateSum(t *testing.T) {
    // 定义一组测试用例
    tests := []sumTestCase{
        {
            name:     "Positive numbers",
            a:        1,
            b:        2,
            expected: 3,
        },
        {
            name:     "Negative numbers",
            a:        -1,
            b:        -2,
            expected: -3,
        },
        {
            name:     "Zero with positive",
            a:        0,
            b:        5,
            expected: 5,
        },
        {
            name:     "Zero with negative",
            a:        -5,
            b:        0,
            expected: -5,
        },
        {
            name:     "Large numbers",
            a:        1000000,
            b:        2000000,
            expected: 3000000,
        },
    }

    // 遍历所有测试用例
    for _, tc := range tests {
        // 使用 t.Run 为每个测试用例创建子测试
        // 这样做的好处是，即使某个子测试失败，其他子测试也能继续运行，
        // 并且测试报告会清晰地指出是哪个具体用例出了问题。
        t.Run(tc.name, func(t *testing.T) {
            actual := CalculateSum(tc.a, tc.b)
            if actual != tc.expected {
                t.Errorf("For a=%d, b=%d, expected %d, got %d", tc.a, tc.b, tc.expected, actual)
            }
        })
    }
}

package main

import (
    "errors"
    "testing"
)

func Divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero is not allowed")
    }
    return a / b, nil
}

// 针对带错误返回的函数，更新测试用例结构体
type divideTestCase struct {
    name        string
    a           int
    b           int
    expectedVal int
    expectedErr error // 预期错误，如果为nil表示不期望错误
}

func TestDivide(t *testing.T) {
    tests := []divideTestCase{
        {
            name:        "Normal division",
            a:           10,
            b:           2,
            expectedVal: 5,
            expectedErr: nil,
        },
        {
            name:        "Division by one",
            a:           7,
            b:           1,
            expectedVal: 7,
            expectedErr: nil,
        },
        {
            name:        "Division by zero",
            a:           10,
            b:           0,
            expectedVal: 0, // 此时返回值不重要，因为有错误
            expectedErr: errors.New("division by zero is not allowed"),
        },
        {
            name:        "Negative result",
            a:           -10,
            b:           2,
            expectedVal: -5,
            expectedErr: nil,
        },
    }

    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            actualVal, actualErr := Divide(tc.a, tc.b)

            // 检查错误是否符合预期
            if tc.expectedErr != nil {
                if actualErr == nil {
                    t.Errorf("Expected an error '%v', but got nil", tc.expectedErr)
                } else if actualErr.Error() != tc.expectedErr.Error() {
                    // 或者使用 errors.Is / errors.As 进行更精确的错误类型匹配
                    t.Errorf("Expected error '%v', got '%v'", tc.expectedErr, actualErr)
                }
            } else { // 不期望错误
                if actualErr != nil {
                    t.Errorf("Did not expect an error, but got '%v'", actualErr)
                }
                // 只有在没有错误时才比较返回值
                if actualVal != tc.expectedVal {
                    t.Errorf("Expected value %d, got %d", tc.expectedVal, actualVal)
                }
            }
        })
    }
}