Golang标准库——testing

testing

testing 提供对 Go 包的自动化测试的支持。通过 go test 命令，能够自动执行如下形式的任何函数：

func TestXxx(*testing.T)

其中 Xxx 可以是任何字母数字字符串（但第一个字母不能是 [a-z]），用于识别测试例程。

在这些函数中，使用 Error, Fail 或相关方法来发出失败信号。

要编写一个新的测试套件，需要创建一个名称以 _test.go 结尾的文件，该文件包含 TestXxx 函数，如上所述。 将该文件放在与被测试的包相同的包中。该文件将被排除在正常的程序包之外，但在运行 “go test” 命令时将被包含。 有关详细信息，请运行 “go help test” 和 “go help testflag” 了解。

如果有需要，可以调用 *T 和 *B 的 Skip 方法，跳过该测试或基准测试：

func TestTimeConsuming(t *testing.T) {
    if testing.Short() {
        t.Skip("skipping test in short mode.")
    }
    ...
}

Benchmarks

如下形式的函数：

func BenchmarkXxx(*testing.B)

被认为是基准测试，通过 "go test" 命令，加上 -bench flag 来执行。多个基准测试按照顺序运行。

testing flags 的详细描述, 参见 https://github.com/golang/go/blob/master/cmd/go/#hdr-Description_of_testing_flags.

基准测试函数样例看起来如下所示：

func BenchmarkHello(b *testing.B) {
    for i := 0; i < b.N; i++ {
        fmt.Sprintf("hello")
    }
}

基准函数会运行目标代码 b.N 次。在基准执行期间，会调整 b.N 直到基准测试函数持续足够长的时间。输出

BenchmarkHello    10000000    282 ns/op

意味着循环执行了 10000000 次，每次循环花费 282 纳秒(ns)。

如果在运行前基准测试需要一些耗时的配置，则可以先重置定时器：

func BenchmarkBigLen(b *testing.B) {
    big := NewBig()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        big.Len()
    }
}

如果基准测试需要在并行设置中测试性能，则可以使用 RunParallel 辅助函数; 这样的基准测试一般与 go test -cpu 标志一起使用：

func BenchmarkTemplateParallel(b *testing.B) {
    templ := template.Must(template.New("test").Parse("Hello, {{.}}!"))
    b.RunParallel(func(pb *testing.PB) {
        var buf bytes.Buffer
        for pb.Next() {
            buf.Reset()
            templ.Execute(&buf, "World")
        }
    })
}

Examples

该包还运行并验证示例代码。示例函数可以包括以 "Output：" 开头的行注释，并在运行测试时与函数的标准输出进行比较。 （比较时会忽略前导和尾随空格。）这些是一个 example 的例子：

func ExampleHello() {
        fmt.Println("hello")
        // Output: hello
}

func ExampleSalutations() {
        fmt.Println("hello, and")
        fmt.Println("goodbye")
        // Output:
        // hello, and
        // goodbye
}

"Unordered output:" 形式的注释，和 "Output:" 类似，但是能够以任意顺序匹配行：

func ExamplePerm() {
    for _, value := range Perm(4) {
        fmt.Println(value)
    }
    // Unordered output: 4
    // 2
    // 1
    // 3
    // 0
}

没有输出注释的示例函数被编译但不执行。

example 声明的命名约定：包，函数 F，类型 T，类型 T 上的方法 M 依次是：

func Example() { ... }
func ExampleF() { ... }
func ExampleT() { ... }
func ExampleT_M() { ... }

可以为 包/类型/函数/方法 提供多个 example 函数，这通过在名称上附加一个不同的后缀来实现。后缀必须是以小写字母开头。

func Example_suffix() { ... }
func ExampleF_suffix() { ... }
func ExampleT_suffix() { ... }
func ExampleT_M_suffix() { ... }

当一个文件包含一个示例函数，同时至少一个其他函数，类型，变量或常量声明，或没有测试或基准函数时，这个测试文件作为示例存在，通常命名为 example_test.go

Subtests 和 Sub-benchmarks

