Go语言中错误处理与测试命名规范的最佳实践

import "yourpkg" // 假设你的包名为 yourpkg

func main() {
    if err := yourpkg.Function(); err == yourpkg.ErrTimeout {
        fmt.Println("连接超时错误:", err)
    } else if err != nil {
        fmt.Println("其他错误:", err)
    }

    if err := yourpkg.AnotherFunction(); err == yourpkg.ErrSyntax {
        fmt.Println("语法错误:", err)
    }
}

package yourpkg

import "fmt"

// SyntaxError 表示一个语法错误，包含错误发生的位置和详细描述。
type SyntaxError struct {
    File        string
    Line, Pos   int
    Description string
}

// Error 方法实现了 error 接口，返回格式化的错误信息。
func (e *SyntaxError) Error() string {
    return fmt.Sprintf("%s:%d:%d: %s", e.File, e.Line, e.Pos, e.Description)
}

func Parse(fileContent string) (interface{}, error) {
    // 假设解析逻辑中检测到语法错误
    if fileContent == "bad syntax" {
        return nil, &SyntaxError{
            File:        "example.go",
            Line:        10,
            Pos:         5,
            Description: "unexpected token 'bad'",
        }
    }
    return "parsed data", nil
}

import "yourpkg"

func main() {
    _, err := yourpkg.Parse("bad syntax")
    if serr, ok := err.(*yourpkg.SyntaxError); ok {
        fmt.Printf("语法错误发生在文件 %s 的 %d 行 %d 列: %s
", serr.File, serr.Line, serr.Pos, serr.Description)
    } else if err != nil {
        fmt.Println("其他错误:", err)
    }
}

func TestXxx(t *testing.T) { ... }

package yourpkg_test

import (
    "errors"
    "fmt"
    "strings"
    "testing"
)

// 模拟 yourpkg 包中的 Parse 函数和错误常量
var (
    ErrBadOrdinal    = errors.New("yourpkg: bad ordinal")
    ErrUnexpectedEOF = errors.New("yourpkg: unexpected EOF")
)

// Parse 模拟被测试的函数
func Parse(r *strings.Reader) error {
    content, _ := r.ReadString(0) // 简化读取
    switch strings.TrimSpace(content) {
    case "blah":
        return ErrBadOrdinal
    case "":
        return ErrUnexpectedEOF
    case "1st", "2nd", "third":
        return nil
    default:
        return fmt.Errorf("yourpkg: unknown content %q", content)
    }
}

func TestParse(t *testing.T) {
    // 定义测试用例
    tests := []struct {
        name     string        // 测试用例名称
        contents string        // 输入内容
        wantErr  error         // 期望的错误
    }{
        {"Valid_First", "1st", nil},
        {"Valid_Second", "2nd", nil},
        {"Valid_Third", "third", nil},
        {"Error_BadOrdinal", "blah", ErrBadOrdinal},
        {"Error_UnexpectedEOF", "", ErrUnexpectedEOF},
        {"Error_Unknown", "random", errors.New("yourpkg: unknown content "random\x00"")}, // 假设的未知错误
    }

    // 遍历测试用例并执行测试
    for _, test := range tests {
        t.Run(test.name, func(t *testing.T) { // 使用 t.Run 为每个子测试命名
            fileReader := strings.NewReader(test.contents)
            err := Parse(fileReader)

            // 比较错误
            if !errors.Is(err, test.wantErr) { // 使用 errors.Is 比较错误链或常量
                // 特殊处理模拟的未知错误，因为 errors.New 每次创建都是新对象
                if test.wantErr != nil && strings.HasPrefix(test.wantErr.Error(), "yourpkg: unknown content") &&
                    err != nil && strings.HasPrefix(err.Error(), "yourpkg: unknown content") {
                    // 认为匹配
                } else {
                    t.Errorf("Parse(%q) got error %q, want error %q", test.contents, err, test.wantErr)
                }
            }
            // 如果需要，这里还可以添加对其他返回值的检查
        })
    }
}

func TestParseTimeout(t *testing.T) {
    // 专门测试 Parse 函数的超时行为
    // ...
}