Package testing

Overview ▾

软件包测试为Go软件包的自动化测试提供支持. 它旨在与" go test"命令配合使用,该命令可自动执行表格中的任何功能

func TestXxx(*testing.T)

其中Xxx不以小写字母开头. 函数名称用于标识测试例程.

在这些功能中,使用错误,失败或相关方法来指示失败.

要编写新的测试套件,请创建一个名称以_test.go结尾的文件,其中包含TestXxx函数,如此处所述. 将文件与要测试的文件放在同一软件包中. 该文件将从常规软件包生成中排除,但在运行" go test"命令时将包括在内. 有关更多详细信息,请运行" go help test"和" go help testflag".

一个简单的测试函数如下所示:

func TestAbs(t *testing.T) {
    got := Abs(-1)
    if got != 1 {
        t.Errorf("Abs(-1) = %d; want 1", got)
    }
}

Benchmarks

表格功能

func BenchmarkXxx(*testing.B)

被视为基准,并在提供-bench标志时由"执行测试"命令执行. 基准按顺序运行.

有关测试标志的说明,请参见https://golang.org/cmd/go/#hdr-Testing_flags

基准测试函数示例如下所示:

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

基准功能必须运行目标代码bN次. 在基准执行期间,将调整bN直到基准功能持续足够长的时间以可靠地计时. 输出

BenchmarkHello    10000000    282 ns/op

表示该循环以282 ns的速度运行了10000000次.

如果基准测试需要在运行前进行一些昂贵的设置,则可以重置计时器:

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:"开头的结尾行注释,并在运行测试时与函数的标准输出进行比较. (比较将忽略前导和尾随空格.)这些是示例的示例:

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

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

注释前缀"无序输出:"类似于"输出:",但匹配任何行顺序:

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

没有输出注释的示例函数已编译但未执行.

声明包示例的命名约定,函数F,类型T和类型T上的方法M是:

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

可以通过在名称后附加一个不同的后缀来提供包/类型/功能/方法的多个示例功能. 后缀必须以小写字母开头.

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

当整个测试文件包含单个示例函数,至少一个其他函数,类型,变量或常量声明,并且不包含测试或基准测试函数时,将以示例形式显示.

Skipping

通过调用* T或* B的Skip方法,可以在运行时跳过测试或基准测试:

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

Subtests and Sub-benchmarks

T和B的Run方法允许定义子测试和子基准,而不必为每个子函数定义单独的功能. 这可以实现诸如表驱动基准测试和创建分层测试之类的用途. 它还提供了一种共享通用设置和拆卸代码的方法:

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命令行标志的参数是与测试名称匹配的未锚定正则表达式. 对于带有多个以斜杠分隔的元素的测试(例如子测试),参数本身是以斜杠分隔的,表达式依次匹配每个name元素. 因为未锚定,所以空表达式匹配任何字符串. 例如,使用"匹配"来表示"其名称包含":

go test -run ''      # Run all tests.
go test -run Foo     # Run top-level tests matching "Foo", such as "TestFooBar".
go test -run Foo/A=  # For top-level tests matching "Foo", run subtests matching "A=".
go test -run /A=1    # For all top-level tests, run subtests matching "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()
            ...
        })
    }
}

如果种族检测器超过了8192个并发goroutine,则它们将杀死该程序,因此在设置了-race标志的并行测试中运行时,请务必小心.

Run does not return until parallel subtests have completed, providing a way to clean up after a group of parallel tests:

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

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

func TestMain(m *testing.M)

那么生成的测试将调用TestMain(m)而不是直接运行测试. TestMain在主goroutine中运行,并且可以在调用m.Run周围进行任何必要的设置和拆卸. 然后,应使用m.Run的结果调用os.Exit. 调用TestMain时,flag.Parse尚未运行. 如果TestMain依赖命令行标志(包括测试包的标志),则应显式调用flag.Parse.

TestMain的简单实现是:

func TestMain(m *testing.M) {
	// call flag.Parse() here if TestMain uses flags
	os.Exit(m.Run())
}

Index ▾

