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 ValidateConfig() error {
    // 模拟配置无效
    return ErrInvalid
}

import "yourpkg"

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

package yourpkg

import "fmt"

// yourpkgError 是一个非导出类型，用于定义包内的错误常量
type yourpkgError int

// 错误常量
const (
    ErrTimeout yourpkgError = iota // 连接超时
    ErrSyntax                      // 语法错误
    ErrConfig                      // 配置错误
    ErrInvalid                     // 无效参数
)

// 错误消息映射
var errText = map[yourpkgError]string{
    ErrTimeout: "yourpkg: connect timed out",
    ErrSyntax:  "yourpkg: syntax error",
    ErrConfig:  "yourpkg: configuration error",
    ErrInvalid: "yourpkg: invalid argument",
}

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

// 示例函数
func ProcessData() error {
    // 模拟语法错误
    return ErrSyntax
}

package yourpkg

import "fmt"

// SyntaxError 表示一个语法错误，包含文件、行和位置信息
type SyntaxError struct {
    File        string
    Line, Column int
    Description string
}

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

// 示例函数，解析文件并可能返回 SyntaxError
func Parse(fileContent string) (interface{}, error) {
    // 模拟解析失败，返回 SyntaxError
    return nil, &SyntaxError{
        File:        "example.go",
        Line:        10,
        Column:      5,
        Description: "unexpected token 'func'",
    }
}

import "yourpkg"

func main() {
    _, err := yourpkg.Parse("some code")
    if serr, ok := err.(*yourpkg.SyntaxError); ok {
        // 处理语法错误，可以访问 serr 的字段
        fmt.Printf("语法错误在 %s:%d:%d: %s\n", serr.File, serr.Line, serr.Column, serr.Description)
    } else if err != nil {
        // 处理其他错误
        fmt.Println("其他解析错误:", err)
    }
}

func TestFunctionName(t *testing.T) {
    // 测试逻辑
}

func TestMethodName(t *testing.T) {
    // 测试逻辑
}

package yourpkg_test

import (
    "strings"
    "testing"
    "yourpkg" // 导入你的包
)

// TestParse 函数测试 yourpkg 包中的 Parse 函数
func TestParse(t *testing.T) {
    // 定义测试用例切片
    tests := []struct {
        name     string // 测试用例名称
        contents string // 输入内容
        wantErr  error  // 期望的错误
        // ... 其他期望结果，例如解析后的结构体
    }{
        {
            name:     "ValidInput1",
            contents: "1st",
            wantErr:  nil, // 期望无错误
        },
        {
            name:     "ValidInput2",
            contents: "2nd",
            wantErr:  nil,
        },
        {
            name:     "ValidInput3",
            contents: "third",
            wantErr:  nil,
        },
        {
            name:     "InvalidOrdinal",
            contents: "blah",
            wantErr:  yourpkg.ErrBadOrdinal, // 期望返回 ErrBadOrdinal
        },
        {
            name:     "EmptyInput",
            contents: "",
            wantErr:  yourpkg.ErrUnexpectedEOF, // 期望返回 ErrUnexpectedEOF
        },
        // 针对 SyntaxError 的测试
        {
            name:     "SyntaxError",
            contents: "func main {", // 模拟语法错误
            wantErr:  &yourpkg.SyntaxError{File: "test", Line: 1, Column: 1, Description: "unexpected token '{'"}, // 期望返回 SyntaxError
        },
    }

    // 遍历所有测试用例
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) { // 使用 t.Run 为每个用例创建子测试
            fileReader := strings.NewReader(tt.contents)
            _, err := yourpkg.Parse(fileReader) // 假设 Parse 函数接受 io.Reader

            // 检查错误类型
            if tt.wantErr == nil {
                // 期望无错误
                if err != nil {
                    t.Errorf("Parse(%q) returned error %q, want nil", tt.contents, err)
                }
            } else {
                // 期望有特定错误
                if err == nil {
                    t.Errorf("Parse(%q) returned nil, want error %q", tt.contents, tt.wantErr)
                } else if _, ok := tt.wantErr.(*yourpkg.SyntaxError); ok {
                    // 如果期望的是 SyntaxError，则进行类型断言比较
                    if _, errIsSyntax := err.(*yourpkg.SyntaxError); !errIsSyntax {
                        t.Errorf("Parse(%q) returned error type %T, want %T", tt.contents, err, tt.wantErr)
                    }
                    // 可以在这里进一步比较 SyntaxError 的字段
                } else if err != tt.wantErr {
                    // 对于其他错误常量，直接比较值
                    t.Errorf("Parse(%q) returned error %q, want error %q", tt.contents, err, tt.wantErr)
                }
            }
            // ... 其他验证，例如检查解析后的数据是否符合预期
        })
    }
}

// 假设 yourpkg.Parse 函数的定义如下，以便上面的测试代码能运行
// func Parse(r io.Reader) (interface{}, error) {
//  data, _ := io.ReadAll(r)
//  content := string(data)
//  switch content {
//  case "1st", "2nd", "third":
//      return content, nil
//  case "blah":
//      return nil, yourpkg.ErrBadOrdinal
//  case "":
//      return nil, yourpkg.ErrUnexpectedEOF
//  case "func main {":
//      return nil, &yourpkg.SyntaxError{File: "test", Line: 1, Column: 1, Description: "unexpected token '{'"}
//  default:
//      return nil, errors.New("unknown error")
//  }
// }

func TestParseTimeout(t *testing.T) {
    // 模拟一个导致超时的输入或环境
    // ...
    // 验证是否返回了超时错误
    // ...
}