func AllocsPerRun(runsint, f func()) (avgfloat64)

func CoverMode()string

func Coverage()float64

func Init()

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

func RegisterCover(cCover)

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

func RunExamples(matchString func(pat, strstring) (bool,error), examples []InternalExample) (okbool)

func RunTests(matchString func(pat, strstring) (bool,error), tests []InternalTest) (okbool)

func Short()bool

func Testing()bool

func Verbose()bool

type B struct {Nint// contains filtered or unexported fields}

func (*B)Attr¶added ingo1.25.0

func (c *B) Attr(key, valuestring)

Attr emits a test attribute associated with this test.

The key must not contain whitespace.The value must not contain newlines or carriage returns.

The meaning of different attribute keys is left up tocontinuous integration systems and test frameworks.

Test attributes are emitted immediately in the test log,but they are intended to be treated as unordered.

func (*B)Chdir¶added ingo1.24.0

func (c *B) Chdir(dirstring)

Chdir callsos.Chdir and uses Cleanup to restore the currentworking directory to its original value after the test. On Unix, italso sets PWD environment variable for the duration of the test.

Because Chdir affects the whole process, it cannot be usedin parallel tests or tests with parallel ancestors.

func (*B)Cleanup¶added ingo1.14

func (c *B) Cleanup(f func())

Cleanup registers a function to be called when the test (or subtest) and all itssubtests complete. Cleanup functions will be called in last added,first called order.

func (*B)Context¶added ingo1.24.0

func (c *B) Context()context.Context

Context returns a context that is canceled just beforeCleanup-registered functions are called.

Cleanup functions can wait for any resourcesthat shut down oncontext.Context.Done before the test or benchmark completes.

func (*B)Elapsed¶added ingo1.20

func (b *B) Elapsed()time.Duration

Elapsed returns the measured elapsed time of the benchmark.The duration reported by Elapsed matches the one measured byB.StartTimer,B.StopTimer, andB.ResetTimer.

func (*B)Error¶

func (c *B) Error(args ...any)

Error is equivalent to Log followed by Fail.

func (*B)Errorf¶

func (c *B) Errorf(formatstring, args ...any)

Errorf is equivalent to Logf followed by Fail.

func (*B)Fail¶

func (c *B) Fail()

Fail marks the function as having failed but continues execution.

func (*B)FailNow¶

func (c *B) FailNow()

FailNow marks the function as having failed and stops its executionby callingruntime.Goexit (which then runs all deferred calls in thecurrent goroutine).Execution will continue at the next test or benchmark.FailNow must be called from the goroutine running thetest or benchmark function, not from other goroutinescreated during the test. Calling FailNow does not stopthose other goroutines.

func (*B)Failed¶

func (c *B) Failed()bool

Failed reports whether the function has failed.

func (*B)Fatal¶

func (c *B) Fatal(args ...any)

Fatal is equivalent to Log followed by FailNow.

func (*B)Fatalf¶

func (c *B) Fatalf(formatstring, args ...any)

Fatalf is equivalent to Logf followed by FailNow.

func (*B)Helper¶added ingo1.9

func (c *B) Helper()

Helper marks the calling function as a test helper function.When printing file and line information, that function will be skipped.Helper may be called simultaneously from multiple goroutines.

func (*B)Log¶

func (c *B) Log(args ...any)

Log formats its arguments using default formatting, analogous tofmt.Println,and records the text in the error log. For tests, the text will be printed only ifthe test fails or the -test.v flag is set. For benchmarks, the text is alwaysprinted to avoid having performance depend on the value of the -test.v flag.It is an error to call Log after a test or benchmark returns.

func (*B)Logf¶

func (c *B) Logf(formatstring, args ...any)

Logf formats its arguments according to the format, analogous tofmt.Printf, andrecords the text in the error log. A final newline is added if not provided. Fortests, the text will be printed only if the test fails or the -test.v flag isset. For benchmarks, the text is always printed to avoid having performancedepend on the value of the -test.v flag.It is an error to call Logf after a test or benchmark returns.

func (*B)Loop¶added ingo1.24.0

func (b *B) Loop()bool

Loop returns true as long as the benchmark should continue running.

A typical benchmark is structured like:

func Benchmark(b *testing.B) {... setup ...for b.Loop() {... code to measure ...}... cleanup ...}

Loop resets the benchmark timer the first time it is called in a benchmark,so any setup performed prior to starting the benchmark loop does not counttoward the benchmark measurement. Likewise, when it returns false, it stopsthe timer so cleanup code is not measured.

Within the body of a "for b.Loop() { ... }" loop, arguments to andresults from function calls within the loop are kept alive, preventingthe compiler from fully optimizing away the loop body. Currently, this isimplemented by disabling inlining of functions called in a b.Loop loop.This applies only to calls syntactically between the curly braces of the loop,and the loop condition must be written exactly as "b.Loop()". Optimizationsare performed as usual in any functions called by the loop.

After Loop returns false, b.N contains the total number of iterations thatran, so the benchmark may use b.N to compute other average metrics.

Prior to the introduction of Loop, benchmarks were expected to contain anexplicit loop from 0 to b.N. Benchmarks should either use Loop or contain aloop to b.N, but not both. Loop offers more automatic management of thebenchmark timer, and runs each benchmark function only once per measurement,whereas b.N-based benchmarks must run the benchmark function (and anyassociated setup and cleanup) several times.

package mainimport ("math/rand/v2""testing")// ExBenchmark shows how to use b.Loop in a benchmark.//// (If this were a real benchmark, not an example, this would be named// BenchmarkSomething.)func ExBenchmark(b *testing.B) {// Generate a large random slice to use as an input.// Since this is done before the first call to b.Loop(),// it doesn't count toward the benchmark time.input := make([]int, 128<<10)for i := range input {input[i] = rand.Int()}// Perform the benchmark.for b.Loop() {// Normally, the compiler would be allowed to optimize away the call// to sum because it has no side effects and the result isn't used.// However, inside a b.Loop loop, the compiler ensures function calls// aren't optimized away.sum(input)}// Outside the loop, the timer is stopped, so we could perform// cleanup if necessary without affecting the result.}func sum(data []int) int {total := 0for _, value := range data {total += value}return total}func main() {testing.Benchmark(ExBenchmark)}

func (*B)Name¶added ingo1.8

func (c *B) Name()string

Name returns the name of the running (sub-) test or benchmark.

The name will include the name of the test along with the names ofany nested sub-tests. If two sibling sub-tests have the same name,Name will append a suffix to guarantee the returned name is unique.

func (*B)Output¶added ingo1.25.0

func (c *B) Output()io.Writer

Output returns a Writer that writes to the same test output stream as TB.Log.The output is indented like TB.Log lines, but Output does notadd source locations or newlines. The output is internally linebuffered, and a call to TB.Log or the end of the test will implicitlyflush the buffer, followed by a newline. After a test function and all itsparents return, neither Output nor the Write method may be called.

func (*B)ReportAllocs¶added ingo1.1

func (b *B) ReportAllocs()

ReportAllocs enables malloc statistics for this benchmark.It is equivalent to setting -test.benchmem, but it only affects thebenchmark function that calls ReportAllocs.

func (*B)ReportMetric¶added ingo1.13

func (b *B) ReportMetric(nfloat64, unitstring)

ReportMetric adds "n unit" to the reported benchmark results.If the metric is per-iteration, the caller should divide by b.N,and by convention units should end in "/op".ReportMetric overrides any previously reported value for the same unit.ReportMetric panics if unit is the empty string or if unit containsany whitespace.If unit is a unit normally reported by the benchmark framework itself(such as "allocs/op"), ReportMetric will override that metric.Setting "ns/op" to 0 will suppress that built-in metric.

package mainimport ("cmp""slices""testing")func main() {// This reports a custom benchmark metric relevant to a// specific algorithm (in this case, sorting).testing.Benchmark(func(b *testing.B) {var compares int64for b.Loop() {s := []int{5, 4, 3, 2, 1}slices.SortFunc(s, func(a, b int) int {compares++return cmp.Compare(a, b)})}// This metric is per-operation, so divide by b.N and// report it as a "/op" unit.b.ReportMetric(float64(compares)/float64(b.N), "compares/op")// This metric is per-time, so divide by b.Elapsed and// report it as a "/ns" unit.b.ReportMetric(float64(compares)/float64(b.Elapsed().Nanoseconds()), "compares/ns")})}

package mainimport ("cmp""slices""sync/atomic""testing")func main() {// This reports a custom benchmark metric relevant to a// specific algorithm (in this case, sorting) in parallel.testing.Benchmark(func(b *testing.B) {var compares atomic.Int64b.RunParallel(func(pb *testing.PB) {for pb.Next() {s := []int{5, 4, 3, 2, 1}slices.SortFunc(s, func(a, b int) int {// Because RunParallel runs the function many// times in parallel, we must increment the// counter atomically to avoid racing writes.compares.Add(1)return cmp.Compare(a, b)})}})// NOTE: Report each metric once, after all of the parallel// calls have completed.// This metric is per-operation, so divide by b.N and// report it as a "/op" unit.b.ReportMetric(float64(compares.Load())/float64(b.N), "compares/op")// This metric is per-time, so divide by b.Elapsed and// report it as a "/ns" unit.b.ReportMetric(float64(compares.Load())/float64(b.Elapsed().Nanoseconds()), "compares/ns")})}

func (*B)ResetTimer¶

func (b *B) ResetTimer()

ResetTimer zeroes the elapsed benchmark time and memory allocation countersand deletes user-reported metrics.It does not affect whether the timer is running.

func (*B)Run¶added ingo1.7

func (b *B) Run(namestring, f func(b *B))bool

Run benchmarks f as a subbenchmark with the given name. It reportswhether there were any failures.

A subbenchmark is like any other benchmark. A benchmark that calls Run atleast once will not be measured itself and will be called once with N=1.

func (*B)RunParallel¶added ingo1.3

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

RunParallel runs a benchmark in parallel.It creates multiple goroutines and distributes b.N iterations among them.The number of goroutines defaults to GOMAXPROCS. To increase parallelism fornon-CPU-bound benchmarks, callB.SetParallelism before RunParallel.RunParallel is usually used with the go test -cpu flag.

The body function will be run in each goroutine. It should set up anygoroutine-local state and then iterate until pb.Next returns false.It should not use theB.StartTimer,B.StopTimer, orB.ResetTimer functions,because they have global effect. It should also not callB.Run.

RunParallel reports ns/op values as wall time for the benchmark as a whole,not the sum of wall time or CPU time over each parallel goroutine.

package mainimport ("bytes""testing""text/template")func main() {// Parallel benchmark for text/template.Template.Execute on a single object.testing.Benchmark(func(b *testing.B) {templ := template.Must(template.New("test").Parse("Hello, {{.}}!"))// RunParallel will create GOMAXPROCS goroutines// and distribute work among them.b.RunParallel(func(pb *testing.PB) {// Each goroutine has its own bytes.Buffer.var buf bytes.Bufferfor pb.Next() {// The loop body is executed b.N times total across all goroutines.buf.Reset()templ.Execute(&buf, "World")}})})}

func (*B)SetBytes¶

func (b *B) SetBytes(nint64)

SetBytes records the number of bytes processed in a single operation.If this is called, the benchmark will report ns/op and MB/s.

func (*B)SetParallelism¶added ingo1.3

func (b *B) SetParallelism(pint)

SetParallelism sets the number of goroutines used byB.RunParallel to p*GOMAXPROCS.There is usually no need to call SetParallelism for CPU-bound benchmarks.If p is less than 1, this call will have no effect.

func (*B)Setenv¶added ingo1.17

func (c *B) Setenv(key, valuestring)

Setenv callsos.Setenv and uses Cleanup torestore the environment variable to its original valueafter the test.

Because Setenv affects the whole process, it cannot be usedin parallel tests or tests with parallel ancestors.

func (*B)Skip¶added ingo1.1

func (c *B) Skip(args ...any)

Skip is equivalent to Log followed by SkipNow.

func (*B)SkipNow¶added ingo1.1

func (c *B) SkipNow()

SkipNow marks the test as having been skipped and stops its executionby callingruntime.Goexit.If a test fails (see Error, Errorf, Fail) and is then skipped,it is still considered to have failed.Execution will continue at the next test or benchmark. See also FailNow.SkipNow must be called from the goroutine running the test, not fromother goroutines created during the test. Calling SkipNow does not stopthose other goroutines.

func (*B)Skipf¶added ingo1.1

func (c *B) Skipf(formatstring, args ...any)

Skipf is equivalent to Logf followed by SkipNow.

func (*B)Skipped¶added ingo1.1

func (c *B) Skipped()bool

Skipped reports whether the test was skipped.

func (*B)StartTimer¶

func (b *B) StartTimer()

StartTimer starts timing a test. This function is called automaticallybefore a benchmark starts, but it can also be used to resume timing aftera call toB.StopTimer.

func (*B)StopTimer¶

func (b *B) StopTimer()

StopTimer stops timing a test. This can be used to pause the timerwhile performing steps that you don't want to measure.

func (*B)TempDir¶added ingo1.15

func (c *B) TempDir()string

TempDir returns a temporary directory for the test to use.The directory is automatically removed when the test andall its subtests complete.Each subsequent call to TempDir returns a unique directory;if the directory creation fails, TempDir terminates the test by calling Fatal.

type BenchmarkResult struct {Nint// The number of iterations.Ttime.Duration// The total time taken.Bytesint64// Bytes processed in one iteration.MemAllocsuint64// The total number of memory allocations.MemBytesuint64// The total number of bytes allocated.// Extra records additional metrics reported by ReportMetric.Extra map[string]float64}

funcBenchmark¶

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

Benchmark benchmarks a single function. It is useful for creatingcustom benchmarks that do not use the "go test" command.

If f depends on testing flags, thenInit must be used to registerthose flags before calling Benchmark and before callingflag.Parse.

If f calls Run, the result will be an estimate of running all itssubbenchmarks that don't call Run in sequence in a single benchmark.

func (BenchmarkResult)AllocedBytesPerOp¶added ingo1.1

func (rBenchmarkResult) AllocedBytesPerOp()int64

AllocedBytesPerOp returns the "B/op" metric,which is calculated as r.MemBytes / r.N.

func (BenchmarkResult)AllocsPerOp¶added ingo1.1

func (rBenchmarkResult) AllocsPerOp()int64

AllocsPerOp returns the "allocs/op" metric,which is calculated as r.MemAllocs / r.N.

func (BenchmarkResult)MemString¶added ingo1.1

func (rBenchmarkResult) MemString()string

MemString returns r.AllocedBytesPerOp and r.AllocsPerOp in the same format as 'go test'.

func (BenchmarkResult)NsPerOp¶

func (rBenchmarkResult) NsPerOp()int64

NsPerOp returns the "ns/op" metric.

func (BenchmarkResult)String¶

func (rBenchmarkResult) String()string

String returns a summary of the benchmark results.It follows the benchmark result line format fromhttps://golang.org/design/14313-benchmark-format, not including thebenchmark name.Extra metrics override built-in metrics of the same name.String does not include allocs/op or B/op, since those are reportedbyBenchmarkResult.MemString.

type Cover struct {ModestringCounters        map[string][]uint32Blocks          map[string][]CoverBlockCoveredPackagesstring}

type CoverBlock struct {Line0uint32// Line number for block start.Col0uint16// Column number for block start.Line1uint32// Line number for block end.Col1uint16// Column number for block end.Stmtsuint16// Number of statements included in this block.}

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

func (*F)Add¶added ingo1.18

func (f *F) Add(args ...any)

Add will add the arguments to the seed corpus for the fuzz test. This will bea no-op if called after or within the fuzz target, and args must match thearguments for the fuzz target.

func (*F)Attr¶added ingo1.25.0

func (c *F) Attr(key, valuestring)

Attr emits a test attribute associated with this test.

The key must not contain whitespace.The value must not contain newlines or carriage returns.

The meaning of different attribute keys is left up tocontinuous integration systems and test frameworks.

Test attributes are emitted immediately in the test log,but they are intended to be treated as unordered.

func (*F)Chdir¶added ingo1.24.0

func (c *F) Chdir(dirstring)

Chdir callsos.Chdir and uses Cleanup to restore the currentworking directory to its original value after the test. On Unix, italso sets PWD environment variable for the duration of the test.

Because Chdir affects the whole process, it cannot be usedin parallel tests or tests with parallel ancestors.

func (*F)Cleanup¶added ingo1.18

func (c *F) Cleanup(f func())

Cleanup registers a function to be called when the test (or subtest) and all itssubtests complete. Cleanup functions will be called in last added,first called order.

func (*F)Context¶added ingo1.24.0

func (c *F) Context()context.Context

Context returns a context that is canceled just beforeCleanup-registered functions are called.

Cleanup functions can wait for any resourcesthat shut down oncontext.Context.Done before the test or benchmark completes.

func (*F)Error¶added ingo1.18

func (c *F) Error(args ...any)

Error is equivalent to Log followed by Fail.

func (*F)Errorf¶added ingo1.18

func (c *F) Errorf(formatstring, args ...any)

Errorf is equivalent to Logf followed by Fail.

func (*F)Fail¶added ingo1.18

func (f *F) Fail()

Fail marks the function as having failed but continues execution.

func (*F)FailNow¶added ingo1.18

func (c *F) FailNow()

FailNow marks the function as having failed and stops its executionby callingruntime.Goexit (which then runs all deferred calls in thecurrent goroutine).Execution will continue at the next test or benchmark.FailNow must be called from the goroutine running thetest or benchmark function, not from other goroutinescreated during the test. Calling FailNow does not stopthose other goroutines.

func (*F)Failed¶added ingo1.18

func (c *F) Failed()bool

Failed reports whether the function has failed.

func (*F)Fatal¶added ingo1.18

func (c *F) Fatal(args ...any)

Fatal is equivalent to Log followed by FailNow.

func (*F)Fatalf¶added ingo1.18

func (c *F) Fatalf(formatstring, args ...any)

Fatalf is equivalent to Logf followed by FailNow.

func (*F)Fuzz¶added ingo1.18

func (f *F) Fuzz(ffany)

Fuzz runs the fuzz function, ff, for fuzz testing. If ff fails for a set ofarguments, those arguments will be added to the seed corpus.

ff must be a function with no return value whose first argument is*T andwhose remaining arguments are the types to be fuzzed.For example:

f.Fuzz(func(t *testing.T, b []byte, i int) { ... })

The following types are allowed: []byte, string, bool, byte, rune, float32,float64, int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64.More types may be supported in the future.

ff must not call any*F methods, e.g.F.Log,F.Error,F.Skip. Usethe corresponding*T method instead. The only*F methods that are allowed inthe F.Fuzz function areF.Failed andF.Name.

This function should be fast and deterministic, and its behavior should notdepend on shared state. No mutable input arguments, or pointers to them,should be retained between executions of the fuzz function, as the memorybacking them may be mutated during a subsequent invocation. ff must notmodify the underlying data of the arguments provided by the fuzzing engine.

When fuzzing, F.Fuzz does not return until a problem is found, time runs out(set with -fuzztime), or the test process is interrupted by a signal. F.Fuzzshould be called exactly once, unlessF.Skip orF.Fail is called beforehand.

func (*F)Helper¶added ingo1.18

func (f *F) Helper()

Helper marks the calling function as a test helper function.When printing file and line information, that function will be skipped.Helper may be called simultaneously from multiple goroutines.

func (*F)Log¶added ingo1.18

func (c *F) Log(args ...any)

Log formats its arguments using default formatting, analogous tofmt.Println,and records the text in the error log. For tests, the text will be printed only ifthe test fails or the -test.v flag is set. For benchmarks, the text is alwaysprinted to avoid having performance depend on the value of the -test.v flag.It is an error to call Log after a test or benchmark returns.

func (*F)Logf¶added ingo1.18

func (c *F) Logf(formatstring, args ...any)

Logf formats its arguments according to the format, analogous tofmt.Printf, andrecords the text in the error log. A final newline is added if not provided. Fortests, the text will be printed only if the test fails or the -test.v flag isset. For benchmarks, the text is always printed to avoid having performancedepend on the value of the -test.v flag.It is an error to call Logf after a test or benchmark returns.

func (*F)Name¶added ingo1.18

func (c *F) Name()string

Name returns the name of the running (sub-) test or benchmark.

The name will include the name of the test along with the names ofany nested sub-tests. If two sibling sub-tests have the same name,Name will append a suffix to guarantee the returned name is unique.

func (*F)Output¶added ingo1.25.0

func (c *F) Output()io.Writer

Output returns a Writer that writes to the same test output stream as TB.Log.The output is indented like TB.Log lines, but Output does notadd source locations or newlines. The output is internally linebuffered, and a call to TB.Log or the end of the test will implicitlyflush the buffer, followed by a newline. After a test function and all itsparents return, neither Output nor the Write method may be called.

func (*F)Setenv¶added ingo1.18

func (c *F) Setenv(key, valuestring)

Setenv callsos.Setenv and uses Cleanup torestore the environment variable to its original valueafter the test.

Because Setenv affects the whole process, it cannot be usedin parallel tests or tests with parallel ancestors.

func (*F)Skip¶added ingo1.18

func (c *F) Skip(args ...any)

Skip is equivalent to Log followed by SkipNow.

func (*F)SkipNow¶added ingo1.18

func (c *F) SkipNow()

SkipNow marks the test as having been skipped and stops its executionby callingruntime.Goexit.If a test fails (see Error, Errorf, Fail) and is then skipped,it is still considered to have failed.Execution will continue at the next test or benchmark. See also FailNow.SkipNow must be called from the goroutine running the test, not fromother goroutines created during the test. Calling SkipNow does not stopthose other goroutines.

func (*F)Skipf¶added ingo1.18

func (c *F) Skipf(formatstring, args ...any)

Skipf is equivalent to Logf followed by SkipNow.

func (*F)Skipped¶added ingo1.18

func (f *F) Skipped()bool

Skipped reports whether the test was skipped.

func (*F)TempDir¶added ingo1.18

func (c *F) TempDir()string

TempDir returns a temporary directory for the test to use.The directory is automatically removed when the test andall its subtests complete.Each subsequent call to TempDir returns a unique directory;if the directory creation fails, TempDir terminates the test by calling Fatal.

type InternalBenchmark struct {NamestringF    func(b *B)}

type InternalExample struct {NamestringF         func()OutputstringUnorderedbool}

type InternalFuzzTarget struct {NamestringFn   func(f *F)}

type InternalTest struct {NamestringF    func(*T)}

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

funcMainStart¶added ingo1.4

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

MainStart is meant for use by tests generated by 'go test'.It is not meant to be called directly and is not subject to the Go 1 compatibility document.It may change signature from release to release.

func (*M)Run¶added ingo1.4

func (m *M) Run() (codeint)

Run runs the tests. It returns an exit code to pass to os.Exit.The exit code is zero when all tests pass, and non-zero for any kindof failure. For machine readable test results, parse the output of'go test -json'.

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

func (*PB)Next¶added ingo1.3

func (pb *PB) Next()bool

Next reports whether there are more iterations to execute.

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

func (*T)Attr¶added ingo1.25.0

func (c *T) Attr(key, valuestring)

Attr emits a test attribute associated with this test.

The key must not contain whitespace.The value must not contain newlines or carriage returns.

The meaning of different attribute keys is left up tocontinuous integration systems and test frameworks.

Test attributes are emitted immediately in the test log,but they are intended to be treated as unordered.

func (*T)Chdir¶added ingo1.24.0

func (t *T) Chdir(dirstring)

Chdir callsos.Chdir and uses Cleanup to restore the currentworking directory to its original value after the test. On Unix, italso sets PWD environment variable for the duration of the test.

Because Chdir affects the whole process, it cannot be usedin parallel tests or tests with parallel ancestors.

func (*T)Cleanup¶added ingo1.14

func (c *T) Cleanup(f func())

Cleanup registers a function to be called when the test (or subtest) and all itssubtests complete. Cleanup functions will be called in last added,first called order.

func (*T)Context¶added ingo1.24.0

func (c *T) Context()context.Context

Context returns a context that is canceled just beforeCleanup-registered functions are called.

Cleanup functions can wait for any resourcesthat shut down oncontext.Context.Done before the test or benchmark completes.

func (*T)Deadline¶added ingo1.15

func (t *T) Deadline() (deadlinetime.Time, okbool)

Deadline reports the time at which the test binary will haveexceeded the timeout specified by the -timeout flag.

The ok result is false if the -timeout flag indicates “no timeout” (0).

func (*T)Error¶

func (c *T) Error(args ...any)

Error is equivalent to Log followed by Fail.

func (*T)Errorf¶

func (c *T) Errorf(formatstring, args ...any)

Errorf is equivalent to Logf followed by Fail.

func (*T)Fail¶

func (c *T) Fail()

Fail marks the function as having failed but continues execution.

func (*T)FailNow¶

func (c *T) FailNow()

FailNow marks the function as having failed and stops its executionby callingruntime.Goexit (which then runs all deferred calls in thecurrent goroutine).Execution will continue at the next test or benchmark.FailNow must be called from the goroutine running thetest or benchmark function, not from other goroutinescreated during the test. Calling FailNow does not stopthose other goroutines.

func (*T)Failed¶

func (c *T) Failed()bool

Failed reports whether the function has failed.

func (*T)Fatal¶

func (c *T) Fatal(args ...any)

Fatal is equivalent to Log followed by FailNow.

func (*T)Fatalf¶

func (c *T) Fatalf(formatstring, args ...any)

Fatalf is equivalent to Logf followed by FailNow.

func (*T)Helper¶added ingo1.9

func (c *T) Helper()

Helper marks the calling function as a test helper function.When printing file and line information, that function will be skipped.Helper may be called simultaneously from multiple goroutines.

func (*T)Log¶

func (c *T) Log(args ...any)

Log formats its arguments using default formatting, analogous tofmt.Println,and records the text in the error log. For tests, the text will be printed only ifthe test fails or the -test.v flag is set. For benchmarks, the text is alwaysprinted to avoid having performance depend on the value of the -test.v flag.It is an error to call Log after a test or benchmark returns.

func (*T)Logf¶

func (c *T) Logf(formatstring, args ...any)

Logf formats its arguments according to the format, analogous tofmt.Printf, andrecords the text in the error log. A final newline is added if not provided. Fortests, the text will be printed only if the test fails or the -test.v flag isset. For benchmarks, the text is always printed to avoid having performancedepend on the value of the -test.v flag.It is an error to call Logf after a test or benchmark returns.

func (*T)Name¶added ingo1.8

func (c *T) Name()string

Name returns the name of the running (sub-) test or benchmark.

The name will include the name of the test along with the names ofany nested sub-tests. If two sibling sub-tests have the same name,Name will append a suffix to guarantee the returned name is unique.

func (*T)Output¶added ingo1.25.0

func (c *T) Output()io.Writer

Output returns a Writer that writes to the same test output stream as TB.Log.The output is indented like TB.Log lines, but Output does notadd source locations or newlines. The output is internally linebuffered, and a call to TB.Log or the end of the test will implicitlyflush the buffer, followed by a newline. After a test function and all itsparents return, neither Output nor the Write method may be called.

func (*T)Parallel¶

func (t *T) Parallel()

Parallel signals that this test is to be run in parallel with (and only with)other parallel tests. When a test is run multiple times due to use of-test.count or -test.cpu, multiple instances of a single test never run inparallel with each other.

func (*T)Run¶added ingo1.7

func (t *T) Run(namestring, f func(t *T))bool

Run runs f as a subtest of t called name. It runs f in a separate goroutineand blocks until f returns or calls t.Parallel to become a parallel test.Run reports whether f succeeded (or at least did not fail before calling t.Parallel).

Run may be called simultaneously from multiple goroutines, but all such callsmust return before the outer test function for t returns.

func (*T)Setenv¶added ingo1.17

func (t *T) Setenv(key, valuestring)

Setenv calls os.Setenv(key, value) and uses Cleanup torestore the environment variable to its original valueafter the test.

Because Setenv affects the whole process, it cannot be usedin parallel tests or tests with parallel ancestors.

func (*T)Skip¶added ingo1.1

func (c *T) Skip(args ...any)

Skip is equivalent to Log followed by SkipNow.

func (*T)SkipNow¶added ingo1.1

func (c *T) SkipNow()

SkipNow marks the test as having been skipped and stops its executionby callingruntime.Goexit.If a test fails (see Error, Errorf, Fail) and is then skipped,it is still considered to have failed.Execution will continue at the next test or benchmark. See also FailNow.SkipNow must be called from the goroutine running the test, not fromother goroutines created during the test. Calling SkipNow does not stopthose other goroutines.

func (*T)Skipf¶added ingo1.1

func (c *T) Skipf(formatstring, args ...any)

Skipf is equivalent to Logf followed by SkipNow.

func (*T)Skipped¶added ingo1.1

func (c *T) Skipped()bool

Skipped reports whether the test was skipped.

func (*T)TempDir¶added ingo1.15

func (c *T) TempDir()string

TempDir returns a temporary directory for the test to use.The directory is automatically removed when the test andall its subtests complete.Each subsequent call to TempDir returns a unique directory;if the directory creation fails, TempDir terminates the test by calling Fatal.

type TB interface {Attr(key, valuestring)Cleanup(func())Error(args ...any)Errorf(formatstring, args ...any)Fail()FailNow()Failed()boolFatal(args ...any)Fatalf(formatstring, args ...any)Helper()Log(args ...any)Logf(formatstring, args ...any)Name()stringSetenv(key, valuestring)Chdir(dirstring)Skip(args ...any)SkipNow()Skipf(formatstring, args ...any)Skipped()boolTempDir()stringContext()context.ContextOutput()io.Writer// contains filtered or unexported methods}