func AllocsPerRun(runs int, f func()) (avg float64)
func CoverMode() string
func Coverage() float64
func Init()
func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample)
func RegisterCover(c Cover)
func RunBenchmarks(matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark)
func RunExamples(matchString func(pat, str string) (bool, error), examples []InternalExample) (ok bool)
func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool)
func Short() bool
func Verbose() bool
type B
    func (c *B) Error(args ...interface{})
    func (c *B) Errorf(format string, args ...interface{})
    func (c *B) Fail()
    func (c *B) FailNow()
    func (c *B) Failed() bool
    func (c *B) Fatal(args ...interface{})
    func (c *B) Fatalf(format string, args ...interface{})
    func (c *B) Helper()
    func (c *B) Log(args ...interface{})
    func (c *B) Logf(format string, args ...interface{})
    func (c *B) Name() string
    func (b *B) ReportAllocs()
    func (b *B) ReportMetric(n float64, unit string)
    func (b *B) ResetTimer()
    func (b *B) Run(name string, f func(b *B)) bool
    func (b *B) RunParallel(body func(*PB))
    func (b *B) SetBytes(n int64)
    func (b *B) SetParallelism(p int)
    func (c *B) Skip(args ...interface{})
    func (c *B) SkipNow()
    func (c *B) Skipf(format string, args ...interface{})
    func (c *B) Skipped() bool
    func (b *B) StartTimer()
    func (b *B) StopTimer()
type BenchmarkResult
    func Benchmark(f func(b *B)) BenchmarkResult
    func (r BenchmarkResult) AllocedBytesPerOp() int64
    func (r BenchmarkResult) AllocsPerOp() int64
    func (r BenchmarkResult) MemString() string
    func (r BenchmarkResult) NsPerOp() int64
    func (r BenchmarkResult) String() string
type Cover
type CoverBlock
type InternalBenchmark
type InternalExample
type InternalTest
type M
    func MainStart(deps testDeps, tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample) *M
    func (m *M) Run() int
type PB
    func (pb *PB) Next() bool
type T
    func (c *T) Error(args ...interface{})
    func (c *T) Errorf(format string, args ...interface{})
    func (c *T) Fail()
    func (c *T) FailNow()
    func (c *T) Failed() bool
    func (c *T) Fatal(args ...interface{})
    func (c *T) Fatalf(format string, args ...interface{})
    func (c *T) Helper()
    func (c *T) Log(args ...interface{})
    func (c *T) Logf(format string, args ...interface{})
    func (c *T) Name() string
    func (t *T) Parallel()
    func (t *T) Run(name string, f func(t *T)) bool
    func (c *T) Skip(args ...interface{})
    func (c *T) SkipNow()
    func (c *T) Skipf(format string, args ...interface{})
    func (c *T) Skipped() bool
type TB

Examples

B.ReportMetric
B.RunParallel

Package files

allocs.go benchmark.go cover.go example.go match.go run_example.go testing.go

func AllocsPerRun 1.1

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

AllocsPerRun返回调用f期间的平均分配数. 尽管返回值的类型为float64,但它将始终是整数值.

要计算分配数量,该函数将作为预热运行一次. 然后将测量并返回指定运行次数的平均分配数量.

AllocsPerRun在测量期间将GOMAXPROCS设置为1,并将在返回之前将其还原.

func CoverMode 1.8

func CoverMode() string

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

func Coverage 1.4

func Coverage() float64

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

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

func Init 1.13

func Init()

初始化注册测试标志. 这些标志在运行测试功能之前由" go test"命令自动注册,因此仅在调用基准之类的功能而不使用" go test"时才需要Init.

如果已经调用了Init,则无效.

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 1.2

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

Short报告是否设置了-test.short标志.

func Verbose 1.1

func Verbose() bool

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

type B

B是传递给Benchmark函数的一种类型,用于管理基准测试时序并指定要运行的迭代次数.

基准测试在其Benchmark函数返回或调用FailNow,Fatal,Fatalf,SkipNow,Skip或Skipf中的任何方法时结束. 这些方法只能从运行Benchmark函数的goroutine中调用. 可以从多个goroutine中同时调用其他报告方法,例如Log和Error的变体.