T 和 B 的 Run 方法允许定义子单元测试和子基准测试，而不必为每个子测试和子基准定义单独的函数。这使得可以使用 Table-Driven 的基准测试和创建层级测试。它还提供了一种共享通用 setup 和 tear-down 代码的方法：

func TestFoo(t *testing.T) {
    // <setup code>
    t.Run("A=1", func(t *testing.T) { ... })
    t.Run("A=2", func(t *testing.T) { ... })
    t.Run("B=1", func(t *testing.T) { ... })
    // <tear-down code>
}

每个子测试和子基准测试都有一个唯一的名称：顶级测试的名称和传递给 Run 的名称的组合，以斜杠分隔，并具有用于消歧的可选尾随序列号。

-run 和 -bench 命令行标志的参数是与测试名称相匹配的非固定的正则表达式。对于具有多个斜杠分隔元素（例如子测试）的测试，该参数本身是斜杠分隔的，其中表达式依次匹配每个名称元素。因为它是非固定的，一个空的表达式匹配任何字符串。例如，使用 "匹配" 表示 "其名称包含"：

go test -run ''      # Run 所有测试。
go test -run Foo     # Run 匹配 "Foo" 的顶层测试，例如 "TestFooBar"。
go test -run Foo/A=  # 匹配顶层测试 "Foo"，运行其匹配 "A=" 的子测试。
go test -run /A=1    # 运行所有匹配 "A=1" 的子测试。

子测试也可用于控制并行性。所有的子测试完成后，父测试才会完成。在这个例子中，所有的测试是相互并行运行的，当然也只是彼此之间，不包括定义在其他顶层测试的子测试：

func TestGroupedParallel(t *testing.T) {
    for _, tc := range tests {
        tc := tc // capture range variable
        t.Run(tc.Name, func(t *testing.T) {
            t.Parallel()
            ...
        })
    }
}

在并行子测试完成之前，Run 方法不会返回，这提供了一种测试后清理的方法：

func TestTeardownParallel(t *testing.T) {
    // This Run will not return until the parallel tests finish.
    t.Run("group", func(t *testing.T) {
        t.Run("Test1", parallelTest1)
        t.Run("Test2", parallelTest2)
        t.Run("Test3", parallelTest3)
    })
    // <tear-down code>
}

Main

测试程序有时需要在测试之前或之后进行额外的设置（setup）或拆卸（teardown）。有时, 测试还需要控制在主线程上运行的代码。为了支持这些和其他一些情况, 如果测试文件包含函数:

func TestMain(m *testing.M)

那么生成的测试将调用 TestMain(m)，而不是直接运行测试。TestMain 运行在主 goroutine 中, 可以在调用 m.Run 前后做任何设置和拆卸。应该使用 m.Run 的返回值作为参数调用 os.Exit。在调用 TestMain 时, flag.Parse 并没有被调用。所以，如果 TestMain 依赖于 command-line 标志 (包括 testing 包的标记), 则应该显示的调用 flag.Parse。

一个简单的 TestMain 的实现：

func TestMain(m *testing.M) {
    // call flag.Parse() here if TestMain uses flags
    // 如果 TestMain 使用了 flags，这里应该加上 flag.Parse()
    os.Exit(m.Run())
}

func AllocsPerRun

func AllocsPerRun(runs int, f func()) (avg float64)

AllocsPerRun 返回在调用 f 期间内存平均分配次数。虽然返回值的类型为 float64，但它始终是一个整数值。

要计算分配次数，该函数将首先作为热身运行一次。然后将测量并返回指定数量（runs 参数）运行的内存平均分配次数。

AllocsPerRun 在测量过程中将 GOMAXPROCS 设置为1，并在返回前将其还原。

func CoverMode

func CoverMode() string

CoverMode报告测试覆盖率模式设置为什么。 值是“设置”，“计数”或“原子”。 如果未启用测试覆盖率，则返回值将为空。

func Coverage

func Coverage() float64

Coverage报告当前代码的覆盖率，范围为[0，1]。 如果未启用coverage，则Coverage返回0。

当运行大量顺序测试用例时，在每个测试用例之后检查Coverage对确定哪些测试用例执行新代码路径很有用。 它不能替代“ go test -cover”和“ go tool cover”生成的报告。

func Main

func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample)

