/*
04-testing.go - Go 语言测试详解
学习目标：
1. 理解 Go 语言测试的基本概念
2. 掌握单元测试的编写方法
3. 学会基准测试和性能分析
4. 了解测试覆盖率和测试工具
5. 掌握测试的最佳实践
知识点：
- 测试函数的命名和签名
- testing 包的使用
- 表驱动测试模式
- 基准测试和内存分析
- 测试覆盖率
- 测试工具和技巧
*/

package main

import (
	"fmt"
	"sort"
	"strings"
	"time"
)

// 这个文件演示了如何编写各种类型的测试
// 注意：实际的测试文件应该以 _test.go 结尾

func main() {
	fmt.Println("=== Go 语言测试详解 ===\n")

	// 演示测试的基本概念
	demonstrateTestingBasics()

	// 演示单元测试
	demonstrateUnitTesting()

	// 演示表驱动测试
	demonstrateTableDrivenTests()

	// 演示基准测试
	demonstrateBenchmarkTesting()

	// 演示示例测试
	demonstrateExampleTesting()

	// 演示测试工具和技巧
	demonstrateTestingTools()

	// 演示测试的最佳实践
	demonstrateTestingBestPractices()
}

// demonstrateTestingBasics 演示测试的基本概念
func demonstrateTestingBasics() {
	fmt.Println("1. 测试的基本概念:")

	// 测试的重要性
	fmt.Printf("   测试的重要性:\n")
	fmt.Printf("     - 验证代码的正确性\n")
	fmt.Printf("     - 防止回归错误\n")
	fmt.Printf("     - 提高代码质量\n")
	fmt.Printf("     - 便于重构和维护\n")
	fmt.Printf("     - 作为代码的文档\n")

	// Go 测试的特点
	fmt.Printf("   Go 测试的特点:\n")
	fmt.Printf("     - 内置测试框架\n")
	fmt.Printf("     - 简单的测试语法\n")
	fmt.Printf("     - 强大的工具支持\n")
	fmt.Printf("     - 并行测试支持\n")
	fmt.Printf("     - 基准测试集成\n")

	// 测试文件的组织
	fmt.Printf("   测试文件的组织:\n")
	fmt.Printf("     源文件: calculator.go\n")
	fmt.Printf("     测试文件: calculator_test.go\n")
	fmt.Printf("     \n")
	fmt.Printf("     源文件: utils.go\n")
	fmt.Printf("     测试文件: utils_test.go\n")

	// 测试函数的类型
	fmt.Printf("   测试函数的类型:\n")
	fmt.Printf("     1. 单元测试: func TestXxx(*testing.T)\n")
	fmt.Printf("     2. 基准测试: func BenchmarkXxx(*testing.B)\n")
	fmt.Printf("     3. 示例测试: func ExampleXxx()\n")
	fmt.Printf("     4. 模糊测试: func FuzzXxx(*testing.F) (Go 1.18+)\n")

	// 运行测试的命令
	fmt.Printf("   运行测试的命令:\n")
	fmt.Printf("     go test                    # 运行当前包的测试\n")
	fmt.Printf("     go test ./...              # 运行所有子包的测试\n")
	fmt.Printf("     go test -v                 # 详细输出\n")
	fmt.Printf("     go test -run TestAdd       # 运行特定测试\n")
	fmt.Printf("     go test -bench=.           # 运行基准测试\n")
	fmt.Printf("     go test -cover             # 显示覆盖率\n")

	fmt.Println()
}

