Golang测试表格驱动与结构体反射实践

func isEven(n int) bool {
    return n%2 == 0
}

func TestIsEven(t *testing.T) {
    tests := []struct {
        name     string
        input    int
        expected bool
    }{
        {"positive even", 4, true},
        {"positive odd", 3, false},
        {"negative even", -2, true},
        {"zero", 0, true},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := isEven(tt.input); got != tt.expected {
                t.Errorf("isEven(%d) = %v; want %v", tt.input, got, tt.expected)
            }
        })
    }
}

type Version struct {
    Major int
    Minor int
    Patch int
}

func ParseVersion(s string) (*Version, error) {
    parts := strings.Split(s, ".")
    if len(parts) != 3 {
        return nil, fmt.Errorf("invalid format")
    }
    v := &Version{}
    var err error
    v.Major, err = strconv.Atoi(parts[0])
    if err != nil { return nil, err }
    v.Minor, err = strconv.Atoi(parts[1])
    if err != nil { return nil, err }
    v.Patch, err = strconv.Atoi(parts[2])
    if err != nil { return nil, err }
    return v, nil
}

func equal(a, b interface{}) bool {
    va := reflect.ValueOf(a)
    vb := reflect.ValueOf(b)
    if va.Kind() == reflect.Ptr {
        va = va.Elem()
    }
    if vb.Kind() == reflect.Ptr {
        vb = vb.Elem()
    }
    if va.Type() != vb.Type() {
        return false
    }
    for i := 0; i < va.NumField(); i++ {
        if va.Field(i).Interface() != vb.Field(i).Interface() {
            return false
        }
    }
    return true
}

func TestParseVersion(t *testing.T) {
    tests := []struct {
        name     string
        input    string
        expected *Version
        hasError bool
    }{
        {"valid", "1.2.3", &Version{1,2,3}, false},
        {"invalid format", "1.2", nil, true},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            v, err := ParseVersion(tt.input)
            if (err != nil) != tt.hasError {
                t.Fatalf("error = %v; want error: %v", err, tt.hasError)
            }
            if tt.expected != nil && !equal(v, tt.expected) {
                t.Errorf("got %+v, want %+v", v, tt.expected)
            }
        })
    }
}

type testCase struct {
    Input    string `test:"required"`
    Expected string `test:"optional"`
    Skip     bool   `test:"internal"`
}