Main是一个内部函数，是执行“ go test”命令的一部分。 它已导出是因为它是交叉打包的，并且早于“内部”打包。 它不再由“执行测试”使用，而是尽可能多地保留给使用Main模拟“执行测试”的其他系统，但由于无法向测试包中添加新功能，因此有时无法更新Main。 模拟“执行测试”的系统应更新为使用MainStart。

func RegisterCover

func RegisterCover(c Cover)

RegisterCover记录测试的覆盖率数据累加器。 注意：此功能是测试基础结构的内部功能，可能会更改。 Go 1兼容性准则尚未涵盖它。

func RunBenchmarks

func RunBenchmarks(matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark)

内部函数，但由于是交叉包装而导出； 执行“执行测试”命令的一部分。

func RunExamples

func RunExamples(matchString func(pat, str string) (bool, error), examples []InternalExample) (ok bool)

内部函数，但由于是交叉包装而导出； 执行“执行测试”命令的一部分。

func RunTests

func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool)

内部函数，但由于是交叉包装而导出； 执行“执行测试”命令的一部分。

func Short

func Short() bool

简短信息报告是否设置了-test.short标志。

func Verbose

func Verbose() bool

详细报告是否设置了-test.v标志。

type B

type B struct {
    N int
    // contains filtered or unexported fields
}

B 是传递给基准测试函数的一种类型，它用于管理基准测试的计时行为，并指示应该迭代地运行测试多少次。

一个基准测试在它的基准测试函数返回时，又或者在它的基准测试函数调用 FailNow、Fatal、Fatalf、SkipNow、Skip 或者 Skipf 中的任意一个方法时，测试即宣告结束。至于其他报告方法，比如 Log 和 Error 的变种，则可以在其他 goroutine 中同时进行调用。

跟单元测试一样，基准测试会在执行的过程中积累日志，并在测试完毕时将日志转储到标准错误。但跟单元测试不一样的是，为了避免基准测试的结果受到日志打印操作的影响，基准测试总是会把日志打印出来。

func (*B) Error

func (c *B) Error(args ...interface{})

调用 Error 相当于在调用 Log 之后调用 Fail 。

func (*B) Errorf

func (c *B) Errorf(format string, args ...interface{})

调用 Errorf 相当于在调用 Logf 之后调用 Fail 。

func (*B) Fail

func (c *B) Fail()

将当前的测试函数标识为“失败”，但仍然继续执行该函数。

func (*B) FailNow

func (c *B) FailNow()

将当前的测试函数标识为“失败”，并停止执行该函数。在此之后，测试过程将在下一个测试或者下一个基准测试中继续。 FailNow 必须在运行测试函数或者基准测试函数的 goroutine 中调用，而不能在测试期间创建的 goroutine 中调用。调用 FailNow 不会导致其他 goroutine 停止。

func (*B) Failed

func (c *B) Failed() bool

Failed 用于报告测试函数是否已失败。

func (*B) Fatal

func (c *B) Fatal(args ...interface{})

调用 Fatal 相当于在调用 Log 之后调用 FailNow 。

func (*B) Fatalf

func (c *B) Fatalf(format string, args ...interface{})

调用 Fatalf 相当于在调用 Logf 之后调用 FailNow 。

func (*B) Log

func (c *B) Log(args ...interface{})

Log 使用与 Println 相同的格式化语法对它的参数进行格式化， 然后将格式化后的文本记录到错误日志里面：

对于测试来说， 格式化文本只会在测试失败或者设置了 -test.v 标志的情况下被打印出来； 对于基准测试来说， 为了避免 -test.v 标志的值对测试的性能产生影响， 格式化文本总会被打印出来。

func (*B) Logf

func (c *B) Logf(format string, args ...interface{})

Log 使用与 Printf 相同的格式化语法对它的参数进行格式化， 然后将格式化后的文本记录到错误日志里面。 如果输入的格式化文本最末尾没有出现新行， 那么将一个新行添加到格式化后的文本末尾。

对于测试来说，Logf 产生的格式化文本只会在测试失败或者设置了 -test.v 标志的情况下被打印出来； 对于基准测试来说， 为了避免 -test.v 标志的值对测试的性能产生影响， Logf 产生的格式化文本总会被打印出来。