// demonstrateUnitTesting 演示单元测试
func demonstrateUnitTesting() {
	fmt.Println("2. 单元测试:")

	// 基本测试函数
	fmt.Printf("   基本测试函数:\n")
	fmt.Printf("     func TestAdd(t *testing.T) {\n")
	fmt.Printf("         result := Add(2, 3)\n")
	fmt.Printf("         expected := 5\n")
	fmt.Printf("         if result != expected {\n")
	fmt.Printf("             t.Errorf(\\\"Add(2, 3) = %%d; want %%d\\\", result, expected)\n")
	fmt.Printf("         }\n")
	fmt.Printf("     }\n")

	// 模拟运行测试
	fmt.Printf("   模拟运行测试:\n")
	mockT := &MockT{}

	// 测试 Add 函数
	fmt.Printf("     测试 Add 函数:\n")
	TestAdd(mockT)
	if mockT.failed {
		fmt.Printf("       ❌ 测试失败: %s\n", mockT.errorMsg)
	} else {
		fmt.Printf("       ✅ 测试通过\n")
	}

	// 测试 Divide 函数
	fmt.Printf("     测试 Divide 函数:\n")
	mockT = &MockT{}
	TestDivide(mockT)
	if mockT.failed {
		fmt.Printf("       ❌ 测试失败: %s\n", mockT.errorMsg)
	} else {
		fmt.Printf("       ✅ 测试通过\n")
	}

	// 测试 IsPrime 函数
	fmt.Printf("     测试 IsPrime 函数:\n")
	mockT = &MockT{}
	TestIsPrime(mockT)
	if mockT.failed {
		fmt.Printf("       ❌ 测试失败: %s\n", mockT.errorMsg)
	} else {
		fmt.Printf("       ✅ 测试通过\n")
	}

	// testing.T 的方法
	fmt.Printf("   testing.T 的方法:\n")
	fmt.Printf("     t.Error(args ...)          # 记录错误但继续测试\n")
	fmt.Printf("     t.Errorf(format, args ...) # 格式化错误信息\n")
	fmt.Printf("     t.Fatal(args ...)          # 记录错误并停止测试\n")
	fmt.Printf("     t.Fatalf(format, args ...) # 格式化致命错误\n")
	fmt.Printf("     t.Log(args ...)            # 记录日志信息\n")
	fmt.Printf("     t.Logf(format, args ...)   # 格式化日志信息\n")
	fmt.Printf("     t.Skip(args ...)           # 跳过测试\n")
	fmt.Printf("     t.Helper()                 # 标记为辅助函数\n")

	fmt.Println()
}

// demonstrateTableDrivenTests 演示表驱动测试
func demonstrateTableDrivenTests() {
	fmt.Println("3. 表驱动测试:")

	// 表驱动测试的优势
	fmt.Printf("   表驱动测试的优势:\n")
	fmt.Printf("     - 减少重复代码\n")
	fmt.Printf("     - 易于添加新的测试用例\n")
	fmt.Printf("     - 提高测试的可维护性\n")
	fmt.Printf("     - 清晰的测试数据结构\n")

	// 表驱动测试示例
	fmt.Printf("   表驱动测试示例:\n")
	fmt.Printf("     func TestAddTable(t *testing.T) {\n")
	fmt.Printf("         tests := []struct {\n")
	fmt.Printf("             name     string\n")
	fmt.Printf("             a, b     int\n")
	fmt.Printf("             expected int\n")
	fmt.Printf("         }{\n")
	fmt.Printf("             {\\\"positive\\\", 2, 3, 5},\n")
	fmt.Printf("             {\\\"negative\\\", -1, -2, -3},\n")
	fmt.Printf("             {\\\"zero\\\", 0, 5, 5},\n")
	fmt.Printf("         }\n")
	fmt.Printf("         \n")
	fmt.Printf("         for _, tt := range tests {\n")
	fmt.Printf("             t.Run(tt.name, func(t *testing.T) {\n")
	fmt.Printf("                 result := Add(tt.a, tt.b)\n")
	fmt.Printf("                 if result != tt.expected {\n")
	fmt.Printf("                     t.Errorf(\\\"got %%d, want %%d\\\", result, tt.expected)\n")
	fmt.Printf("                 }\n")
	fmt.Printf("             })\n")
	fmt.Printf("         }\n")
	fmt.Printf("     }\n")

	// 模拟运行表驱动测试
	fmt.Printf("   模拟运行表驱动测试:\n")
	mockT := &MockT{}
	TestAddTable(mockT)

	// 字符串处理的表驱动测试
	fmt.Printf("   字符串处理的表驱动测试:\n")
	mockT = &MockT{}
	TestStringOperations(mockT)

	// 错误处理的表驱动测试
	fmt.Printf("   错误处理的表驱动测试:\n")
	mockT = &MockT{}
	TestValidateInput(mockT)

	fmt.Println()
}