像在测试中一样,基准日志在执行期间会累积,并在完成时转储为标准错误. 与测试不同,总是打印基准日志,以免隐藏可能影响基准结果的输出.

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

func (*B) Error

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

错误等同于日志,后跟失败.

func (*B) Errorf

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

Errorf等同于Logf,后跟失败.

func (*B) Fail

func (c *B) Fail()

失败将功能标记为失败,但继续执行.

func (*B) FailNow

func (c *B) FailNow()

FailNow将函数标记为失败,并通过调用runtime.Goexit(然后在当前goroutine中运行所有延迟的调用)来停止执行. 执行将在下一个测试或基准测试中继续. 必须从运行测试或基准功能的goroutine中调用FailNow,而不是从在测试过程中创建的其他goroutine中调用FailNow. 调用FailNow不会停止其他goroutine.

func (*B) Failed

func (c *B) Failed() bool

失败报告功能是否失败.

func (*B) Fatal

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

致命等同于Log,后跟FailNow.

func (*B) Fatalf

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

Fatalf等效于Logf,后跟FailNow.

func (*B) Helper 1.9

func (c *B) Helper()

助手将调用函数标记为测试助手函数. 当打印文件和行信息时,该功能将被跳过. 可以从多个goroutine中同时调用Helper.

func (*B) Log

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

日志使用类似于Println的默认格式来格式化其参数,并将文本记录在错误日志中. 对于测试,仅当测试失败或设置了-test.v标志时,才会打印文本. 对于基准测试,总是打印文本以避免性能取决于-test.v标志的值.

func (*B) Logf

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

Logf按照类似于Printf的格式设置其参数的格式,并将文本记录在错误日志中. 如果未提供,则添加最终换行符. 对于测试,仅当测试失败或设置了-test.v标志时,才会打印文本. 对于基准测试,总是打印文本以避免性能取决于-test.v标志的值.

func (*B) Name 1.8

func (c *B) Name() string

名称返回正在运行的测试或基准的名称.

func (*B) ReportAllocs 1.1

func (b *B) ReportAllocs()

ReportAllocs启用此基准的malloc统计信息. 它等效于设置-test.benchmem,但仅会影响调用ReportAllocs的基准功能.

func (*B) ReportMetric 1.13

func (b *B) ReportMetric(n float64, unit string)

ReportMetric将" n单位"添加到报告的基准结果中. 如果度量是按迭代的,则调用方应除以bN,按约定,单位应以" / op"结尾. ReportMetric覆盖同一单位的任何先前报告的值. 如果unit为空字符串或unit包含任何空格,则ReportMetric会发生混乱. 如果单位是基准框架本身通常报告的单位(例如" allocs / op"),则ReportMetric将覆盖该指标. 将" ns / op"设置为0将抑制该内置指标.

Example

func (*B) ResetTimer

func (b *B) ResetTimer()

ResetTimer将经过的基准时间和内存分配计数器归零,并删除用户报告的指标. 它不影响计时器是否正在运行.

func (*B) Run 1.7

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

使用给定名称将基准f作为子基准运行. 它报告是否有任何故障.

子基准类似于任何其他基准. 至少调用一次Run的基准将不会自行测量,并且将在N = 1时调用一次.

func (*B) RunParallel 1.3

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

RunParallel并行运行基准测试. 它创建多个goroutine,并在其中分配bN个迭代. goroutine的数量默认为GOMAXPROCS. 要提高非CPU基准测试的并行度,请在RunParallel之前调用SetParallelism. RunParallel通常与go test -cpu标志一起使用.

身体功能将在每个goroutine中运行. 它应该设置任何goroutine-local状态,然后进行迭代直到pb.Next返回false. 它不应使用StartTimer,StopTimer或ResetTimer函数,因为它们具有全局作用. 它也不应调用运行.

Example

func (*B) SetBytes

func (b *B) SetBytes(n int64)

SetBytes记录单个操作中处理的字节数. 如果调用此方法,则基准测试将报告ns / op和MB / s.