func (*B) Name

func (c *B) Name() string

返回正在运行的测试或者基准测试的名字。

func (*B) ReportAllocs

func (b *B) ReportAllocs()

打开当前基准测试的内存统计功能，与使用 -test.benchmem 设置类似，但 ReportAllocs 只影响那些调用了该函数的基准测试。

func (*B) ResetTimer

func (b *B) ResetTimer()

对已经逝去的基准测试时间以及内存分配计数器进行清零。对于正在运行中的计时器，这个方法不会产生任何效果。

func (*B) Run

func (b *B) Run(name string, f func(b *B)) bool

执行名字为 name 的子基准测试（subbenchmark）f ，并报告 f 在执行过程中是否出现了任何失败。

子基准测试跟其他普通的基准测试一样。一个调用了 Run 方法至少一次的基准测试将不会对其自身进行测量（measure），并且在 N 为 1 时， 这个基准测试将只会被执行一次。

Run 可以同时在多个 goroutine 中被调用，但这些调用必须发生在 b 的外部基准函数（outer benchmark function）返回之前。

func (*B) RunParallel

func (b *B) RunParallel(body func(*PB))

以并行的方式执行给定的基准测试。 RunParallel 会创建出多个 goroutine ，并将 b.N 分配给这些 goroutine 执行， 其中 goroutine 数量的默认值为 GOMAXPROCS 。用户如果想要增加非CPU受限（non-CPU-bound）基准测试的并行性， 那么可以在 RunParallel 之前调用 SetParallelism 。RunParallel 通常会与 -cpu 标志一同使用。

body 函数将在每个 goroutine 中执行，这个函数需要设置所有 goroutine 本地的状态， 并迭代直到 pb.Next 返回 false 值为止。因为 StartTimer 、 StopTimer 和 ResetTimer 这三个函数都带有全局作用，所以 body 函数不应该调用这些函数；除此之外，body 函数也不应该调用 Run 函数。

func (*B) SetBytes

func (b *B) SetBytes(n int64)

记录在单个操作中处理的字节数量。在调用了这个方法之后，基准测试将会报告 ns/op 以及 MB/s 。

func (*B) SetParallelism

func (b *B) SetParallelism(p int)

将 RunParallel 使用的 goroutine 数量设置为 p*GOMAXPROCS ，如果 p 小于 1 ，那么调用将不产生任何效果。

CPU受限（CPU-bound）的基准测试通常不需要调用这个方法。

func (*B) Skip

func (c *B) Skip(args ...interface{})

调用 Skip 相当于在调用 Log 之后调用 SkipNow 。

func (*B) SkipNow

func (c *B) SkipNow()

将当前测试标识为“被跳过”并停止执行该测试。 如果一个测试在失败（参考 Error 、 Errorf 和 Fail）之后被跳过了， 那么它还是会被判断为是“失败的”。

在停止当前测试之后， 测试过程将在下一个测试或者下一个基准测试中继续， 具体请参考 FailNow 。

SkipNow 必须在运行测试的 goroutine 中进行调用， 而不能在测试期间创建的 goroutine 中调用。 调用 SkipNow 不会导致其他 goroutine 停止。

func (*B) Skipf

func (c *B) Skipf(format string, args ...interface{})

调用 Skipf 相当于在调用 Logf 之后调用 SkipNow 。

func (*B) Skipped

func (c *B) Skipped() bool

报告测试是否已被跳过。

func (*B) StartTimer

func (b *B) StartTimer()

开始对测试进行计时。 这个函数在基准测试开始时会自动被调用， 它也可以在调用 StopTimer 之后恢复进行计时。

func (*B) StopTimer

func (b *B) StopTimer()

停止对测试进行计时。 当你需要执行一些复杂的初始化操作， 并且你不想对这些操作进行测量时， 就可以使用这个方法来暂时地停止计时。

type BenchmarkResult

type BenchmarkResult struct {
    N         int           // The number of iterations.
    T         time.Duration // The total time taken.
    Bytes     int64         // Bytes processed in one iteration.
    MemAllocs uint64        // The total number of memory allocations.
    MemBytes  uint64        // The total number of bytes allocated.
}

