Go语言中文件I/O操作的模拟与测试策略（以os.ReadFile为例）

package main

import (
    "os"
)

// ObtainTranslationStrings 模拟对文件内容的进一步处理
func ObtainTranslationStrings(data string) ([]string, error) {
    // 实际业务逻辑可能更复杂，这里简化为返回一个包含处理后字符串的切片
    return []string{"processed_" + data}, nil
}

// ReadAndProcessFile 负责读取文件并调用处理函数
func ReadAndProcessFile(path string) ([]string, error) {
    contents, err := os.ReadFile(path) // 直接调用 os.ReadFile
    if err != nil {
        return nil, err
    }
    return ObtainTranslationStrings(string(contents))
}

package main

import (
    "io"
    "io/ioutil" // 在 Go 1.16+ 中，推荐使用 io.ReadAll(r) 替代 ioutil.ReadAll(r)
    "bytes"
)

// ObtainTranslationStrings 模拟对文件内容的进一步处理
func ObtainTranslationStrings(data string) ([]string, error) {
    return []string{"processed_" + data}, nil
}

// ReadAndProcessFileWithReader 接受一个 io.Reader 接口
func ReadAndProcessFileWithReader(r io.Reader) ([]string, error) {
    // 使用 ioutil.ReadAll 从 io.Reader 中读取所有内容
    // 在 Go 1.16+ 中，推荐使用 io.ReadAll(r)
    contents, err := ioutil.ReadAll(r) // 兼容旧代码，但推荐 io.ReadAll
    if err != nil {
        return nil, err
    }
    return ObtainTranslationStrings(string(contents))
}

package main

import (
    "bytes"
    "fmt"
    "strings"
    "testing"
)

// 假设 ObtainTranslationStrings 和 ReadAndProcessFileWithReader 函数已定义

func TestReadAndProcessFileWithReader(t *testing.T) {
    // 模拟文件内容
    mockContent := "Hello, Mock!"
    mockReader := bytes.NewBufferString(mockContent) // 使用 bytes.Buffer 模拟 io.Reader

    result, err := ReadAndProcessFileWithReader(mockReader)
    if err != nil {
        t.Fatalf("Expected no error, got %v", err)
    }

    expected := []string{"processed_Hello, Mock!"}
    if fmt.Sprint(result) != fmt.Sprint(expected) {
        t.Errorf("Expected %v, got %v", expected, result)
    }

    // 模拟空文件
    emptyReader := strings.NewReader("")
    resultEmpty, errEmpty := ReadAndProcessFileWithReader(emptyReader)
    if errEmpty != nil {
        t.Fatalf("Expected no error for empty reader, got %v", errEmpty)
    }
    expectedEmpty := []string{"processed_"}
    if fmt.Sprint(resultEmpty) != fmt.Sprint(expectedEmpty) {
        t.Errorf("Expected %v, got %v", expectedEmpty, resultEmpty)
    }
}

package main

import (
    "os"
)

// fileReader 是一个包级别的函数变量，用于替代 os.ReadFile
// 默认指向 os.ReadFile
var fileReader = os.ReadFile

// ObtainTranslationStrings 模拟对文件内容的进一步处理
func ObtainTranslationStrings(data string) ([]string, error) {
    return []string{"processed_" + data}, nil
}

// ReadAndProcessFileWithMockableFunc 使用包级别的 fileReader
func ReadAndProcessFileWithMockableFunc(path string) ([]string, error) {
    contents, err := fileReader(path) // 调用包级别变量
    if err != nil {
        return nil, err
    }
    return ObtainTranslationStrings(string(contents))
}

package main

import (
    "errors"
    "fmt"
    "os"
    "testing"
)

// 假设 ObtainTranslationStrings 和 ReadAndProcessFileWithMockableFunc 已定义
// 并且 fileReader 变量已在 main 包中声明

func TestReadAndProcessFileWithMockableFunc(t *testing.T) {
    // 保存原始的 fileReader，以便测试后恢复
    originalFileReader := fileReader
    defer func() { fileReader = originalFileReader }() // 确保测试结束后恢复

    // 1. 模拟成功读取
    mockContent := "Mocked Data"
    fileReader = func(filename string) ([]byte, error) {
        if filename == "/path/to/mock.txt" {
            return []byte(mockContent), nil
        }
        return nil, errors.New("unexpected file read")
    }

    result, err := ReadAndProcessFileWithMockableFunc("/path/to/mock.txt")
    if err != nil {
        t.Fatalf("Expected no error, got %v", err)
    }
    expected := []