func (*B) SetParallelism 1.3

func (b *B) SetParallelism(p int)

SetParallelism将RunParallel使用的goroutine的数量设置为p * GOMAXPROCS. 通常不需要为CPU受限的基准调用SetParallelism. 如果p小于1,则此调用无效.

func (*B) Skip 1.1

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

跳过等同于日志,后跟跳过现在.

func (*B) SkipNow 1.1

func (c *B) SkipNow()

SkipNow将测试标记为已跳过,并通过调用runtime.Goexit停止执行. 如果测试失败(请参见错误,Errorf,失败),然后被跳过,则仍被视为失败. 执行将在下一个测试或基准测试中继续. 另请参见FailNow. 必须从运行测试的goroutine中调用SkipNow,而不是从测试过程中创建的其他goroutine中调用. 调用SkipNow不会停止其他goroutine.

func (*B) Skipf 1.1

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

Skipf等效于Logf,后跟SkipNow.

func (*B) Skipped 1.1

func (c *B) Skipped() bool

已跳过报告是否已跳过测试.

func (*B) StartTimer

func (b *B) StartTimer()

StartTimer开始计时测试. 在基准测试开始之前会自动调用此函数,但也可以将其用于在调用StopTimer之后恢复计时.

func (*B) StopTimer

func (b *B) StopTimer()

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; added in Go 1.1
    MemBytes  uint64        // The total number of bytes allocated; added in Go 1.1

    // Extra records additional metrics reported by ReportMetric.
    Extra map[string]float64 // Go 1.13
}

func Benchmark

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

基准测试是单个功能的基准. 对于创建不使用" go test"命令的自定义基准测试很有用.

如果f取决于测试标志,则必须在调用Benchmark和调用flag.Parse之前使用Init来注册这些标志.

如果f调用运行,则结果将是运行其所有子基准的估计,这些子基准未在单个基准中按顺序调用Run.

func (BenchmarkResult) AllocedBytesPerOp 1.1

func (r BenchmarkResult) AllocedBytesPerOp() int64

AllocedBytesPerOp返回" B / op"度量标准,该度量标准计算为r.MemBytes / rN

func (BenchmarkResult) AllocsPerOp 1.1

func (r BenchmarkResult) AllocsPerOp() int64

AllocsPerOp返回"分配/操作"度量标准,该度量标准计算为r.MemAllocs / rN

func (BenchmarkResult) MemString 1.1

func (r BenchmarkResult) MemString() string

MemString以与" go test"相同的格式返回r.AllocedBytesPerOp和r.AllocsPerOp.

func (BenchmarkResult) NsPerOp

func (r BenchmarkResult) NsPerOp() int64

NsPerOp返回" ns / op"度量.

func (BenchmarkResult) String

func (r BenchmarkResult) String() string

String返回基准测试结果的摘要. 它遵循https://golang.org/design/14313-benchmark-format中的基准结果行格式,不包括基准名称. 额外的指标会覆盖同名的内置指标. 字符串不包括allocs / op或B / op,因为这些是由MemString报告的.

type Cover 1.2

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

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

type CoverBlock 1.2

CoverBlock记录单个基本块的coverage数据. 像在编辑器中一样,这些字段是1索引的:例如,文件的开头行是1. 列以字节为单位. 注意:此结构在测试基础结构内部,并且可能会更改. Go 1兼容性准则尚未涵盖它.

type CoverBlock struct {
    Line0 uint32 // Line number for block start.
    Col0  uint16 // Column number for block start.
    Line1 uint32 // Line number for block end.
    Col1  uint16 // Column number for block end.
    Stmts uint16 // Number of statements included in this block.
}

type InternalBenchmark

内部类型,但由于交叉包装而导出; 执行"执行测试"命令的一部分.

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

type InternalExample

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

type InternalTest

An internal type but exported because it is cross-package; part of the implementation of the "go test" command.

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

type M 1.4

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

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

func MainStart 1.8

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

MainStart是供" go test"生成的测试使用的. 它并不意味着可以直接调用,也不受Go 1兼容性文档的约束. 它可能会在版本之间更改签名.