基准测试运行的结果。

func Benchmark

func Benchmark(f func(b *B)) BenchmarkResult

测试单个函数。用于创建不使用 "go test" 命令的自定义基准测试。

如果 f 调用 Run，则结果将是运行其所有子基准的结果估计，该子基准在单个基准测试中不会顺序调用 Run。

func (BenchmarkResult) AllocedBytesPerOp

func (r BenchmarkResult) AllocedBytesPerOp() int64

func (BenchmarkResult) AllocsPerOp

func (r BenchmarkResult) AllocsPerOp() int64

func (BenchmarkResult) MemString

func (r BenchmarkResult) MemString() string

func (BenchmarkResult) NsPerOp

func (r BenchmarkResult) NsPerOp() int64

func (BenchmarkResult) String

func (r BenchmarkResult) String() string

type Cover

type Cover struct {
    Mode            string
    Counters        map[string][]uint32
    Blocks          map[string][]CoverBlock
    CoveredPackages string
}

Cover记录有关测试覆盖率检查的信息。 注意：此结构在测试基础结构内部，并且可能会更改。 Go 1兼容性准则尚未涵盖它。

type CoverBlock

type CoverBlock struct {
    Line0 uint32
    Col0  uint16
    Line1 uint32
    Col1  uint16
    Stmts uint16
}

CoverBlock记录单个基本块的coverage数据。 注意：此结构在测试基础结构内部，并且可能会更改。 Go 1兼容性准则尚未涵盖它。

type InternalBenchmark

type InternalBenchmark struct {
    Name string
    F    func(b *B)
}

内部类型，但由于是交叉包装而被导出； 执行“执行测试”命令的一部分。

type InternalExample

type InternalExample struct {
    Name      string
    F         func()
    Output    string
    Unordered bool
}

type InternalTest

type InternalTest struct {
    Name string
    F    func(*T)
}

内部类型，但由于是交叉包装而被导出； 执行“执行测试”命令的一部分。

type M

type M struct {
    // contains filtered or unexported fields
}

M 是传递给 TestMain 函数以运行实际测试的类型。

func MainStart

func MainStart(deps testDeps, tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample) *M

MainStart是供“ go test”生成的测试使用的。 它并不意味着可以直接调用，也不受Go 1兼容性文档的约束。 它可能会在发布之间更改签名。

func (*M) Run

func (m *M) Run() int

Run 运行这些测试。它返回要传递给 os.Exit 的退出代码。

type PB

type PB struct {
    // contains filtered or unexported fields
}

PB 被 RunParallel 使用来运行并行基准测试。

func (*PB) Next

func (pb *PB) Next() bool

Next 判断是否有更多的迭代要执行

type T

type T struct {
    // contains filtered or unexported fields
}

T 是传递给测试函数的一种类型，它用于管理测试状态并支持格式化测试日志。测试日志会在执行测试的过程中不断累积， 并在测试完成时转储至标准输出。

当一个测试的测试函数返回时， 又或者当一个测试函数调用 FailNow 、 Fatal 、 Fatalf 、 SkipNow 、 Skip 或者 Skipf 中的任意一个时， 该测试即宣告结束。 跟 Parallel 方法一样， 以上提到的这些方法只能在运行测试函数的 goroutine 中调用。

至于其他报告方法， 比如 Log 以及 Error 的变种， 则可以在多个 goroutine 中同时进行调用。

func (*T) Error

func (c *T) Error(args ...interface{})

调用 Error 相当于在调用 Log 之后调用 Fail 。

func (*T) Errorf

func (c *T) Errorf(format string, args ...interface{})

调用 Errorf 相当于在调用 Logf 之后调用 Fail 。

func (*T) Fail

func (c *T) Fail()

将当前测试标识为失败，但是仍继续执行该测试。

func (*T) FailNow

func (c *T) FailNow()

将当前测试标识为失败并停止执行该测试，在此之后，测试过程将在下一个测试或者下一个基准测试中继续。

FailNow 必须在运行测试函数或者基准测试函数的 goroutine 中调用，而不能在测试期间创建的 goroutine 中调用。调用 FailNow 不会导致其他 goroutine 停止。

