Go语言中测试同名但绑定不同结构体的方法

// main.go
package main

import "fmt"

// Type one 结构体
type one struct{}

// fly 方法，绑定到 one 结构体，返回一个字符串表示其行为
func (o *one) fly() string {
    return "one is flying gracefully"
}

// Type two 结构体
type two struct{}

// fly 方法，绑定到 two 结构体，返回一个字符串表示其行为
func (t *two) fly() string {
    return "two is flying powerfully"
}

func main() {
    o := &one{}
    t := &two{}
    fmt.Println(o.fly())
    fmt.Println(t.fly())
}

// main_test.go
package main

import "testing"

// TestOneFly 测试 one 结构体的 fly 方法
func TestOneFly(t *testing.T) {
    o := &one{} // 实例化 one 结构体
    expected := "one is flying gracefully"
    actual := o.fly() // 调用 fly 方法

    // 断言结果是否符合预期
    if actual != expected {
        t.Errorf("TestOneFly failed: expected %q, got %q", expected, actual)
    }
}

// TestTwoFly 测试 two 结构体的 fly 方法
func TestTwoFly(t *testing.T) {
    tt := &two{} // 实例化 two 结构体 (变量名避免与 t *testing.T 冲突)
    expected := "two is flying powerfully"
    actual := tt.fly() // 调用 fly 方法

    // 断言结果是否符合预期
    if actual != expected {
        t.Errorf("TestTwoFly failed: expected %q, got %q", expected, actual)
    }
}

// main_test.go (在现有测试函数基础上添加)
package main

import "testing"

// ... (TestOneFly 和 TestTwoFly 保持不变或根据需要删除)

// TestAllFlyMethods 整合测试所有 fly 方法
func TestAllFlyMethods(t *testing.T) {
    // 使用 t.Run 创建子测试，测试 one 结构体的 fly 方法
    t.Run("Test one.fly() method", func(t *testing.T) {
        o := &one{}
        expected := "one is flying gracefully"
        actual := o.fly()
        if actual != expected {
            t.Errorf("one.fly() failed: expected %q, got %q", expected, actual)
        }
    })

    // 使用 t.Run 创建子测试，测试 two 结构体的 fly 方法
    t.Run("Test two.fly() method", func(t *testing.T) {
        tt := &two{}
        expected := "two is flying powerfully"
        actual := tt.fly()
        if actual != expected {
            t.Errorf("two.fly() failed: expected %q, got %q", expected, actual)
        }
    })
}