// demonstrateBenchmarkTesting 演示基准测试
func demonstrateBenchmarkTesting() {
	fmt.Println("4. 基准测试:")

	// 基准测试的概念
	fmt.Printf("   基准测试的概念:\n")
	fmt.Printf("     - 测量代码的性能\n")
	fmt.Printf("     - 比较不同实现的效率\n")
	fmt.Printf("     - 识别性能瓶颈\n")
	fmt.Printf("     - 验证优化效果\n")

	// 基准测试函数
	fmt.Printf("   基准测试函数:\n")
	fmt.Printf("     func BenchmarkStringConcat(b *testing.B) {\n")
	fmt.Printf("         for i := 0; i < b.N; i++ {\n")
	fmt.Printf("             _ = \\\"hello\\\" + \\\"world\\\"\n")
	fmt.Printf("         }\n")
	fmt.Printf("     }\n")

	// 模拟运行基准测试
	fmt.Printf("   模拟运行基准测试:\n")

	// 字符串连接基准测试
	fmt.Printf("     字符串连接性能比较:\n")
	runBenchmark("StringConcat", BenchmarkStringConcat)
	runBenchmark("StringBuffer", BenchmarkStringBuffer)
	runBenchmark("StringBuilder", BenchmarkStringBuilder)

	// 排序算法基准测试
	fmt.Printf("     排序算法性能比较:\n")
	runBenchmark("BubbleSort", BenchmarkBubbleSort)
	runBenchmark("QuickSort", BenchmarkQuickSort)
	runBenchmark("StandardSort", BenchmarkStandardSort)

	// 基准测试的运行参数
	fmt.Printf("   基准测试的运行参数:\n")
	fmt.Printf("     go test -bench=.                    # 运行所有基准测试\n")
	fmt.Printf("     go test -bench=BenchmarkAdd         # 运行特定基准测试\n")
	fmt.Printf("     go test -bench=. -benchmem          # 显示内存分配\n")
	fmt.Printf("     go test -bench=. -benchtime=10s     # 设置运行时间\n")
	fmt.Printf("     go test -bench=. -count=5           # 运行多次\n")

	// 基准测试结果解读
	fmt.Printf("   基准测试结果解读:\n")
	fmt.Printf("     BenchmarkAdd-8    1000000000    0.50 ns/op    0 B/op    0 allocs/op\n")
	fmt.Printf("     │               │            │             │         │\n")
	fmt.Printf("     │               │            │             │         └─ 每次操作的分配次数\n")
	fmt.Printf("     │               │            │             └─ 每次操作分配的字节数\n")
	fmt.Printf("     │               │            └─ 每次操作的平均时间\n")
	fmt.Printf("     │               └─ 执行次数\n")
	fmt.Printf("     └─ 基准测试名称和CPU核心数\n")

	fmt.Println()
}

// demonstrateExampleTesting 演示示例测试
func demonstrateExampleTesting() {
	fmt.Println("5. 示例测试:")

	// 示例测试的概念
	fmt.Printf("   示例测试的概念:\n")
	fmt.Printf("     - 提供函数使用示例\n")
	fmt.Printf("     - 验证输出结果\n")
	fmt.Printf("     - 生成文档\n")
	fmt.Printf("     - 确保示例代码正确\n")

	// 示例测试函数
	fmt.Printf("   示例测试函数:\n")
	fmt.Printf("     func ExampleAdd() {\n")
	fmt.Printf("         result := Add(2, 3)\n")
	fmt.Printf("         fmt.Println(result)\n")
	fmt.Printf("         // Output: 5\n")
	fmt.Printf("     }\n")

	// 运行示例测试
	fmt.Printf("   运行示例测试:\n")
	fmt.Printf("     Add 函数示例:\n")
	ExampleAdd()

	fmt.Printf("     Divide 函数示例:\n")
	ExampleDivide()

	fmt.Printf("     StringReverse 函数示例:\n")
	ExampleStringReverse()

	// 示例测试的特点
	fmt.Printf("   示例测试的特点:\n")
	fmt.Printf("     1. 函数名以 Example 开头\n")
	fmt.Printf("     2. 使用 // Output: 注释指定期望输出\n")
	fmt.Printf("     3. 可以使用 // Unordered output: 处理无序输出\n")
	fmt.Printf("     4. 会在 go doc 中显示\n")
	fmt.Printf("     5. 可以通过 go test 验证\n")

	fmt.Println()
}