func (*T) Failed

func (c *T) Failed() bool

Failed 用于报告测试函数是否已失败。

func (*T) Fatal

func (c *T) Fatal(args ...interface{})

调用 Fatal 相当于在调用 Log 之后调用 FailNow 。

func (*T) Fatalf

func (c *T) Fatalf(format string, args ...interface{})

调用 Fatalf 相当于在调用 Logf 之后调用 FailNow 。

func (*T) Log

func (c *T) Log(args ...interface{})

Log 使用与 Println 相同的格式化语法对它的参数进行格式化，然后将格式化后的文本记录到错误日志里面：

1）对于测试来说，格式化文本只会在测试失败或者设置了 -test.v 标志的情况下被打印出来； 2）对于基准测试来说，为了避免 -test.v 标志的值对测试的性能产生影响， 格式化文本总会被打印出来。

func (*T) Logf

func (c *T) Logf(format string, args ...interface{})

Log 使用与 Printf 相同的格式化语法对它的参数进行格式化，然后将格式化后的文本记录到错误日志里面。 如果输入的格式化文本最末尾没有出现新行，那么将一个新行添加到格式化后的文本末尾。

1）对于测试来说，Logf 产生的格式化文本只会在测试失败或者设置了 -test.v 标志的情况下被打印出来； 2）对于基准测试来说，为了避免 -test.v 标志的值对测试的性能产生影响，Logf 产生的格式化文本总会被打印出来。

func (*T) Name

func (c *T) Name() string

返回正在运行的测试或基准测试的名字。

func (*T) Parallel

func (t *T) Parallel()

Parallel 用于表示当前测试只会与其他带有 Parallel 方法的测试并行进行测试。

func (*T) Run

func (t *T) Run(name string, f func(t *T)) bool

执行名字为 name 的子测试 f ，并报告 f 在执行过程中是否出现了任何失败。Run 将一直阻塞直到 f 的所有并行测试执行完毕。

Run 可以在多个 goroutine 里面同时进行调用，但这些调用必须发生在 t 的外层测试函数（outer test function）返回之前。

func (*T) Skip

func (c *T) Skip(args ...interface{})

调用 Skip 相当于在调用 Log 之后调用 SkipNow 。

func (*T) SkipNow

func (c *T) SkipNow()

将当前测试标识为“被跳过”并停止执行该测试。 如果一个测试在失败（参考 Error、Errorf 和 Fail）之后被跳过了， 那么它还是会被判断为是“失败的”。

在停止当前测试之后，测试过程将在下一个测试或者下一个基准测试中继续，具体请参考 FailNow 。

SkipNow 必须在运行测试的 goroutine 中进行调用，而不能在测试期间创建的 goroutine 中调用。 调用 SkipNow 不会导致其他 goroutine 停止。

func (*T) Skipf

func (c *T) Skipf(format string, args ...interface{})

调用 Skipf 相当于在调用 Logf 之后调用 SkipNow 。

func (*T) Skipped

func (c *T) Skipped() bool

Skipped 用于报告测试函数是否已被跳过。

type TB

type TB interface {
    Error(args ...interface{})
    Errorf(format string, args ...interface{})
    Fail()
    FailNow()
    Failed() bool
    Fatal(args ...interface{})
    Fatalf(format string, args ...interface{})
    Log(args ...interface{})
    Logf(format string, args ...interface{})
    Name() string
    Skip(args ...interface{})
    SkipNow()
    Skipf(format string, args ...interface{})
    Skipped() bool
    // contains filtered or unexported methods
}

TB 是一个接口，类型 T 和 B 实现了该接口。

Directories

Path	Synopsis
iotest	iotest包实现了主要用于Reader和Writer的测试。
quick	quick包实现实用程序功能以帮助进行黑盒测试。

• iotest
• quick

iotest

iotest包实现了主要用于Reader和Writer的测试。

Variables

var ErrTimeout = errors.New("timeout")

func DataErrReader

func DataErrReader(r io.Reader) io.Reader

