Golang测试代码生成 自动化生成测试用例

go generate

Fuzz

*testing.F

[]byte

string

int

F.Add()

go test -fuzz=.

Fuzz

// 示例：fuzzing一个字符串反转函数
package main

import (
    "testing"
    "unicode/utf8"
)

// 假设这是你要测试的函数
func Reverse(s string) string {
    r := []rune(s)
    for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
        r[i], r[j] = r[j], r[i]
    }
    return string(r)
}

func FuzzReverse(f *testing.F) {
    testcases := []string{"Hello, world", " ", "!12345", "你好，世界"}
    for _, tc := range testcases {
        f.Add(tc) // 添加种子输入
    }
    f.Fuzz(func(t *testing.T, orig string) {
        rev := Reverse(orig) // 你的目标函数
        doubleRev := Reverse(rev)
        if orig != doubleRev {
            t.Errorf("Before: %q, After: %q", orig, doubleRev)
        }
        // 还可以添加其他断言，比如检查UTF-8有效性等
        if utf8.ValidString(orig) && !utf8.ValidString(rev) {
            t.Errorf("Reverse produced invalid UTF-8 string %q", rev)
        }
    })
}

TestXxx

reflect

TestXxx

// 概念性代码，非完整实现，需要完善各种类型处理和错误处理
package main

import (
    "math/rand"
    "reflect"
    "strconv"
    "time"
)

type MyComplexStruct struct {
    ID        int
    Name      string
    IsActive  bool
    SubStruct SubStructType
    Tags      []string
    DataMap   map[string]interface{}
}

type SubStructType struct {
    Value float64
    Count int
}

func init() {
    rand.Seed(time.Now().UnixNano())
}

// PopulateRandomStruct 尝试用随机数据填充结构体
func PopulateRandomStruct(v interface{}) {
    rv := reflect.ValueOf(v)
    if rv.Kind() != reflect.Ptr || rv.IsNil() {
        return // 仅处理非空结构体指针
    }
    elem := rv.Elem()
    if elem.Kind() != reflect.Struct {
        return // 仅处理结构体
    }

    for i := 0; i < elem.NumField(); i++ {
        field := elem.Field(i)
        fieldType := elem.Type().Field(i)

        if !field.CanSet() {
            continue // 无法设置的字段（如未导出字段）跳过
        }

        switch field.Kind() {
        case reflect.String:
            field.SetString("rand_str_" + strconv.Itoa(rand.Intn(1000)))
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
            field.SetInt(int64(rand.Intn(10000)))
        case reflect.Bool:
            field.SetBool(rand.Intn(2) == 1)
        case reflect.Float32, reflect.Float64:
            field.SetFloat(rand.Float64() * 1000)
        case reflect.Slice:
            if field.IsNil() {
                field.Set(reflect.MakeSlice(fieldType.Type, rand.Intn(5)+1, rand.Intn(5)+1))
            }
            // 递归填充切片元素，这里简化处理，只填充基本类型
            if field.Len() > 0 && field.Index(0).Kind() == reflect.String {
                for j := 0; j < field.Len(); j++ {
                    field.Index(j).SetString("tag_" + strconv.Itoa(j))
                }
            }
        case reflect.Map:
            if field.IsNil() {
                field.Set(reflect.MakeMap(fieldType.Type))
            }
            // 填充一些随机键值对，这里简化处理
            if fieldType.Type.Key().Kind() == reflect.String && fieldType.Type.Elem().Kind() == reflect.Interface {
                field.SetMapIndex(reflect.ValueOf("key1"), reflect.ValueOf("value1"))
                field.SetMapIndex(reflect.ValueOf("key2"), reflect.ValueOf(rand.Intn(100)))
            }
        case reflect.Struct:
            if field.CanAddr() { // 确保可以获取地址以递归
                PopulateRandomStruct(field.Addr().Interface())
            }
        // ... 其他类型根据需要添加
        }
    }
}

// func main() {
//  myStruct := MyComplexStruct{}
//  PopulateRandomStruct(&myStruct)
//  fmt.Printf("%+v\n", myStruct)
//  fmt.Printf("%+v\n", myStruct.SubStruct)
//  fmt.Printf("%+v\n", myStruct.Tags)
//  fmt.Printf("%+v\n", myStruct.DataMap)
// }

gopter