Golang中模糊测试的应用场景有哪些

在Go中使用模糊测试（fuzzing）主要应用于以下场景：

1. 解析器和编解码器测试 - 模糊测试特别适合测试JSON、XML、CSV等数据解析器，以及各种编解码器（如base64、gob等）

// 示例：JSON解析器的模糊测试
func FuzzJSONParse(f *testing.F) {
    f.Fuzz(func(t *testing.T, data []byte) {
        var v interface{}
        if err := json.Unmarshal(data, &v); err != nil {
            return // 无效输入是预期的
        }
        // 验证往返编码
        encoded, err := json.Marshal(v)
        if err != nil {
            t.Fatalf("failed to marshal: %v", err)
        }
        var v2 interface{}
        if err := json.Unmarshal(encoded, &v2); err != nil {
            t.Fatalf("failed to unmarshal encoded data: %v", err)
        }
    })
}

1. 字符串处理函数 - 测试字符串操作函数对随机输入的鲁棒性

func FuzzStringOperations(f *testing.F) {
    f.Add("test string")
    f.Fuzz(func(t *testing.T, s string) {
        // 测试各种字符串操作
        _ = strings.ToUpper(s)
        _ = strings.ToLower(s)
        _ = strings.TrimSpace(s)
        _ = strings.Split(s, ",")
        
        // 测试自定义字符串处理函数
        result := MyStringProcessor(s)
        if result == "" && s != "" {
            t.Errorf("unexpected empty result for non-empty input")
        }
    })
}

1. 网络协议处理 - 测试HTTP处理器、自定义协议解析器等

func FuzzHTTPHandler(f *testing.F) {
    f.Fuzz(func(t *testing.T, method, path, body string) {
        req := httptest.NewRequest(method, path, strings.NewReader(body))
        w := httptest.NewRecorder()
        
        // 调用HTTP处理器
        MyHTTPHandler(w, req)
        
        // 验证响应状态码有效
        if w.Code < 100 || w.Code >= 600 {
            t.Errorf("invalid status code: %d", w.Code)
        }
    })
}

1. 加密和安全相关代码 - 测试加密函数、哈希函数等

func FuzzCryptoFunctions(f *testing.F) {
    f.Fuzz(func(t *testing.T, data []byte) {
        // 测试哈希函数
        h := sha256.New()
        h.Write(data)
        _ = h.Sum(nil)
        
        // 测试base64编码
        encoded := base64.StdEncoding.EncodeToString(data)
        decoded, err := base64.StdEncoding.DecodeString(encoded)
        if err != nil {
            t.Fatalf("base64 decode failed: %v", err)
        }
        if !bytes.Equal(data, decoded) {
            t.Errorf("base64 roundtrip failed")
        }
    })
}

1. 文件格式处理 - 测试图像处理、文档解析等库

func FuzzImageProcessing(f *testing.F) {
    f.Fuzz(func(t *testing.T, data []byte) {
        // 尝试解码图像
        _, format, err := image.Decode(bytes.NewReader(data))
        if err != nil {
            return // 无效图像数据是预期的
        }
        
        // 验证支持的格式
        supported := []string{"jpeg", "png", "gif"}
        found := false
        for _, f := range supported {
            if format == f {
                found = true
                break
            }
        }
        if !found {
            t.Logf("unexpected format: %s", format)
        }
    })
}

1. 自定义数据结构的序列化/反序列化

type MyStruct struct {
    ID    int
    Name  string
    Data  []byte
}

func FuzzCustomStruct(f *testing.F) {
    f.Fuzz(func(t *testing.T, id int, name string, data []byte) {
        s := MyStruct{
            ID:   id,
            Name: name,
            Data: data,
        }
        
        // 测试二进制编码
        buf := new(bytes.Buffer)
        if err := gob.NewEncoder(buf).Encode(s); err != nil {
            t.Fatalf("gob encode failed: %v", err)
        }
        
        var s2 MyStruct
        if err := gob.NewDecoder(buf).Decode(&s2); err != nil {
            t.Fatalf("gob decode failed: %v", err)
        }
        
        if s.ID != s2.ID || s.Name != s2.Name || !bytes.Equal(s.Data, s2.Data) {
            t.Errorf("roundtrip mismatch")
        }
    })
}

模糊测试在Go中的主要优势是能够自动生成大量随机输入，发现边界情况、panic和内存安全问题。Go 1.18+内置的模糊测试框架使这些测试更容易编写和运行。