// demonstrateTestingTools 演示测试工具和技巧
func demonstrateTestingTools() {
	fmt.Println("6. 测试工具和技巧:")

	// 测试覆盖率
	fmt.Printf("   测试覆盖率:\n")
	fmt.Printf("     go test -cover                    # 显示覆盖率\n")
	fmt.Printf("     go test -coverprofile=cover.out  # 生成覆盖率文件\n")
	fmt.Printf("     go tool cover -html=cover.out    # 生成HTML报告\n")
	fmt.Printf("     go tool cover -func=cover.out    # 显示函数覆盖率\n")

	// 测试辅助函数
	fmt.Printf("   测试辅助函数:\n")
	fmt.Printf("     func assertEqual(t *testing.T, got, want interface{}) {\n")
	fmt.Printf("         t.Helper()  // 标记为辅助函数\n")
	fmt.Printf("         if got != want {\n")
	fmt.Printf("             t.Errorf(\\\"got %%v, want %%v\\\", got, want)\n")
	fmt.Printf("         }\n")
	fmt.Printf("     }\n")

	// 模拟使用辅助函数
	fmt.Printf("   使用辅助函数:\n")
	mockT := &MockT{}
	TestWithHelpers(mockT)
	if mockT.failed {
		fmt.Printf("     ❌ 测试失败: %s\n", mockT.errorMsg)
	} else {
		fmt.Printf("     ✅ 测试通过\n")
	}

	// 子测试
	fmt.Printf("   子测试:\n")
	fmt.Printf("     t.Run(\\\"subtest\\\", func(t *testing.T) {\n")
	fmt.Printf("         // 子测试代码\n")
	fmt.Printf("     })\n")

	// 并行测试
	fmt.Printf("   并行测试:\n")
	fmt.Printf("     func TestParallel(t *testing.T) {\n")
	fmt.Printf("         t.Parallel()  // 标记为并行测试\n")
	fmt.Printf("         // 测试代码\n")
	fmt.Printf("     }\n")

	// 测试设置和清理
	fmt.Printf("   测试设置和清理:\n")
	fmt.Printf("     func TestMain(m *testing.M) {\n")
	fmt.Printf("         setup()    // 全局设置\n")
	fmt.Printf("         code := m.Run()\n")
	fmt.Printf("         teardown() // 全局清理\n")
	fmt.Printf("         os.Exit(code)\n")
	fmt.Printf("     }\n")

	// 跳过测试
	fmt.Printf("   跳过测试:\n")
	fmt.Printf("     if testing.Short() {\n")
	fmt.Printf("         t.Skip(\\\"跳过长时间运行的测试\\\")\n")
	fmt.Printf("     }\n")

	// 临时目录
	fmt.Printf("   临时目录:\n")
	fmt.Printf("     tmpDir := t.TempDir()  // 创建临时目录\n")
	fmt.Printf("     // 测试结束后自动清理\n")

	fmt.Println()
}

// demonstrateTestingBestPractices 演示测试的最佳实践
func demonstrateTestingBestPractices() {
	fmt.Println("7. 测试的最佳实践:")

	// 测试命名
	fmt.Printf("   测试命名:\n")
	fmt.Printf("     1. 使用描述性的测试名称\n")
	fmt.Printf("     2. 包含被测试的功能和场景\n")
	fmt.Printf("     3. 使用一致的命名约定\n")
	fmt.Printf("     \n")
	fmt.Printf("     好的命名:\n")
	fmt.Printf("       TestAdd_PositiveNumbers\n")
	fmt.Printf("       TestDivide_ByZero_ReturnsError\n")
	fmt.Printf("       TestUser_Create_ValidInput\n")

	// 测试组织
	fmt.Printf("   测试组织:\n")
	fmt.Printf("     1. 每个源文件对应一个测试文件\n")
	fmt.Printf("     2. 按功能分组测试\n")
	fmt.Printf("     3. 使用子测试组织复杂场景\n")
	fmt.Printf("     4. 保持测试的独立性\n")

	// 测试数据
	fmt.Printf("   测试数据:\n")
	fmt.Printf("     1. 使用表驱动测试处理多个用例\n")
	fmt.Printf("     2. 包含边界条件和异常情况\n")
	fmt.Printf("     3. 使用有意义的测试数据\n")
	fmt.Printf("     4. 避免硬编码的魔法数字\n")

	// 断言
	fmt.Printf("   断言:\n")
	fmt.Printf("     1. 使用清晰的错误消息\n")
	fmt.Printf("     2. 一个测试只验证一个行为\n")
	fmt.Printf("     3. 优先使用 Errorf 而不是 Error\n")
	fmt.Printf("     4. 在必要时使用 Fatal 停止测试\n")

	// 测试覆盖率
	fmt.Printf("   测试覆盖率:\n")
	fmt.Printf("     1. 追求高覆盖率但不盲目追求100%%\n")
	fmt.Printf("     2. 关注重要的业务逻辑\n")
	fmt.Printf("     3. 测试边界条件和错误路径\n")
	fmt.Printf("     4. 使用覆盖率工具识别遗漏\n")

	// 性能考虑
	fmt.Printf("   性能考虑:\n")
	fmt.Printf("     1. 避免在测试中进行复杂计算\n")
	fmt.Printf("     2. 使用并行测试提高速度\n")
	fmt.Printf("     3. 合理使用测试缓存\n")
	fmt.Printf("     4. 避免不必要的外部依赖\n")

	// 测试维护
	fmt.Printf("   测试维护:\n")
	fmt.Printf("     1. 保持测试代码的简洁\n")
	fmt.Printf("     2. 定期重构测试代码\n")
	fmt.Printf("     3. 及时更新过时的测试\n")
	fmt.Printf("     4. 删除无用的测试\n")

	// 常见陷阱
	fmt.Printf("   常见陷阱:\n")
	fmt.Printf("     1. 测试依赖外部状态\n")
	fmt.Printf("     2. 测试之间相互依赖\n")
	fmt.Printf("     3. 忽略错误处理的测试\n")
	fmt.Printf("     4. 过度复杂的测试逻辑\n")
	fmt.Printf("     5. 不稳定的测试（flaky tests）\n")

	fmt.Println()
}

