Go语言错误处理与测试命名规范：构建健壮且可维护的代码

package yourpkg

import "errors"

// 错误常量
var (
    ErrTimeout   = errors.New("yourpkg: connect timeout")
    ErrInvalid   = errors.New("yourpkg: invalid configuration")
    ErrBadOrdinal = errors.New("yourpkg: bad ordinal")
    ErrUnexpectedEOF = errors.New("yourpkg: unexpected EOF")
)

// 示例函数，可能返回上述错误
func Connect() error {
    // 模拟连接超时
    return ErrTimeout
}

func Configure(config string) error {
    if config == "" {
        return ErrInvalid
    }
    return nil
}

import "yourpkg"

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

package yourpkg

import "fmt"

type yourpkgError int // 未导出的自定义错误类型

// 错误常量
const (
    ErrTimeout yourpkgError = iota // 0
    ErrSyntax                      // 1
    ErrConfig                      // 2
    ErrInvalid                     // 3
)

var errText = map[yourpkgError]string{
    ErrTimeout: "yourpkg: connect timed out",
    ErrSyntax:  "yourpkg: syntax error",
    ErrConfig:  "yourpkg: invalid configuration",
    ErrInvalid: "yourpkg: invalid input",
}

func (e yourpkgError) Error() string {
    if s, ok := errText[e]; ok {
        return s
    }
    return fmt.Sprintf("yourpkg: unknown error %d", e)
}

// 示例函数
func ProcessInput(input string) error {
    if input == "" {
        return ErrInvalid
    }
    // ...
    return nil
}

import "yourpkg"

func main() {
    if err := yourpkg.ProcessInput(""); err == yourpkg.ErrInvalid {
        fmt.Println("输入无效")
    }
}

package yourpkg

import "fmt"

// SyntaxError 表示语法错误，包含详细位置信息
type SyntaxError struct {
    File        string
    Line, Column int
    Description string
}

func (e *SyntaxError) Error() string {
    return fmt.Sprintf("%s:%d:%d: %s", e.File, e.Line, e.Column, e.Description)
}

// 示例解析函数
func Parse(fileContent string) (interface{}, error) {
    // 模拟解析失败
    if fileContent == "bad syntax" {
        return nil, &SyntaxError{
            File:        "example.go",
            Line:        10,
            Column:      5,
            Description: "unexpected token",
        }
    }
    return "parsed data", nil
}

import "yourpkg"

func main() {
    tree, err := yourpkg.Parse("bad syntax")
    if serr, ok := err.(*yourpkg.SyntaxError); ok {
        // 处理语法错误，可以访问 serr.File, serr.Line 等
        fmt.Printf("语法错误发生在 %s:%d，描述: %s\n", serr.File, serr.Line, serr.Description)
    } else if err != nil {
        // 处理其他错误
        fmt.Println("发生其他错误:", err)
    } else {
        fmt.Println("解析成功:", tree)
    }
}

// 假设你的包中有一个 Parse 函数
func Parse(r io.Reader) (interface{}, error) {
    // ... 实现解析逻辑
}

// 对应的测试函数
func TestParse(t *testing.T) {
    // ... 测试 Parse 函数的正常逻辑
}

package yourpkg_test

import (
    "fmt"
    "io"
    "strings"
    "testing"
    "yourpkg" // 假设你的包名为 yourpkg
)

// 假设 yourpkg 包中定义了以下错误
// var ErrBadOrdinal = errors.New("yourpkg: bad ordinal")
// var ErrUnexpectedEOF = errors.New("yourpkg: unexpected EOF")
// type SyntaxError struct { ... }

func TestParse(t *testing.T) {
    // 定义测试用例结构体
    tests := []struct {
        name     string         // 测试用例名称
        contents string         // 输入内容
        wantErr  error          // 预期返回的错误，nil 表示无错误
        wantData string         // 预期返回的数据（简化为string，实际可为interface{}）
        isSyntaxErr bool        // 标记是否预期 SyntaxError
    }{
        {"ValidOrdinal1", "1st", nil, "parsed 1st", false},
        {"ValidOrdinal2", "2nd", nil, "parsed 2nd", false},
        {"ValidOrdinal3", "third", nil, "parsed third", false},
        {"BadOrdinal", "blah", yourpkg.ErrBadOrdinal, "", false},
        {"EmptyInput", "", yourpkg.ErrUnexpectedEOF, "", false},
        {"SyntaxError", "bad syntax", &yourpkg.SyntaxError{}, "", true}, // 预期SyntaxError，但具体字段可能不同
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) { // 使用 t.Run 为每个子测试命名
            file := strings.NewReader(tt.contents)

            // 假设 yourpkg.Parse 返回 (string, error)
            gotData, err := yourpkg.Parse(file) 

            if tt.wantErr != nil {
                // 预期有错误
                if err == nil {
                    t.Errorf("Parse(%q) 预期错误 %q, 实际却无错误", tt.contents, tt.wantErr)
                } else if tt.isSyntaxErr {
                    // 预期是 SyntaxError，进行类型断言
                    if _, ok := err.(*yourpkg.SyntaxError); !ok {
                        t.Errorf("Parse(%q) 预期 SyntaxError, 实际错误类型为 %T (%q)", tt.contents, err, err)
                    }
                    // 如果需要，可以进一步检查 SyntaxError 的字段
                } else if err != tt.wantErr {
                    // 预期是特定错误常量，进行值比较
                    t.Errorf("Parse(%q) 错误 %q, 预期错误 %q", tt.contents, err, tt.wantErr)
                }
            } else {
                // 预期无错误
                if err != nil {
                    t.Errorf("Parse(%q) 预期无错误, 实际错误 %q", tt.contents, err)
                }
                // 进一步检查返回的数据
                if gotData != tt.wantData {
                    t.Errorf("Parse(%q) 得到数据 %q, 预期数据 %q", tt.contents, gotData, tt.wantData)
                }
            }
        })
    }
}

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