Subversion Repositories openrisc

// 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 "gotest" 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.Float64("test.benchtime", 1, "approximate run time for each benchmark, in seconds")

        // 
        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 returns 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 returns 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 returns 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)