Go语言测试包命名策略：白盒与黑盒测试的实践指南

// myfunc.go
package myfunc

import "fmt"

// ExportedFunc 是一个导出函数
func ExportedFunc() string {
    return "Hello from ExportedFunc"
}

// unexportedFunc 是一个非导出函数
func unexportedFunc() string {
    return "Hello from unexportedFunc"
}

// MyStruct 是一个导出结构体
type MyStruct struct {
    privateField string
}

// NewMyStruct 是 MyStruct 的构造函数
func NewMyStruct(field string) *MyStruct {
    return &MyStruct{privateField: field}
}

// GetPrivateField 是访问私有字段的方法
func (s *MyStruct) GetPrivateField() string {
    return s.privateField
}

// myfunc_test.go
package myfunc // 注意：与 myfunc.go 使用相同的包名

import (
    "testing"
)

func TestExportedFunc(t *testing.T) {
    expected := "Hello from ExportedFunc"
    if result := ExportedFunc(); result != expected {
        t.Errorf("ExportedFunc() = %s; want %s", result, expected)
    }
}

func TestUnexportedFunc(t *testing.T) {
    // 同包测试可以直接访问非导出函数
    expected := "Hello from unexportedFunc"
    if result := unexportedFunc(); result != expected {
        t.Errorf("unexportedFunc() = %s; want %s", result, expected)
    }
}

func TestMyStructPrivateField(t *testing.T) {
    s := NewMyStruct("test value")
    // 同包测试可以直接访问结构体的非导出字段
    if s.privateField != "test value" {
        t.Errorf("MyStruct.privateField = %s; want %s", s.privateField, "test value")
    }
}

// myfunc.go (与策略一相同)
package myfunc

import "fmt"

func ExportedFunc() string {
    return "Hello from ExportedFunc"
}

func unexportedFunc() string {
    return "Hello from unexportedFunc"
}

type MyStruct struct {
    privateField string
}

func NewMyStruct(field string) *MyStruct {
    return &MyStruct{privateField: field}
}

func (s *MyStruct) GetPrivateField() string {
    return s.privateField
}

// myfunc_test.go
package myfunc_test // 注意：使用独立的包名

import (
    "testing"
    "path/to/myfunc" // 导入被测试的包
)

func TestExportedFunc(t *testing.T) {
    expected := "Hello from ExportedFunc"
    if result := myfunc.ExportedFunc(); result != expected { // 通过包名调用
        t.Errorf("ExportedFunc() = %s; want %s", result, expected)
    }
}

func TestUnexportedFuncCannotBeAccessed(t *testing.T) {
    // 独立包测试无法直接访问非导出函数
    // myfunc.unexportedFunc() // 这行代码会导致编译错误
    t.Log("Cannot directly access unexportedFunc from myfunc_test package, which is expected.")
}

func TestMyStructPrivateFieldCannotBeAccessed(t *testing.T) {
    s := myfunc.NewMyStruct("test value")
    // 独立包测试无法直接访问结构体的非导出字段
    // if s.privateField != "test value" { // 这行代码会导致编译错误
    //     t.Errorf("MyStruct.privateField = %s; want %s", s.privateField, "test value")
    // }
    // 只能通过导出方法访问
    if s.GetPrivateField() != "test value" {
        t.Errorf("MyStruct.GetPrivateField() = %s; want %s", s.GetPrivateField(), "test value")
    }
}

// myfunc_test.go
package myfunc_test

import (
    "testing"
    . "path/to/myfunc" // 点导入
)

func TestExportedFuncWithDotImport(t *testing.T) {
    expected := "Hello from ExportedFunc"
    if result := ExportedFunc(); result != expected { // 直接调用，无需 myfunc.
        t.Errorf("ExportedFunc() = %s; want %s", result, expected)
    }
}