// ========== 被测试的函数 ==========

// Add 计算两个整数的和
func Add(a, b int) int {
	return a + b
}

// Divide 计算两个数的商
func Divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, fmt.Errorf("division by zero")
	}
	return a / b, nil
}

// IsPrime 判断是否为质数
func IsPrime(n int) bool {
	if n < 2 {
		return false
	}
	for i := 2; i*i <= n; i++ {
		if n%i == 0 {
			return false
		}
	}
	return true
}

// StringReverse 反转字符串
func StringReverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

// Capitalize 将字符串首字母大写
func Capitalize(s string) string {
	if len(s) == 0 {
		return s
	}
	return strings.ToUpper(s[:1]) + strings.ToLower(s[1:])
}

// ValidateInput 验证输入
func ValidateInput(input string) error {
	if len(input) == 0 {
		return fmt.Errorf("input cannot be empty")
	}
	if len(input) > 100 {
		return fmt.Errorf("input too long")
	}
	return nil
}

// ========== 模拟的 testing.T 和 testing.B ==========

// MockT 模拟 testing.T 类型
type MockT struct {
	failed   bool
	errorMsg string
	logs     []string
}

func (m *MockT) Error(args ...interface{}) {
	m.failed = true
	m.errorMsg = fmt.Sprint(args...)
}

func (m *MockT) Errorf(format string, args ...interface{}) {
	m.failed = true
	m.errorMsg = fmt.Sprintf(format, args...)
}

func (m *MockT) Fatal(args ...interface{}) {
	m.failed = true
	m.errorMsg = fmt.Sprint(args...)
}

func (m *MockT) Fatalf(format string, args ...interface{}) {
	m.failed = true
	m.errorMsg = fmt.Sprintf(format, args...)
}

func (m *MockT) Log(args ...interface{}) {
	m.logs = append(m.logs, fmt.Sprint(args...))
}

func (m *MockT) Logf(format string, args ...interface{}) {
	m.logs = append(m.logs, fmt.Sprintf(format, args...))
}

func (m *MockT) Helper() {
	// 标记为辅助函数
}

func (m *MockT) Run(name string, f func(*MockT)) bool {
	fmt.Printf("       运行子测试: %s\n", name)
	subT := &MockT{}
	f(subT)
	if subT.failed {
		fmt.Printf("         ❌ 失败: %s\n", subT.errorMsg)
		return false
	} else {
		fmt.Printf("         ✅ 通过\n")
		return true
	}
}

// MockB 模拟 testing.B 类型
type MockB struct {
	N int
}

func (b *MockB) ResetTimer()   {}
func (b *MockB) ReportAllocs() {}

// ========== 测试函数示例 ==========

// TestAdd 测试 Add 函数
func TestAdd(t *MockT) {
	result := Add(2, 3)
	expected := 5
	if result != expected {
		t.Errorf("Add(2, 3) = %d; want %d", result, expected)
	}
}

