4deda6ea98
* Changes to make vendored packages accept new home. * Fix go2idl to import vendored packages.
299 lines
8.6 KiB
Plaintext
299 lines
8.6 KiB
Plaintext
// Package testing provides support for automated testing of Go ...
|
|
PACKAGE testing
|
|
|
|
IMPORTPATH
|
|
testdata/testing
|
|
|
|
IMPORTS
|
|
bytes
|
|
flag
|
|
fmt
|
|
io
|
|
os
|
|
runtime
|
|
runtime/pprof
|
|
strconv
|
|
strings
|
|
time
|
|
|
|
FILENAMES
|
|
testdata/benchmark.go
|
|
testdata/example.go
|
|
testdata/testing.go
|
|
|
|
VARIABLES
|
|
//
|
|
var (
|
|
// The short flag requests that tests run more quickly, but its functionality
|
|
// is provided by test writers themselves. The testing package is just its
|
|
// home. The all.bash installation script sets it to make installation more
|
|
// efficient, but by default the flag is off so a plain "go test" will do a
|
|
// full test of the package.
|
|
short = flag.Bool("test.short", false, "run smaller test suite to save time")
|
|
|
|
// Report as tests are run; default is silent for success.
|
|
chatty = flag.Bool("test.v", false, "verbose: print additional output")
|
|
match = flag.String("test.run", "", "regular expression to select tests to run")
|
|
memProfile = flag.String("test.memprofile", "", "write a memory profile to the named file after execution")
|
|
memProfileRate = flag.Int("test.memprofilerate", 0, "if >=0, sets runtime.MemProfileRate")
|
|
cpuProfile = flag.String("test.cpuprofile", "", "write a cpu profile to the named file during execution")
|
|
timeout = flag.Duration("test.timeout", 0, "if positive, sets an aggregate time limit for all tests")
|
|
cpuListStr = flag.String("test.cpu", "", "comma-separated list of number of CPUs to use for each test")
|
|
parallel = flag.Int("test.parallel", runtime.GOMAXPROCS(0), "maximum test parallelism")
|
|
|
|
cpuList []int
|
|
)
|
|
|
|
//
|
|
var benchTime = flag.Duration("test.benchtime", 1*time.Second, "approximate run time for each benchmark")
|
|
|
|
//
|
|
var matchBenchmarks = flag.String("test.bench", "", "regular expression to select benchmarks to run")
|
|
|
|
//
|
|
var timer *time.Timer
|
|
|
|
|
|
FUNCTIONS
|
|
// An internal function but exported because it is cross-package; ...
|
|
func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample)
|
|
|
|
// An internal function but exported because it is cross-package; ...
|
|
func RunBenchmarks(matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark)
|
|
|
|
//
|
|
func RunExamples(examples []InternalExample) (ok bool)
|
|
|
|
//
|
|
func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool)
|
|
|
|
// Short reports whether the -test.short flag is set.
|
|
func Short() bool
|
|
|
|
// after runs after all testing.
|
|
func after()
|
|
|
|
// alarm is called if the timeout expires.
|
|
func alarm()
|
|
|
|
// before runs before all testing.
|
|
func before()
|
|
|
|
// decorate inserts the final newline if needed and indentation ...
|
|
func decorate(s string, addFileLine bool) string
|
|
|
|
//
|
|
func max(x, y int) int
|
|
|
|
//
|
|
func min(x, y int) int
|
|
|
|
//
|
|
func parseCpuList()
|
|
|
|
// roundDown10 rounds a number down to the nearest power of 10.
|
|
func roundDown10(n int) int
|
|
|
|
// roundUp rounds x up to a number of the form [1eX, 2eX, 5eX].
|
|
func roundUp(n int) int
|
|
|
|
// startAlarm starts an alarm if requested.
|
|
func startAlarm()
|
|
|
|
// stopAlarm turns off the alarm.
|
|
func stopAlarm()
|
|
|
|
//
|
|
func tRunner(t *T, test *InternalTest)
|
|
|
|
|
|
TYPES
|
|
// B is a type passed to Benchmark functions to manage benchmark ...
|
|
type B struct {
|
|
common
|
|
N int
|
|
benchmark InternalBenchmark
|
|
bytes int64
|
|
timerOn bool
|
|
result BenchmarkResult
|
|
}
|
|
|
|
// Error is equivalent to Log() followed by Fail().
|
|
func (c *B) Error(args ...interface{})
|
|
|
|
// Errorf is equivalent to Logf() followed by Fail().
|
|
func (c *B) Errorf(format string, args ...interface{})
|
|
|
|
// Fail marks the function as having failed but continues ...
|
|
func (c *B) Fail()
|
|
|
|
// FailNow marks the function as having failed and stops its ...
|
|
func (c *B) FailNow()
|
|
|
|
// Failed reports whether the function has failed.
|
|
func (c *B) Failed() bool
|
|
|
|
// Fatal is equivalent to Log() followed by FailNow().
|
|
func (c *B) Fatal(args ...interface{})
|
|
|
|
// Fatalf is equivalent to Logf() followed by FailNow().
|
|
func (c *B) Fatalf(format string, args ...interface{})
|
|
|
|
// Log formats its arguments using default formatting, analogous ...
|
|
func (c *B) Log(args ...interface{})
|
|
|
|
// Logf formats its arguments according to the format, analogous ...
|
|
func (c *B) Logf(format string, args ...interface{})
|
|
|
|
// ResetTimer sets the elapsed benchmark time to zero. It does not ...
|
|
func (b *B) ResetTimer()
|
|
|
|
// SetBytes records the number of bytes processed in a single ...
|
|
func (b *B) SetBytes(n int64)
|
|
|
|
// StartTimer starts timing a test. This function is called ...
|
|
func (b *B) StartTimer()
|
|
|
|
// StopTimer stops timing a test. This can be used to pause the ...
|
|
func (b *B) StopTimer()
|
|
|
|
// launch launches the benchmark function. It gradually increases ...
|
|
func (b *B) launch()
|
|
|
|
// log generates the output. It's always at the same stack depth.
|
|
func (c *B) log(s string)
|
|
|
|
//
|
|
func (b *B) nsPerOp() int64
|
|
|
|
// run times the benchmark function in a separate goroutine.
|
|
func (b *B) run() BenchmarkResult
|
|
|
|
// runN runs a single benchmark for the specified number of ...
|
|
func (b *B) runN(n int)
|
|
|
|
// trimOutput shortens the output from a benchmark, which can be ...
|
|
func (b *B) trimOutput()
|
|
|
|
// The results of a benchmark run.
|
|
type BenchmarkResult struct {
|
|
N int // The number of iterations.
|
|
T time.Duration // The total time taken.
|
|
Bytes int64 // Bytes processed in one iteration.
|
|
}
|
|
|
|
// Benchmark benchmarks a single function. Useful for creating ...
|
|
func Benchmark(f func(b *B)) BenchmarkResult
|
|
|
|
//
|
|
func (r BenchmarkResult) NsPerOp() int64
|
|
|
|
//
|
|
func (r BenchmarkResult) String() string
|
|
|
|
//
|
|
func (r BenchmarkResult) mbPerSec() float64
|
|
|
|
// An internal type but exported because it is cross-package; part ...
|
|
type InternalBenchmark struct {
|
|
Name string
|
|
F func(b *B)
|
|
}
|
|
|
|
//
|
|
type InternalExample struct {
|
|
Name string
|
|
F func()
|
|
Output string
|
|
}
|
|
|
|
// An internal type but exported because it is cross-package; part ...
|
|
type InternalTest struct {
|
|
Name string
|
|
F func(*T)
|
|
}
|
|
|
|
// T is a type passed to Test functions to manage test state and ...
|
|
type T struct {
|
|
common
|
|
name string // Name of test.
|
|
startParallel chan bool // Parallel tests will wait on this.
|
|
}
|
|
|
|
// Error is equivalent to Log() followed by Fail().
|
|
func (c *T) Error(args ...interface{})
|
|
|
|
// Errorf is equivalent to Logf() followed by Fail().
|
|
func (c *T) Errorf(format string, args ...interface{})
|
|
|
|
// Fail marks the function as having failed but continues ...
|
|
func (c *T) Fail()
|
|
|
|
// FailNow marks the function as having failed and stops its ...
|
|
func (c *T) FailNow()
|
|
|
|
// Failed reports whether the function has failed.
|
|
func (c *T) Failed() bool
|
|
|
|
// Fatal is equivalent to Log() followed by FailNow().
|
|
func (c *T) Fatal(args ...interface{})
|
|
|
|
// Fatalf is equivalent to Logf() followed by FailNow().
|
|
func (c *T) Fatalf(format string, args ...interface{})
|
|
|
|
// Log formats its arguments using default formatting, analogous ...
|
|
func (c *T) Log(args ...interface{})
|
|
|
|
// Logf formats its arguments according to the format, analogous ...
|
|
func (c *T) Logf(format string, args ...interface{})
|
|
|
|
// Parallel signals that this test is to be run in parallel with ...
|
|
func (t *T) Parallel()
|
|
|
|
// log generates the output. It's always at the same stack depth.
|
|
func (c *T) log(s string)
|
|
|
|
//
|
|
func (t *T) report()
|
|
|
|
// common holds the elements common between T and B and captures ...
|
|
type common struct {
|
|
output []byte // Output generated by test or benchmark.
|
|
failed bool // Test or benchmark has failed.
|
|
start time.Time // Time test or benchmark started
|
|
duration time.Duration
|
|
self interface{} // To be sent on signal channel when done.
|
|
signal chan interface{} // Output for serial tests.
|
|
}
|
|
|
|
// Error is equivalent to Log() followed by Fail().
|
|
func (c *common) Error(args ...interface{})
|
|
|
|
// Errorf is equivalent to Logf() followed by Fail().
|
|
func (c *common) Errorf(format string, args ...interface{})
|
|
|
|
// Fail marks the function as having failed but continues ...
|
|
func (c *common) Fail()
|
|
|
|
// FailNow marks the function as having failed and stops its ...
|
|
func (c *common) FailNow()
|
|
|
|
// Failed reports whether the function has failed.
|
|
func (c *common) Failed() bool
|
|
|
|
// Fatal is equivalent to Log() followed by FailNow().
|
|
func (c *common) Fatal(args ...interface{})
|
|
|
|
// Fatalf is equivalent to Logf() followed by FailNow().
|
|
func (c *common) Fatalf(format string, args ...interface{})
|
|
|
|
// Log formats its arguments using default formatting, analogous ...
|
|
func (c *common) Log(args ...interface{})
|
|
|
|
// Logf formats its arguments according to the format, analogous ...
|
|
func (c *common) Logf(format string, args ...interface{})
|
|
|
|
// log generates the output. It's always at the same stack depth.
|
|
func (c *common) log(s string)
|
|
|