DataErrReader更改阅读器处理错误的方式。 通常，在读取最后一条数据后，读取器会从第一个Read调用返回错误（通常为EOF）。 DataErrReader包装一个Reader并更改其行为，以便最终错误与最终数据一起返回，而不是在最终数据之后的第一次调用中返回。

func HalfReader

func HalfReader(r io.Reader) io.Reader

HalfReader返回一个Reader，该Reader通过从r读取一半的请求字节来实现Read。

func NewReadLogger

func NewReadLogger(prefix string, r io.Reader) io.Reader

NewReadLogger返回一个行为类似于r的阅读器，只是它会将每次读取记录（使用log.Print）记录为标准错误，并打印读取的前缀和十六进制数据。

func NewWriteLogger

func NewWriteLogger(prefix string, w io.Writer) io.Writer

NewWriteLogger返回一个行为类似w的书写器，除了它记录（使用log.Printf）每次写入标准错误时，都会打印出写入的前缀和十六进制数据。

func OneByteReader

func OneByteReader(r io.Reader) io.Reader

OneByteReader返回一个Reader，该Reader通过从r读取一个字节来实现每个非空的Read。

func TimeoutReader

func TimeoutReader(r io.Reader) io.Reader

TimeoutReader在第二次读取时返回ErrTimeout，但没有数据。 随后的读取调用成功。

func TruncateWriter

func TruncateWriter(w io.Writer, n int64) io.Writer

TruncateWriter返回一个Writer，该Writer写入w，但在n个字节后静默停止。

quick

quick包实现实用程序功能以帮助进行黑盒测试。

测试/快速软件包已冻结，并且不接受新功能。

func Check

func Check(f interface{}, config *Config) error

Check查找f的输入，f是返回布尔值的任何函数，例如f返回false。 它反复调用f，每个参数具有任意值。 如果f在给定输入上返回false，则Check以* CheckError形式返回该输入。 例如：

func TestOddMultipleOfThree(t *testing.T) {
    f := func(x int) bool {
        y := OddMultipleOfThree(x)
        return y%2 == 1 && y%3 == 0
    }
    if err := quick.Check(f, nil); err != nil {
        t.Error(err)
    }
}

func CheckEqual

func CheckEqual(f, g interface{}, config *Config) error

CheckEqual查找f和g返回不同结果的输入。 它会重复调用f和g，并为每个参数使用任意值。 如果f和g返回不同的答案，则CheckEqual返回描述输入和输出的* CheckEqualError。

func Value

func Value(t reflect.Type, rand *rand.Rand) (value reflect.Value, ok bool)

值返回给定类型的任意值。 如果该类型实现了Generator接口，则将使用该接口。 注意：要为结构创建任意值，必须导出所有字段。

type CheckEqualError

type CheckEqualError struct {
    CheckError
    Out1 []interface{}
    Out2 []interface{}
}

CheckEqualError是CheckEqual发现错误的结果。

func (*CheckEqualError) Error

func (s *CheckEqualError) Error() string

type CheckError

type CheckError struct {
    Count int
    In    []interface{}
}

CheckError是Check发现错误的结果。

func (*CheckError) Error

func (s *CheckError) Error() string

type Config

type Config struct {
    // MaxCount sets the maximum number of iterations. If zero,
    // MaxCountScale is used.
    MaxCount int
    // MaxCountScale is a non-negative scale factor applied to the default
    // maximum. If zero, the default is unchanged.
    MaxCountScale float64
    // If non-nil, rand is a source of random numbers. Otherwise a default
    // pseudo-random source will be used.
    Rand *rand.Rand
    // If non-nil, the Values function generates a slice of arbitrary
    // reflect.Values that are congruent with the arguments to the function
    // being tested. Otherwise, the top-level Value function is used
    // to generate them.
    Values func([]reflect.Value, *rand.Rand)
}

Config结构包含用于运行测试的选项。

type Generator

type Generator interface {
    // Generate returns a random instance of the type on which it is a
    // method using the size as a size hint.
    Generate(rand *rand.Rand, size int) reflect.Value
}

生成器可以生成自己类型的随机值。

type SetupError]

type SetupError string

SetupError是使用检查方式时发生错误的结果，与所测试的功能无关。

func (SetupError) Error

func (s SetupError) Error() string