// TestDivide 测试 Divide 函数
func TestDivide(t *MockT) {
	// 正常情况
	result, err := Divide(10, 2)
	if err != nil {
		t.Errorf("Divide(10, 2) returned error: %v", err)
		return
	}
	if result != 5 {
		t.Errorf("Divide(10, 2) = %f; want 5", result)
	}

	// 除零情况
	_, err = Divide(10, 0)
	if err == nil {
		t.Error("Divide(10, 0) should return error")
	}
}

// TestIsPrime 测试 IsPrime 函数
func TestIsPrime(t *MockT) {
	tests := []struct {
		n        int
		expected bool
	}{
		{2, true},
		{3, true},
		{4, false},
		{17, true},
		{25, false},
		{1, false},
		{0, false},
		{-1, false},
	}

	for _, tt := range tests {
		result := IsPrime(tt.n)
		if result != tt.expected {
			t.Errorf("IsPrime(%d) = %t; want %t", tt.n, result, tt.expected)
		}
	}
}

// TestAddTable 表驱动测试示例
func TestAddTable(t *MockT) {
	tests := []struct {
		name     string
		a, b     int
		expected int
	}{
		{"positive numbers", 2, 3, 5},
		{"negative numbers", -1, -2, -3},
		{"mixed numbers", -1, 2, 1},
		{"zero", 0, 5, 5},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(subT *MockT) {
			result := Add(tt.a, tt.b)
			if result != tt.expected {
				subT.Errorf("Add(%d, %d) = %d; want %d", tt.a, tt.b, result, tt.expected)
			}
		})
	}
}

// TestStringOperations 字符串操作测试
func TestStringOperations(t *MockT) {
	tests := []struct {
		name     string
		input    string
		expected string
	}{
		{"normal string", "hello", "Hello"},
		{"empty string", "", ""},
		{"single char", "a", "A"},
		{"already capitalized", "Hello", "Hello"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(subT *MockT) {
			result := Capitalize(tt.input)
			if result != tt.expected {
				subT.Errorf("Capitalize(%q) = %q; want %q", tt.input, result, tt.expected)
			}
		})
	}
}

// TestValidateInput 输入验证测试
func TestValidateInput(t *MockT) {
	tests := []struct {
		name      string
		input     string
		wantError bool
	}{
		{"valid input", "hello", false},
		{"empty input", "", true},
		{"too long input", strings.Repeat("a", 101), true},
		{"max length input", strings.Repeat("a", 100), false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(subT *MockT) {
			err := ValidateInput(tt.input)
			if (err != nil) != tt.wantError {
				subT.Errorf("ValidateInput(%q) error = %v; wantError %t", tt.input, err, tt.wantError)
			}
		})
	}
}

// TestWithHelpers 使用辅助函数的测试
func TestWithHelpers(t *MockT) {
	assertEqual := func(t *MockT, got, want interface{}) {
		t.Helper()
		if got != want {
			t.Errorf("got %v, want %v", got, want)
		}
	}

	// 使用辅助函数进行断言
	assertEqual(t, Add(2, 3), 5)
	assertEqual(t, Capitalize("hello"), "Hello")

	result, err := Divide(10, 2)
	if err != nil {
		t.Errorf("unexpected error: %v", err)
		return
	}
	assertEqual(t, result, 5.0)
}

// ========== 基准测试函数 ==========

// BenchmarkStringConcat 字符串连接基准测试
func BenchmarkStringConcat(b *MockB) {
	for i := 0; i < b.N; i++ {
		_ = "hello" + "world" + "golang" + "benchmark"
	}
}

// BenchmarkStringBuffer 字符串缓冲区基准测试
func BenchmarkStringBuffer(b *MockB) {
	for i := 0; i < b.N; i++ {
		var buffer strings.Builder
		buffer.WriteString("hello")
		buffer.WriteString("world")
		buffer.WriteString("golang")
		buffer.WriteString("benchmark")
		_ = buffer.String()
	}
}

// BenchmarkStringBuilder 字符串构建器基准测试
func BenchmarkStringBuilder(b *MockB) {
	for i := 0; i < b.N; i++ {
		parts := []string{"hello", "world", "golang", "benchmark"}
		_ = strings.Join(parts, "")
	}
}

// BenchmarkBubbleSort 冒泡排序基准测试
func BenchmarkBubbleSort(b *MockB) {
	data := []int{64, 34, 25, 12, 22, 11, 90}
	for i := 0; i < b.N; i++ {
		bubbleSort(append([]int(nil), data...))
	}
}