func (*M) Run 1.4

func (m *M) Run() int

运行运行测试. 它返回退出代码以传递给os.Exit.

type PB 1.3

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

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

func (*PB) Next 1.3

func (pb *PB) Next() bool

接下来报告是否还有更多迭代要执行.

type T

T是传递给"测试"功能的一种类型,用于管理测试状态并支持格式化的测试日志. 日志在执行期间累积,完成后转储到标准输出.

当测试的Test函数返回或调用FailNow,Fatal,Fatalf,SkipNow,Skip或Skipf中的任何方法时,测试结束. 只能从运行Test函数的goroutine中调用这些方法以及Parallel方法.

可以从多个goroutine中同时调用其他报告方法,例如Log和Error的变体.

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

func (*T) Error

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

错误等同于日志,后跟失败.

func (*T) Errorf

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

Errorf等同于Logf,后跟失败.

func (*T) Fail

func (c *T) Fail()

失败将功能标记为失败,但继续执行.

func (*T) FailNow

func (c *T) FailNow()

FailNow将函数标记为失败,并通过调用runtime.Goexit(然后在当前goroutine中运行所有延迟的调用)来停止执行. 执行将在下一个测试或基准测试中继续. 必须从运行测试或基准功能的goroutine中调用FailNow,而不是从在测试过程中创建的其他goroutine中调用FailNow. 调用FailNow不会停止其他goroutine.

func (*T) Failed

func (c *T) Failed() bool

失败报告功能是否失败.

func (*T) Fatal

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

致命等同于Log,后跟FailNow.

func (*T) Fatalf

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

Fatalf等效于Logf,后跟FailNow.

func (*T) Helper 1.9

func (c *T) Helper()

助手将调用函数标记为测试助手函数. 当打印文件和行信息时,该功能将被跳过. 可以从多个goroutine中同时调用Helper.

func (*T) Log

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

日志使用类似于Println的默认格式来格式化其参数,并将文本记录在错误日志中. 对于测试,仅当测试失败或设置了-test.v标志时,才会打印文本. 对于基准测试,总是打印文本以避免性能取决于-test.v标志的值.

func (*T) Logf

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

Logf按照类似于Printf的格式设置其参数的格式,并将文本记录在错误日志中. 如果未提供,则添加最终换行符. 对于测试,仅当测试失败或设置了-test.v标志时,才会打印文本. 对于基准测试,总是打印文本以避免性能取决于-test.v标志的值.

func (*T) Name 1.8

func (c *T) Name() string

Name returns the name of the running test or benchmark.

func (*T) Parallel

func (t *T) Parallel()

并行表示此测试将与(并且仅)与其他并行测试并行运行. 当由于使用-test.count或-test.cpu而多次运行测试时,单个测试的多个实例永远不会并行运行.

func (*T) Run 1.7

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

Run运行f作为t的子测试,称为name. 它在单独的goroutine中运行f并阻塞,直到f返回或调用t.Parallel成为并行测试. 运行报告f是否成功(或至少在调用t.Parallel之前没有失败).

可以从多个goroutine中同时调用run,但是所有此类调用必须在t的外部测试函数返回之前返回.

func (*T) Skip 1.1

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

跳过等同于日志,后跟跳过现在.

func (*T) SkipNow 1.1

func (c *T) SkipNow()

SkipNow将测试标记为已跳过,并通过调用runtime.Goexit停止执行. 如果测试失败(请参见错误,Errorf,失败),然后被跳过,则仍被视为失败. 执行将在下一个测试或基准测试中继续. 另请参见FailNow. 必须从运行测试的goroutine中调用SkipNow,而不是从测试过程中创建的其他goroutine中调用. 调用SkipNow不会停止其他goroutine.

func (*T) Skipf 1.1

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

Skipf等效于Logf,后跟SkipNow.

func (*T) Skipped 1.1

func (c *T) Skipped() bool

已跳过报告是否已跳过测试.

type TB 1.9

TB是T和B通用的接口.

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
    Helper()
    // contains filtered or unexported methods
}

Subdirectories

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

by  ICOPY.SITE