// BenchmarkQuickSort 快速排序基准测试
func BenchmarkQuickSort(b *MockB) {
	data := []int{64, 34, 25, 12, 22, 11, 90}
	for i := 0; i < b.N; i++ {
		quickSort(append([]int(nil), data...))
	}
}

// BenchmarkStandardSort 标准排序基准测试
func BenchmarkStandardSort(b *MockB) {
	data := []int{64, 34, 25, 12, 22, 11, 90}
	for i := 0; i < b.N; i++ {
		sort.Ints(append([]int(nil), data...))
	}
}

// ========== 示例测试函数 ==========

// ExampleAdd Add 函数的示例
func ExampleAdd() {
	result := Add(2, 3)
	fmt.Println(result)
	// Output: 5
}

// ExampleDivide Divide 函数的示例
func ExampleDivide() {
	result, err := Divide(10, 2)
	if err != nil {
		fmt.Printf("Error: %v", err)
		return
	}
	fmt.Printf("%.1f", result)
	// Output: 5.0
}

// ExampleStringReverse StringReverse 函数的示例
func ExampleStringReverse() {
	result := StringReverse("hello")
	fmt.Println(result)
	// Output: olleh
}

// ========== 辅助函数 ==========

// runBenchmark 运行基准测试
func runBenchmark(name string, benchFunc func(*MockB)) {
	b := &MockB{N: 1000000}
	start := time.Now()
	benchFunc(b)
	duration := time.Since(start)
	nsPerOp := duration.Nanoseconds() / int64(b.N)
	fmt.Printf("       %s: %d ns/op\n", name, nsPerOp)
}

// bubbleSort 冒泡排序
func bubbleSort(arr []int) {
	n := len(arr)
	for i := 0; i < n-1; i++ {
		for j := 0; j < n-i-1; j++ {
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
			}
		}
	}
}

// quickSort 快速排序
func quickSort(arr []int) {
	if len(arr) < 2 {
		return
	}

	pivot := partition(arr)
	quickSort(arr[:pivot])
	quickSort(arr[pivot+1:])
}

// partition 分区函数
func partition(arr []int) int {
	pivot := arr[len(arr)-1]
	i := -1

	for j := 0; j < len(arr)-1; j++ {
		if arr[j] <= pivot {
			i++
			arr[i], arr[j] = arr[j], arr[i]
		}
	}

	arr[i+1], arr[len(arr)-1] = arr[len(arr)-1], arr[i+1]
	return i + 1
}

/*
运行这个程序：
go run 04-testing.go

实际测试文件示例（calculator_test.go）：
package calculator

import "testing"

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    expected := 5
    if result != expected {
        t.Errorf("Add(2, 3) = %d; want %d", result, expected)
    }
}

func TestAddTable(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positive numbers", 2, 3, 5},
        {"negative numbers", -1, -2, -3},
        {"mixed numbers", -1, 2, 1},
        {"zero", 0, 5, 5},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := Add(tt.a, tt.b)
            if result != tt.expected {
                t.Errorf("got %d, want %d", result, tt.expected)
            }
        })
    }
}

func BenchmarkStringConcat(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = "hello" + "world"
    }
}

func ExampleAdd() {
    result := Add(2, 3)
    fmt.Println(result)
    // Output: 5
}

运行测试命令：
go test                    # 运行当前包的所有测试
go test -v                 # 详细输出
go test -run TestAdd       # 运行特定测试
go test -bench=.           # 运行基准测试
go test -cover             # 显示覆盖率
go test ./...              # 运行所有子包的测试

测试的核心概念：
1. 单元测试：验证单个函数或方法的正确性
2. 表驱动测试：使用测试数据表驱动测试执行
3. 基准测试：测量代码的性能和内存使用
4. 示例测试：提供函数使用示例并验证输出

测试的最佳实践：
1. 使用描述性的测试名称
2. 保持测试的独立性
3. 测试边界条件和错误情况
4. 使用表驱动测试处理多个用例
5. 编写清晰的错误消息
6. 保持高的测试覆盖率
7. 定期重构和维护测试代码

注意事项：
1. 测试文件必须以 _test.go 结尾
2. 测试函数必须以 Test 开头
3. 基准测试函数必须以 Benchmark 开头
4. 示例测试函数必须以 Example 开头
5. 使用 t.Helper() 标记辅助函数
6. 合理使用并行测试提高效率
*/