summaryrefslogtreecommitdiff
path: root/src/pkg/testing
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/testing')
-rw-r--r--src/pkg/testing/allocs.go45
-rw-r--r--src/pkg/testing/benchmark.go444
-rw-r--r--src/pkg/testing/benchmark_test.go111
-rw-r--r--src/pkg/testing/cover.go86
-rw-r--r--src/pkg/testing/example.go100
-rw-r--r--src/pkg/testing/export_test.go10
-rw-r--r--src/pkg/testing/iotest/logger.go54
-rw-r--r--src/pkg/testing/iotest/reader.go88
-rw-r--r--src/pkg/testing/iotest/writer.go35
-rw-r--r--src/pkg/testing/quick/quick.go358
-rw-r--r--src/pkg/testing/quick/quick_test.go249
-rw-r--r--src/pkg/testing/testing.go657
12 files changed, 0 insertions, 2237 deletions
diff --git a/src/pkg/testing/allocs.go b/src/pkg/testing/allocs.go
deleted file mode 100644
index 9ec47bd46..000000000
--- a/src/pkg/testing/allocs.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package testing
-
-import (
- "runtime"
-)
-
-// AllocsPerRun returns the average number of allocations during calls to f.
-// Although the return value has type float64, it will always be an integral value.
-//
-// To compute the number of allocations, the function will first be run once as
-// a warm-up. The average number of allocations over the specified number of
-// runs will then be measured and returned.
-//
-// AllocsPerRun sets GOMAXPROCS to 1 during its measurement and will restore
-// it before returning.
-func AllocsPerRun(runs int, f func()) (avg float64) {
- defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))
-
- // Warm up the function
- f()
-
- // Measure the starting statistics
- var memstats runtime.MemStats
- runtime.ReadMemStats(&memstats)
- mallocs := 0 - memstats.Mallocs
-
- // Run the function the specified number of times
- for i := 0; i < runs; i++ {
- f()
- }
-
- // Read the final statistics
- runtime.ReadMemStats(&memstats)
- mallocs += memstats.Mallocs
-
- // Average the mallocs over the runs (not counting the warm-up).
- // We are forced to return a float64 because the API is silly, but do
- // the division as integers so we can ask if AllocsPerRun()==1
- // instead of AllocsPerRun()<2.
- return float64(mallocs / uint64(runs))
-}
diff --git a/src/pkg/testing/benchmark.go b/src/pkg/testing/benchmark.go
deleted file mode 100644
index 1fbf5c861..000000000
--- a/src/pkg/testing/benchmark.go
+++ /dev/null
@@ -1,444 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package testing
-
-import (
- "flag"
- "fmt"
- "os"
- "runtime"
- "sync"
- "sync/atomic"
- "time"
-)
-
-var matchBenchmarks = flag.String("test.bench", "", "regular expression to select benchmarks to run")
-var benchTime = flag.Duration("test.benchtime", 1*time.Second, "approximate run time for each benchmark")
-var benchmarkMemory = flag.Bool("test.benchmem", false, "print memory allocations for benchmarks")
-
-// Global lock to ensure only one benchmark runs at a time.
-var benchmarkLock sync.Mutex
-
-// Used for every benchmark for measuring memory.
-var memStats runtime.MemStats
-
-// An internal type but exported because it is cross-package; part of the implementation
-// of the "go test" command.
-type InternalBenchmark struct {
- Name string
- F func(b *B)
-}
-
-// B is a type passed to Benchmark functions to manage benchmark
-// timing and to specify the number of iterations to run.
-type B struct {
- common
- N int
- previousN int // number of iterations in the previous run
- previousDuration time.Duration // total duration of the previous run
- benchmark InternalBenchmark
- bytes int64
- timerOn bool
- showAllocResult bool
- result BenchmarkResult
- parallelism int // RunParallel creates parallelism*GOMAXPROCS goroutines
- // The initial states of memStats.Mallocs and memStats.TotalAlloc.
- startAllocs uint64
- startBytes uint64
- // The net total of this test after being run.
- netAllocs uint64
- netBytes uint64
-}
-
-// StartTimer starts timing a test. This function is called automatically
-// before a benchmark starts, but it can also used to resume timing after
-// a call to StopTimer.
-func (b *B) StartTimer() {
- if !b.timerOn {
- runtime.ReadMemStats(&memStats)
- b.startAllocs = memStats.Mallocs
- b.startBytes = memStats.TotalAlloc
- b.start = time.Now()
- b.timerOn = true
- }
-}
-
-// StopTimer stops timing a test. This can be used to pause the timer
-// while performing complex initialization that you don't
-// want to measure.
-func (b *B) StopTimer() {
- if b.timerOn {
- b.duration += time.Now().Sub(b.start)
- runtime.ReadMemStats(&memStats)
- b.netAllocs += memStats.Mallocs - b.startAllocs
- b.netBytes += memStats.TotalAlloc - b.startBytes
- b.timerOn = false
- }
-}
-
-// ResetTimer zeros the elapsed benchmark time and memory allocation counters.
-// It does not affect whether the timer is running.
-func (b *B) ResetTimer() {
- if b.timerOn {
- runtime.ReadMemStats(&memStats)
- b.startAllocs = memStats.Mallocs
- b.startBytes = memStats.TotalAlloc
- b.start = time.Now()
- }
- b.duration = 0
- b.netAllocs = 0
- b.netBytes = 0
-}
-
-// 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 *B) SetBytes(n int64) { b.bytes = n }
-
-// ReportAllocs enables malloc statistics for this benchmark.
-// It is equivalent to setting -test.benchmem, but it only affects the
-// benchmark function that calls ReportAllocs.
-func (b *B) ReportAllocs() {
- b.showAllocResult = true
-}
-
-func (b *B) nsPerOp() int64 {
- if b.N <= 0 {
- return 0
- }
- return b.duration.Nanoseconds() / int64(b.N)
-}
-
-// runN runs a single benchmark for the specified number of iterations.
-func (b *B) runN(n int) {
- benchmarkLock.Lock()
- defer benchmarkLock.Unlock()
- // Try to get a comparable environment for each run
- // by clearing garbage from previous runs.
- runtime.GC()
- b.N = n
- b.parallelism = 1
- b.ResetTimer()
- b.StartTimer()
- b.benchmark.F(b)
- b.StopTimer()
- b.previousN = n
- b.previousDuration = b.duration
-}
-
-func min(x, y int) int {
- if x > y {
- return y
- }
- return x
-}
-
-func max(x, y int) int {
- if x < y {
- return y
- }
- return x
-}
-
-// roundDown10 rounds a number down to the nearest power of 10.
-func roundDown10(n int) int {
- var tens = 0
- // tens = floor(log_10(n))
- for n >= 10 {
- n = n / 10
- tens++
- }
- // result = 10^tens
- result := 1
- for i := 0; i < tens; i++ {
- result *= 10
- }
- return result
-}
-
-// roundUp rounds x up to a number of the form [1eX, 2eX, 5eX].
-func roundUp(n int) int {
- base := roundDown10(n)
- switch {
- case n <= base:
- return base
- case n <= (2 * base):
- return 2 * base
- case n <= (5 * base):
- return 5 * base
- default:
- return 10 * base
- }
-}
-
-// run times the benchmark function in a separate goroutine.
-func (b *B) run() BenchmarkResult {
- go b.launch()
- <-b.signal
- return b.result
-}
-
-// launch launches the benchmark function. It gradually increases the number
-// of benchmark iterations until the benchmark runs for a second in order
-// to get a reasonable measurement. It prints timing information in this form
-// testing.BenchmarkHello 100000 19 ns/op
-// launch is run by the fun function as a separate goroutine.
-func (b *B) launch() {
- // Run the benchmark for a single iteration in case it's expensive.
- n := 1
-
- // Signal that we're done whether we return normally
- // or by FailNow's runtime.Goexit.
- defer func() {
- b.signal <- b
- }()
-
- b.runN(n)
- // Run the benchmark for at least the specified amount of time.
- d := *benchTime
- for !b.failed && b.duration < d && n < 1e9 {
- last := n
- // Predict iterations/sec.
- if b.nsPerOp() == 0 {
- n = 1e9
- } else {
- n = int(d.Nanoseconds() / b.nsPerOp())
- }
- // Run more iterations than we think we'll need for a second (1.5x).
- // Don't grow too fast in case we had timing errors previously.
- // Be sure to run at least one more than last time.
- n = max(min(n+n/2, 100*last), last+1)
- // Round up to something easy to read.
- n = roundUp(n)
- b.runN(n)
- }
- b.result = BenchmarkResult{b.N, b.duration, b.bytes, b.netAllocs, b.netBytes}
-}
-
-// 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.
- MemAllocs uint64 // The total number of memory allocations.
- MemBytes uint64 // The total number of bytes allocated.
-}
-
-func (r BenchmarkResult) NsPerOp() int64 {
- if r.N <= 0 {
- return 0
- }
- return r.T.Nanoseconds() / int64(r.N)
-}
-
-func (r BenchmarkResult) mbPerSec() float64 {
- if r.Bytes <= 0 || r.T <= 0 || r.N <= 0 {
- return 0
- }
- return (float64(r.Bytes) * float64(r.N) / 1e6) / r.T.Seconds()
-}
-
-func (r BenchmarkResult) AllocsPerOp() int64 {
- if r.N <= 0 {
- return 0
- }
- return int64(r.MemAllocs) / int64(r.N)
-}
-
-func (r BenchmarkResult) AllocedBytesPerOp() int64 {
- if r.N <= 0 {
- return 0
- }
- return int64(r.MemBytes) / int64(r.N)
-}
-
-func (r BenchmarkResult) String() string {
- mbs := r.mbPerSec()
- mb := ""
- if mbs != 0 {
- mb = fmt.Sprintf("\t%7.2f MB/s", mbs)
- }
- nsop := r.NsPerOp()
- ns := fmt.Sprintf("%10d ns/op", nsop)
- if r.N > 0 && nsop < 100 {
- // The format specifiers here make sure that
- // the ones digits line up for all three possible formats.
- if nsop < 10 {
- ns = fmt.Sprintf("%13.2f ns/op", float64(r.T.Nanoseconds())/float64(r.N))
- } else {
- ns = fmt.Sprintf("%12.1f ns/op", float64(r.T.Nanoseconds())/float64(r.N))
- }
- }
- return fmt.Sprintf("%8d\t%s%s", r.N, ns, mb)
-}
-
-func (r BenchmarkResult) MemString() string {
- return fmt.Sprintf("%8d B/op\t%8d allocs/op",
- r.AllocedBytesPerOp(), r.AllocsPerOp())
-}
-
-// An internal function but exported because it is cross-package; part of the implementation
-// of the "go test" command.
-func RunBenchmarks(matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark) {
- // If no flag was specified, don't run benchmarks.
- if len(*matchBenchmarks) == 0 {
- return
- }
- for _, Benchmark := range benchmarks {
- matched, err := matchString(*matchBenchmarks, Benchmark.Name)
- if err != nil {
- fmt.Fprintf(os.Stderr, "testing: invalid regexp for -test.bench: %s\n", err)
- os.Exit(1)
- }
- if !matched {
- continue
- }
- for _, procs := range cpuList {
- runtime.GOMAXPROCS(procs)
- b := &B{
- common: common{
- signal: make(chan interface{}),
- },
- benchmark: Benchmark,
- }
- benchName := Benchmark.Name
- if procs != 1 {
- benchName = fmt.Sprintf("%s-%d", Benchmark.Name, procs)
- }
- fmt.Printf("%s\t", benchName)
- r := b.run()
- if b.failed {
- // The output could be very long here, but probably isn't.
- // We print it all, regardless, because we don't want to trim the reason
- // the benchmark failed.
- fmt.Printf("--- FAIL: %s\n%s", benchName, b.output)
- continue
- }
- results := r.String()
- if *benchmarkMemory || b.showAllocResult {
- results += "\t" + r.MemString()
- }
- fmt.Println(results)
- // Unlike with tests, we ignore the -chatty flag and always print output for
- // benchmarks since the output generation time will skew the results.
- if len(b.output) > 0 {
- b.trimOutput()
- fmt.Printf("--- BENCH: %s\n%s", benchName, b.output)
- }
- if p := runtime.GOMAXPROCS(-1); p != procs {
- fmt.Fprintf(os.Stderr, "testing: %s left GOMAXPROCS set to %d\n", benchName, p)
- }
- }
- }
-}
-
-// trimOutput shortens the output from a benchmark, which can be very long.
-func (b *B) trimOutput() {
- // The output is likely to appear multiple times because the benchmark
- // is run multiple times, but at least it will be seen. This is not a big deal
- // because benchmarks rarely print, but just in case, we trim it if it's too long.
- const maxNewlines = 10
- for nlCount, j := 0, 0; j < len(b.output); j++ {
- if b.output[j] == '\n' {
- nlCount++
- if nlCount >= maxNewlines {
- b.output = append(b.output[:j], "\n\t... [output truncated]\n"...)
- break
- }
- }
- }
-}
-
-// A PB is used by RunParallel for running parallel benchmarks.
-type PB struct {
- globalN *uint64 // shared between all worker goroutines iteration counter
- grain uint64 // acquire that many iterations from globalN at once
- cache uint64 // local cache of acquired iterations
- bN uint64 // total number of iterations to execute (b.N)
-}
-
-// Next reports whether there are more iterations to execute.
-func (pb *PB) Next() bool {
- if pb.cache == 0 {
- n := atomic.AddUint64(pb.globalN, pb.grain)
- if n <= pb.bN {
- pb.cache = pb.grain
- } else if n < pb.bN+pb.grain {
- pb.cache = pb.bN + pb.grain - n
- } else {
- return false
- }
- }
- pb.cache--
- return true
-}
-
-// 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 for
-// non-CPU-bound benchmarks, call 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 any
-// goroutine-local state and then iterate until pb.Next returns false.
-// It should not use the StartTimer, StopTimer, or ResetTimer functions,
-// because they have global effect.
-func (b *B) RunParallel(body func(*PB)) {
- // Calculate grain size as number of iterations that take ~100µs.
- // 100µs is enough to amortize the overhead and provide sufficient
- // dynamic load balancing.
- grain := uint64(0)
- if b.previousN > 0 && b.previousDuration > 0 {
- grain = 1e5 * uint64(b.previousN) / uint64(b.previousDuration)
- }
- if grain < 1 {
- grain = 1
- }
- // We expect the inner loop and function call to take at least 10ns,
- // so do not do more than 100µs/10ns=1e4 iterations.
- if grain > 1e4 {
- grain = 1e4
- }
-
- n := uint64(0)
- numProcs := b.parallelism * runtime.GOMAXPROCS(0)
- var wg sync.WaitGroup
- wg.Add(numProcs)
- for p := 0; p < numProcs; p++ {
- go func() {
- defer wg.Done()
- pb := &PB{
- globalN: &n,
- grain: grain,
- bN: uint64(b.N),
- }
- body(pb)
- }()
- }
- wg.Wait()
- if n <= uint64(b.N) && !b.Failed() {
- b.Fatal("RunParallel: body exited without pb.Next() == false")
- }
-}
-
-// SetParallelism sets the number of goroutines used by 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 *B) SetParallelism(p int) {
- if p >= 1 {
- b.parallelism = p
- }
-}
-
-// Benchmark benchmarks a single function. Useful for creating
-// custom benchmarks that do not use the "go test" command.
-func Benchmark(f func(b *B)) BenchmarkResult {
- b := &B{
- common: common{
- signal: make(chan interface{}),
- },
- benchmark: InternalBenchmark{"", f},
- }
- return b.run()
-}
diff --git a/src/pkg/testing/benchmark_test.go b/src/pkg/testing/benchmark_test.go
deleted file mode 100644
index f7ea64e7f..000000000
--- a/src/pkg/testing/benchmark_test.go
+++ /dev/null
@@ -1,111 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package testing_test
-
-import (
- "bytes"
- "runtime"
- "sync/atomic"
- "testing"
- "text/template"
-)
-
-var roundDownTests = []struct {
- v, expected int
-}{
- {1, 1},
- {9, 1},
- {10, 10},
- {11, 10},
- {100, 100},
- {101, 100},
- {999, 100},
- {1000, 1000},
- {1001, 1000},
-}
-
-func TestRoundDown10(t *testing.T) {
- for _, tt := range roundDownTests {
- actual := testing.RoundDown10(tt.v)
- if tt.expected != actual {
- t.Errorf("roundDown10(%d): expected %d, actual %d", tt.v, tt.expected, actual)
- }
- }
-}
-
-var roundUpTests = []struct {
- v, expected int
-}{
- {0, 1},
- {1, 1},
- {2, 2},
- {5, 5},
- {9, 10},
- {999, 1000},
- {1000, 1000},
- {1400, 2000},
- {1700, 2000},
- {4999, 5000},
- {5000, 5000},
- {5001, 10000},
-}
-
-func TestRoundUp(t *testing.T) {
- for _, tt := range roundUpTests {
- actual := testing.RoundUp(tt.v)
- if tt.expected != actual {
- t.Errorf("roundUp(%d): expected %d, actual %d", tt.v, tt.expected, actual)
- }
- }
-}
-
-func TestRunParallel(t *testing.T) {
- testing.Benchmark(func(b *testing.B) {
- procs := uint32(0)
- iters := uint64(0)
- b.SetParallelism(3)
- b.RunParallel(func(pb *testing.PB) {
- atomic.AddUint32(&procs, 1)
- for pb.Next() {
- atomic.AddUint64(&iters, 1)
- }
- })
- if want := uint32(3 * runtime.GOMAXPROCS(0)); procs != want {
- t.Errorf("got %v procs, want %v", procs, want)
- }
- if iters != uint64(b.N) {
- t.Errorf("got %v iters, want %v", iters, b.N)
- }
- })
-}
-
-func TestRunParallelFail(t *testing.T) {
- testing.Benchmark(func(b *testing.B) {
- b.RunParallel(func(pb *testing.PB) {
- // The function must be able to log/abort
- // w/o crashing/deadlocking the whole benchmark.
- b.Log("log")
- b.Error("error")
- })
- })
-}
-
-func ExampleB_RunParallel() {
- // 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.Buffer
- for pb.Next() {
- // The loop body is executed b.N times total across all goroutines.
- buf.Reset()
- templ.Execute(&buf, "World")
- }
- })
- })
-}
diff --git a/src/pkg/testing/cover.go b/src/pkg/testing/cover.go
deleted file mode 100644
index dd29364d8..000000000
--- a/src/pkg/testing/cover.go
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Support for test coverage.
-
-package testing
-
-import (
- "fmt"
- "os"
-)
-
-// CoverBlock records the coverage data for a single basic block.
-// NOTE: This struct is internal to the testing infrastructure and may change.
-// It is not covered (yet) by the Go 1 compatibility guidelines.
-type CoverBlock struct {
- Line0 uint32
- Col0 uint16
- Line1 uint32
- Col1 uint16
- Stmts uint16
-}
-
-var cover Cover
-
-// Cover records information about test coverage checking.
-// NOTE: This struct is internal to the testing infrastructure and may change.
-// It is not covered (yet) by the Go 1 compatibility guidelines.
-type Cover struct {
- Mode string
- Counters map[string][]uint32
- Blocks map[string][]CoverBlock
- CoveredPackages string
-}
-
-// RegisterCover records the coverage data accumulators for the tests.
-// NOTE: This function is internal to the testing infrastructure and may change.
-// It is not covered (yet) by the Go 1 compatibility guidelines.
-func RegisterCover(c Cover) {
- cover = c
-}
-
-// mustBeNil checks the error and, if present, reports it and exits.
-func mustBeNil(err error) {
- if err != nil {
- fmt.Fprintf(os.Stderr, "testing: %s\n", err)
- os.Exit(2)
- }
-}
-
-// coverReport reports the coverage percentage and writes a coverage profile if requested.
-func coverReport() {
- var f *os.File
- var err error
- if *coverProfile != "" {
- f, err = os.Create(toOutputDir(*coverProfile))
- mustBeNil(err)
- fmt.Fprintf(f, "mode: %s\n", cover.Mode)
- defer func() { mustBeNil(f.Close()) }()
- }
-
- var active, total int64
- for name, counts := range cover.Counters {
- blocks := cover.Blocks[name]
- for i, count := range counts {
- stmts := int64(blocks[i].Stmts)
- total += stmts
- if count > 0 {
- active += stmts
- }
- if f != nil {
- _, err := fmt.Fprintf(f, "%s:%d.%d,%d.%d %d %d\n", name,
- blocks[i].Line0, blocks[i].Col0,
- blocks[i].Line1, blocks[i].Col1,
- stmts,
- count)
- mustBeNil(err)
- }
- }
- }
- if total == 0 {
- total = 1
- }
- fmt.Printf("coverage: %.1f%% of statements%s\n", 100*float64(active)/float64(total), cover.CoveredPackages)
-}
diff --git a/src/pkg/testing/example.go b/src/pkg/testing/example.go
deleted file mode 100644
index 828c2d3ed..000000000
--- a/src/pkg/testing/example.go
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package testing
-
-import (
- "bytes"
- "fmt"
- "io"
- "os"
- "strings"
- "time"
-)
-
-type InternalExample struct {
- Name string
- F func()
- Output string
-}
-
-func RunExamples(matchString func(pat, str string) (bool, error), examples []InternalExample) (ok bool) {
- ok = true
-
- var eg InternalExample
-
- for _, eg = range examples {
- matched, err := matchString(*match, eg.Name)
- if err != nil {
- fmt.Fprintf(os.Stderr, "testing: invalid regexp for -test.run: %s\n", err)
- os.Exit(1)
- }
- if !matched {
- continue
- }
- if !runExample(eg) {
- ok = false
- }
- }
-
- return
-}
-
-func runExample(eg InternalExample) (ok bool) {
- if *chatty {
- fmt.Printf("=== RUN: %s\n", eg.Name)
- }
-
- // Capture stdout.
- stdout := os.Stdout
- r, w, err := os.Pipe()
- if err != nil {
- fmt.Fprintln(os.Stderr, err)
- os.Exit(1)
- }
- os.Stdout = w
- outC := make(chan string)
- go func() {
- buf := new(bytes.Buffer)
- _, err := io.Copy(buf, r)
- r.Close()
- if err != nil {
- fmt.Fprintf(os.Stderr, "testing: copying pipe: %v\n", err)
- os.Exit(1)
- }
- outC <- buf.String()
- }()
-
- start := time.Now()
- ok = true
-
- // Clean up in a deferred call so we can recover if the example panics.
- defer func() {
- d := time.Now().Sub(start)
-
- // Close pipe, restore stdout, get output.
- w.Close()
- os.Stdout = stdout
- out := <-outC
-
- var fail string
- err := recover()
- if g, e := strings.TrimSpace(out), strings.TrimSpace(eg.Output); g != e && err == nil {
- fail = fmt.Sprintf("got:\n%s\nwant:\n%s\n", g, e)
- }
- if fail != "" || err != nil {
- fmt.Printf("--- FAIL: %s (%v)\n%s", eg.Name, d, fail)
- ok = false
- } else if *chatty {
- fmt.Printf("--- PASS: %s (%v)\n", eg.Name, d)
- }
- if err != nil {
- panic(err)
- }
- }()
-
- // Run example.
- eg.F()
- return
-}
diff --git a/src/pkg/testing/export_test.go b/src/pkg/testing/export_test.go
deleted file mode 100644
index 89781b439..000000000
--- a/src/pkg/testing/export_test.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package testing
-
-var (
- RoundDown10 = roundDown10
- RoundUp = roundUp
-)
diff --git a/src/pkg/testing/iotest/logger.go b/src/pkg/testing/iotest/logger.go
deleted file mode 100644
index 1475d9b0c..000000000
--- a/src/pkg/testing/iotest/logger.go
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package iotest
-
-import (
- "io"
- "log"
-)
-
-type writeLogger struct {
- prefix string
- w io.Writer
-}
-
-func (l *writeLogger) Write(p []byte) (n int, err error) {
- n, err = l.w.Write(p)
- if err != nil {
- log.Printf("%s %x: %v", l.prefix, p[0:n], err)
- } else {
- log.Printf("%s %x", l.prefix, p[0:n])
- }
- return
-}
-
-// NewWriteLogger returns a writer that behaves like w except
-// that it logs (using log.Printf) each write to standard error,
-// printing the prefix and the hexadecimal data written.
-func NewWriteLogger(prefix string, w io.Writer) io.Writer {
- return &writeLogger{prefix, w}
-}
-
-type readLogger struct {
- prefix string
- r io.Reader
-}
-
-func (l *readLogger) Read(p []byte) (n int, err error) {
- n, err = l.r.Read(p)
- if err != nil {
- log.Printf("%s %x: %v", l.prefix, p[0:n], err)
- } else {
- log.Printf("%s %x", l.prefix, p[0:n])
- }
- return
-}
-
-// NewReadLogger returns a reader that behaves like r except
-// that it logs (using log.Print) each read to standard error,
-// printing the prefix and the hexadecimal data written.
-func NewReadLogger(prefix string, r io.Reader) io.Reader {
- return &readLogger{prefix, r}
-}
diff --git a/src/pkg/testing/iotest/reader.go b/src/pkg/testing/iotest/reader.go
deleted file mode 100644
index a5bccca90..000000000
--- a/src/pkg/testing/iotest/reader.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package iotest implements Readers and Writers useful mainly for testing.
-package iotest
-
-import (
- "errors"
- "io"
-)
-
-// OneByteReader returns a Reader that implements
-// each non-empty Read by reading one byte from r.
-func OneByteReader(r io.Reader) io.Reader { return &oneByteReader{r} }
-
-type oneByteReader struct {
- r io.Reader
-}
-
-func (r *oneByteReader) Read(p []byte) (int, error) {
- if len(p) == 0 {
- return 0, nil
- }
- return r.r.Read(p[0:1])
-}
-
-// HalfReader returns a Reader that implements Read
-// by reading half as many requested bytes from r.
-func HalfReader(r io.Reader) io.Reader { return &halfReader{r} }
-
-type halfReader struct {
- r io.Reader
-}
-
-func (r *halfReader) Read(p []byte) (int, error) {
- return r.r.Read(p[0 : (len(p)+1)/2])
-}
-
-// DataErrReader changes the way errors are handled by a Reader. Normally, a
-// Reader returns an error (typically EOF) from the first Read call after the
-// last piece of data is read. DataErrReader wraps a Reader and changes its
-// behavior so the final error is returned along with the final data, instead
-// of in the first call after the final data.
-func DataErrReader(r io.Reader) io.Reader { return &dataErrReader{r, nil, make([]byte, 1024)} }
-
-type dataErrReader struct {
- r io.Reader
- unread []byte
- data []byte
-}
-
-func (r *dataErrReader) Read(p []byte) (n int, err error) {
- // loop because first call needs two reads:
- // one to get data and a second to look for an error.
- for {
- if len(r.unread) == 0 {
- n1, err1 := r.r.Read(r.data)
- r.unread = r.data[0:n1]
- err = err1
- }
- if n > 0 || err != nil {
- break
- }
- n = copy(p, r.unread)
- r.unread = r.unread[n:]
- }
- return
-}
-
-var ErrTimeout = errors.New("timeout")
-
-// TimeoutReader returns ErrTimeout on the second read
-// with no data. Subsequent calls to read succeed.
-func TimeoutReader(r io.Reader) io.Reader { return &timeoutReader{r, 0} }
-
-type timeoutReader struct {
- r io.Reader
- count int
-}
-
-func (r *timeoutReader) Read(p []byte) (int, error) {
- r.count++
- if r.count == 2 {
- return 0, ErrTimeout
- }
- return r.r.Read(p)
-}
diff --git a/src/pkg/testing/iotest/writer.go b/src/pkg/testing/iotest/writer.go
deleted file mode 100644
index af61ab858..000000000
--- a/src/pkg/testing/iotest/writer.go
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package iotest
-
-import "io"
-
-// TruncateWriter returns a Writer that writes to w
-// but stops silently after n bytes.
-func TruncateWriter(w io.Writer, n int64) io.Writer {
- return &truncateWriter{w, n}
-}
-
-type truncateWriter struct {
- w io.Writer
- n int64
-}
-
-func (t *truncateWriter) Write(p []byte) (n int, err error) {
- if t.n <= 0 {
- return len(p), nil
- }
- // real write
- n = len(p)
- if int64(n) > t.n {
- n = int(t.n)
- }
- n, err = t.w.Write(p[0:n])
- t.n -= int64(n)
- if err == nil {
- n = len(p)
- }
- return
-}
diff --git a/src/pkg/testing/quick/quick.go b/src/pkg/testing/quick/quick.go
deleted file mode 100644
index bc79cc329..000000000
--- a/src/pkg/testing/quick/quick.go
+++ /dev/null
@@ -1,358 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package quick implements utility functions to help with black box testing.
-package quick
-
-import (
- "flag"
- "fmt"
- "math"
- "math/rand"
- "reflect"
- "strings"
-)
-
-var defaultMaxCount *int = flag.Int("quickchecks", 100, "The default number of iterations for each check")
-
-// A Generator can generate random values of its own type.
-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
-}
-
-// randFloat32 generates a random float taking the full range of a float32.
-func randFloat32(rand *rand.Rand) float32 {
- f := rand.Float64() * math.MaxFloat32
- if rand.Int()&1 == 1 {
- f = -f
- }
- return float32(f)
-}
-
-// randFloat64 generates a random float taking the full range of a float64.
-func randFloat64(rand *rand.Rand) float64 {
- f := rand.Float64() * math.MaxFloat64
- if rand.Int()&1 == 1 {
- f = -f
- }
- return f
-}
-
-// randInt64 returns a random integer taking half the range of an int64.
-func randInt64(rand *rand.Rand) int64 { return rand.Int63() - 1<<62 }
-
-// complexSize is the maximum length of arbitrary values that contain other
-// values.
-const complexSize = 50
-
-// Value returns an arbitrary value of the given type.
-// If the type implements the Generator interface, that will be used.
-// Note: To create arbitrary values for structs, all the fields must be exported.
-func Value(t reflect.Type, rand *rand.Rand) (value reflect.Value, ok bool) {
- if m, ok := reflect.Zero(t).Interface().(Generator); ok {
- return m.Generate(rand, complexSize), true
- }
-
- v := reflect.New(t).Elem()
- switch concrete := t; concrete.Kind() {
- case reflect.Bool:
- v.SetBool(rand.Int()&1 == 0)
- case reflect.Float32:
- v.SetFloat(float64(randFloat32(rand)))
- case reflect.Float64:
- v.SetFloat(randFloat64(rand))
- case reflect.Complex64:
- v.SetComplex(complex(float64(randFloat32(rand)), float64(randFloat32(rand))))
- case reflect.Complex128:
- v.SetComplex(complex(randFloat64(rand), randFloat64(rand)))
- case reflect.Int16:
- v.SetInt(randInt64(rand))
- case reflect.Int32:
- v.SetInt(randInt64(rand))
- case reflect.Int64:
- v.SetInt(randInt64(rand))
- case reflect.Int8:
- v.SetInt(randInt64(rand))
- case reflect.Int:
- v.SetInt(randInt64(rand))
- case reflect.Uint16:
- v.SetUint(uint64(randInt64(rand)))
- case reflect.Uint32:
- v.SetUint(uint64(randInt64(rand)))
- case reflect.Uint64:
- v.SetUint(uint64(randInt64(rand)))
- case reflect.Uint8:
- v.SetUint(uint64(randInt64(rand)))
- case reflect.Uint:
- v.SetUint(uint64(randInt64(rand)))
- case reflect.Uintptr:
- v.SetUint(uint64(randInt64(rand)))
- case reflect.Map:
- numElems := rand.Intn(complexSize)
- v.Set(reflect.MakeMap(concrete))
- for i := 0; i < numElems; i++ {
- key, ok1 := Value(concrete.Key(), rand)
- value, ok2 := Value(concrete.Elem(), rand)
- if !ok1 || !ok2 {
- return reflect.Value{}, false
- }
- v.SetMapIndex(key, value)
- }
- case reflect.Ptr:
- elem, ok := Value(concrete.Elem(), rand)
- if !ok {
- return reflect.Value{}, false
- }
- v.Set(reflect.New(concrete.Elem()))
- v.Elem().Set(elem)
- case reflect.Slice:
- numElems := rand.Intn(complexSize)
- v.Set(reflect.MakeSlice(concrete, numElems, numElems))
- for i := 0; i < numElems; i++ {
- elem, ok := Value(concrete.Elem(), rand)
- if !ok {
- return reflect.Value{}, false
- }
- v.Index(i).Set(elem)
- }
- case reflect.String:
- numChars := rand.Intn(complexSize)
- codePoints := make([]rune, numChars)
- for i := 0; i < numChars; i++ {
- codePoints[i] = rune(rand.Intn(0x10ffff))
- }
- v.SetString(string(codePoints))
- case reflect.Struct:
- for i := 0; i < v.NumField(); i++ {
- elem, ok := Value(concrete.Field(i).Type, rand)
- if !ok {
- return reflect.Value{}, false
- }
- v.Field(i).Set(elem)
- }
- default:
- return reflect.Value{}, false
- }
-
- return v, true
-}
-
-// A Config structure contains options for running a test.
-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 Values function is used
- // to generate them.
- Values func([]reflect.Value, *rand.Rand)
-}
-
-var defaultConfig Config
-
-// getRand returns the *rand.Rand to use for a given Config.
-func (c *Config) getRand() *rand.Rand {
- if c.Rand == nil {
- return rand.New(rand.NewSource(0))
- }
- return c.Rand
-}
-
-// getMaxCount returns the maximum number of iterations to run for a given
-// Config.
-func (c *Config) getMaxCount() (maxCount int) {
- maxCount = c.MaxCount
- if maxCount == 0 {
- if c.MaxCountScale != 0 {
- maxCount = int(c.MaxCountScale * float64(*defaultMaxCount))
- } else {
- maxCount = *defaultMaxCount
- }
- }
-
- return
-}
-
-// A SetupError is the result of an error in the way that check is being
-// used, independent of the functions being tested.
-type SetupError string
-
-func (s SetupError) Error() string { return string(s) }
-
-// A CheckError is the result of Check finding an error.
-type CheckError struct {
- Count int
- In []interface{}
-}
-
-func (s *CheckError) Error() string {
- return fmt.Sprintf("#%d: failed on input %s", s.Count, toString(s.In))
-}
-
-// A CheckEqualError is the result CheckEqual finding an error.
-type CheckEqualError struct {
- CheckError
- Out1 []interface{}
- Out2 []interface{}
-}
-
-func (s *CheckEqualError) Error() string {
- return fmt.Sprintf("#%d: failed on input %s. Output 1: %s. Output 2: %s", s.Count, toString(s.In), toString(s.Out1), toString(s.Out2))
-}
-
-// Check looks for an input to f, any function that returns bool,
-// such that f returns false. It calls f repeatedly, with arbitrary
-// values for each argument. If f returns false on a given input,
-// Check returns that input as a *CheckError.
-// For example:
-//
-// 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 Check(function interface{}, config *Config) (err error) {
- if config == nil {
- config = &defaultConfig
- }
-
- f, fType, ok := functionAndType(function)
- if !ok {
- err = SetupError("argument is not a function")
- return
- }
-
- if fType.NumOut() != 1 {
- err = SetupError("function returns more than one value.")
- return
- }
- if fType.Out(0).Kind() != reflect.Bool {
- err = SetupError("function does not return a bool")
- return
- }
-
- arguments := make([]reflect.Value, fType.NumIn())
- rand := config.getRand()
- maxCount := config.getMaxCount()
-
- for i := 0; i < maxCount; i++ {
- err = arbitraryValues(arguments, fType, config, rand)
- if err != nil {
- return
- }
-
- if !f.Call(arguments)[0].Bool() {
- err = &CheckError{i + 1, toInterfaces(arguments)}
- return
- }
- }
-
- return
-}
-
-// CheckEqual looks for an input on which f and g return different results.
-// It calls f and g repeatedly with arbitrary values for each argument.
-// If f and g return different answers, CheckEqual returns a *CheckEqualError
-// describing the input and the outputs.
-func CheckEqual(f, g interface{}, config *Config) (err error) {
- if config == nil {
- config = &defaultConfig
- }
-
- x, xType, ok := functionAndType(f)
- if !ok {
- err = SetupError("f is not a function")
- return
- }
- y, yType, ok := functionAndType(g)
- if !ok {
- err = SetupError("g is not a function")
- return
- }
-
- if xType != yType {
- err = SetupError("functions have different types")
- return
- }
-
- arguments := make([]reflect.Value, xType.NumIn())
- rand := config.getRand()
- maxCount := config.getMaxCount()
-
- for i := 0; i < maxCount; i++ {
- err = arbitraryValues(arguments, xType, config, rand)
- if err != nil {
- return
- }
-
- xOut := toInterfaces(x.Call(arguments))
- yOut := toInterfaces(y.Call(arguments))
-
- if !reflect.DeepEqual(xOut, yOut) {
- err = &CheckEqualError{CheckError{i + 1, toInterfaces(arguments)}, xOut, yOut}
- return
- }
- }
-
- return
-}
-
-// arbitraryValues writes Values to args such that args contains Values
-// suitable for calling f.
-func arbitraryValues(args []reflect.Value, f reflect.Type, config *Config, rand *rand.Rand) (err error) {
- if config.Values != nil {
- config.Values(args, rand)
- return
- }
-
- for j := 0; j < len(args); j++ {
- var ok bool
- args[j], ok = Value(f.In(j), rand)
- if !ok {
- err = SetupError(fmt.Sprintf("cannot create arbitrary value of type %s for argument %d", f.In(j), j))
- return
- }
- }
-
- return
-}
-
-func functionAndType(f interface{}) (v reflect.Value, t reflect.Type, ok bool) {
- v = reflect.ValueOf(f)
- ok = v.Kind() == reflect.Func
- if !ok {
- return
- }
- t = v.Type()
- return
-}
-
-func toInterfaces(values []reflect.Value) []interface{} {
- ret := make([]interface{}, len(values))
- for i, v := range values {
- ret[i] = v.Interface()
- }
- return ret
-}
-
-func toString(interfaces []interface{}) string {
- s := make([]string, len(interfaces))
- for i, v := range interfaces {
- s[i] = fmt.Sprintf("%#v", v)
- }
- return strings.Join(s, ", ")
-}
diff --git a/src/pkg/testing/quick/quick_test.go b/src/pkg/testing/quick/quick_test.go
deleted file mode 100644
index e925ba675..000000000
--- a/src/pkg/testing/quick/quick_test.go
+++ /dev/null
@@ -1,249 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package quick
-
-import (
- "math/rand"
- "reflect"
- "testing"
-)
-
-func fBool(a bool) bool { return a }
-
-type TestBoolAlias bool
-
-func fBoolAlias(a TestBoolAlias) TestBoolAlias { return a }
-
-func fFloat32(a float32) float32 { return a }
-
-type TestFloat32Alias float32
-
-func fFloat32Alias(a TestFloat32Alias) TestFloat32Alias { return a }
-
-func fFloat64(a float64) float64 { return a }
-
-type TestFloat64Alias float64
-
-func fFloat64Alias(a TestFloat64Alias) TestFloat64Alias { return a }
-
-func fComplex64(a complex64) complex64 { return a }
-
-type TestComplex64Alias complex64
-
-func fComplex64Alias(a TestComplex64Alias) TestComplex64Alias { return a }
-
-func fComplex128(a complex128) complex128 { return a }
-
-type TestComplex128Alias complex128
-
-func fComplex128Alias(a TestComplex128Alias) TestComplex128Alias { return a }
-
-func fInt16(a int16) int16 { return a }
-
-type TestInt16Alias int16
-
-func fInt16Alias(a TestInt16Alias) TestInt16Alias { return a }
-
-func fInt32(a int32) int32 { return a }
-
-type TestInt32Alias int32
-
-func fInt32Alias(a TestInt32Alias) TestInt32Alias { return a }
-
-func fInt64(a int64) int64 { return a }
-
-type TestInt64Alias int64
-
-func fInt64Alias(a TestInt64Alias) TestInt64Alias { return a }
-
-func fInt8(a int8) int8 { return a }
-
-type TestInt8Alias int8
-
-func fInt8Alias(a TestInt8Alias) TestInt8Alias { return a }
-
-func fInt(a int) int { return a }
-
-type TestIntAlias int
-
-func fIntAlias(a TestIntAlias) TestIntAlias { return a }
-
-func fMap(a map[int]int) map[int]int { return a }
-
-type TestMapAlias map[int]int
-
-func fMapAlias(a TestMapAlias) TestMapAlias { return a }
-
-func fSlice(a []byte) []byte { return a }
-
-type TestSliceAlias []byte
-
-func fSliceAlias(a TestSliceAlias) TestSliceAlias { return a }
-
-func fString(a string) string { return a }
-
-type TestStringAlias string
-
-func fStringAlias(a TestStringAlias) TestStringAlias { return a }
-
-type TestStruct struct {
- A int
- B string
-}
-
-func fStruct(a TestStruct) TestStruct { return a }
-
-type TestStructAlias TestStruct
-
-func fStructAlias(a TestStructAlias) TestStructAlias { return a }
-
-func fUint16(a uint16) uint16 { return a }
-
-type TestUint16Alias uint16
-
-func fUint16Alias(a TestUint16Alias) TestUint16Alias { return a }
-
-func fUint32(a uint32) uint32 { return a }
-
-type TestUint32Alias uint32
-
-func fUint32Alias(a TestUint32Alias) TestUint32Alias { return a }
-
-func fUint64(a uint64) uint64 { return a }
-
-type TestUint64Alias uint64
-
-func fUint64Alias(a TestUint64Alias) TestUint64Alias { return a }
-
-func fUint8(a uint8) uint8 { return a }
-
-type TestUint8Alias uint8
-
-func fUint8Alias(a TestUint8Alias) TestUint8Alias { return a }
-
-func fUint(a uint) uint { return a }
-
-type TestUintAlias uint
-
-func fUintAlias(a TestUintAlias) TestUintAlias { return a }
-
-func fUintptr(a uintptr) uintptr { return a }
-
-type TestUintptrAlias uintptr
-
-func fUintptrAlias(a TestUintptrAlias) TestUintptrAlias { return a }
-
-func fIntptr(a *int) *int {
- b := *a
- return &b
-}
-
-type TestIntptrAlias *int
-
-func fIntptrAlias(a TestIntptrAlias) TestIntptrAlias { return a }
-
-func reportError(property string, err error, t *testing.T) {
- if err != nil {
- t.Errorf("%s: %s", property, err)
- }
-}
-
-func TestCheckEqual(t *testing.T) {
- reportError("fBool", CheckEqual(fBool, fBool, nil), t)
- reportError("fBoolAlias", CheckEqual(fBoolAlias, fBoolAlias, nil), t)
- reportError("fFloat32", CheckEqual(fFloat32, fFloat32, nil), t)
- reportError("fFloat32Alias", CheckEqual(fFloat32Alias, fFloat32Alias, nil), t)
- reportError("fFloat64", CheckEqual(fFloat64, fFloat64, nil), t)
- reportError("fFloat64Alias", CheckEqual(fFloat64Alias, fFloat64Alias, nil), t)
- reportError("fComplex64", CheckEqual(fComplex64, fComplex64, nil), t)
- reportError("fComplex64Alias", CheckEqual(fComplex64Alias, fComplex64Alias, nil), t)
- reportError("fComplex128", CheckEqual(fComplex128, fComplex128, nil), t)
- reportError("fComplex128Alias", CheckEqual(fComplex128Alias, fComplex128Alias, nil), t)
- reportError("fInt16", CheckEqual(fInt16, fInt16, nil), t)
- reportError("fInt16Alias", CheckEqual(fInt16Alias, fInt16Alias, nil), t)
- reportError("fInt32", CheckEqual(fInt32, fInt32, nil), t)
- reportError("fInt32Alias", CheckEqual(fInt32Alias, fInt32Alias, nil), t)
- reportError("fInt64", CheckEqual(fInt64, fInt64, nil), t)
- reportError("fInt64Alias", CheckEqual(fInt64Alias, fInt64Alias, nil), t)
- reportError("fInt8", CheckEqual(fInt8, fInt8, nil), t)
- reportError("fInt8Alias", CheckEqual(fInt8Alias, fInt8Alias, nil), t)
- reportError("fInt", CheckEqual(fInt, fInt, nil), t)
- reportError("fIntAlias", CheckEqual(fIntAlias, fIntAlias, nil), t)
- reportError("fInt32", CheckEqual(fInt32, fInt32, nil), t)
- reportError("fInt32Alias", CheckEqual(fInt32Alias, fInt32Alias, nil), t)
- reportError("fMap", CheckEqual(fMap, fMap, nil), t)
- reportError("fMapAlias", CheckEqual(fMapAlias, fMapAlias, nil), t)
- reportError("fSlice", CheckEqual(fSlice, fSlice, nil), t)
- reportError("fSliceAlias", CheckEqual(fSliceAlias, fSliceAlias, nil), t)
- reportError("fString", CheckEqual(fString, fString, nil), t)
- reportError("fStringAlias", CheckEqual(fStringAlias, fStringAlias, nil), t)
- reportError("fStruct", CheckEqual(fStruct, fStruct, nil), t)
- reportError("fStructAlias", CheckEqual(fStructAlias, fStructAlias, nil), t)
- reportError("fUint16", CheckEqual(fUint16, fUint16, nil), t)
- reportError("fUint16Alias", CheckEqual(fUint16Alias, fUint16Alias, nil), t)
- reportError("fUint32", CheckEqual(fUint32, fUint32, nil), t)
- reportError("fUint32Alias", CheckEqual(fUint32Alias, fUint32Alias, nil), t)
- reportError("fUint64", CheckEqual(fUint64, fUint64, nil), t)
- reportError("fUint64Alias", CheckEqual(fUint64Alias, fUint64Alias, nil), t)
- reportError("fUint8", CheckEqual(fUint8, fUint8, nil), t)
- reportError("fUint8Alias", CheckEqual(fUint8Alias, fUint8Alias, nil), t)
- reportError("fUint", CheckEqual(fUint, fUint, nil), t)
- reportError("fUintAlias", CheckEqual(fUintAlias, fUintAlias, nil), t)
- reportError("fUintptr", CheckEqual(fUintptr, fUintptr, nil), t)
- reportError("fUintptrAlias", CheckEqual(fUintptrAlias, fUintptrAlias, nil), t)
- reportError("fIntptr", CheckEqual(fIntptr, fIntptr, nil), t)
- reportError("fIntptrAlias", CheckEqual(fIntptrAlias, fIntptrAlias, nil), t)
-}
-
-// This tests that ArbitraryValue is working by checking that all the arbitrary
-// values of type MyStruct have x = 42.
-type myStruct struct {
- x int
-}
-
-func (m myStruct) Generate(r *rand.Rand, _ int) reflect.Value {
- return reflect.ValueOf(myStruct{x: 42})
-}
-
-func myStructProperty(in myStruct) bool { return in.x == 42 }
-
-func TestCheckProperty(t *testing.T) {
- reportError("myStructProperty", Check(myStructProperty, nil), t)
-}
-
-func TestFailure(t *testing.T) {
- f := func(x int) bool { return false }
- err := Check(f, nil)
- if err == nil {
- t.Errorf("Check didn't return an error")
- }
- if _, ok := err.(*CheckError); !ok {
- t.Errorf("Error was not a CheckError: %s", err)
- }
-
- err = CheckEqual(fUint, fUint32, nil)
- if err == nil {
- t.Errorf("#1 CheckEqual didn't return an error")
- }
- if _, ok := err.(SetupError); !ok {
- t.Errorf("#1 Error was not a SetupError: %s", err)
- }
-
- err = CheckEqual(func(x, y int) {}, func(x int) {}, nil)
- if err == nil {
- t.Errorf("#2 CheckEqual didn't return an error")
- }
- if _, ok := err.(SetupError); !ok {
- t.Errorf("#2 Error was not a SetupError: %s", err)
- }
-
- err = CheckEqual(func(x int) int { return 0 }, func(x int) int32 { return 0 }, nil)
- if err == nil {
- t.Errorf("#3 CheckEqual didn't return an error")
- }
- if _, ok := err.(SetupError); !ok {
- t.Errorf("#3 Error was not a SetupError: %s", err)
- }
-}
diff --git a/src/pkg/testing/testing.go b/src/pkg/testing/testing.go
deleted file mode 100644
index 8078ba7cc..000000000
--- a/src/pkg/testing/testing.go
+++ /dev/null
@@ -1,657 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package testing provides support for automated testing of Go packages.
-// It is intended to be used in concert with the ``go test'' command, which automates
-// execution of any function of the form
-// func TestXxx(*testing.T)
-// where Xxx can be any alphanumeric string (but the first letter must not be in
-// [a-z]) and serves to identify the test routine.
-//
-// Within these functions, use the Error, Fail or related methods to signal failure.
-//
-// To write a new test suite, create a file whose name ends _test.go that
-// contains the TestXxx functions as described here. Put the file in the same
-// package as the one being tested. The file will be excluded from regular
-// package builds but will be included when the ``go test'' command is run.
-// For more detail, run ``go help test'' and ``go help testflag''.
-//
-// Tests and benchmarks may be skipped if not applicable with a call to
-// the Skip method of *T and *B:
-// func TestTimeConsuming(t *testing.T) {
-// if testing.Short() {
-// t.Skip("skipping test in short mode.")
-// }
-// ...
-// }
-//
-// Benchmarks
-//
-// Functions of the form
-// func BenchmarkXxx(*testing.B)
-// are considered benchmarks, and are executed by the "go test" command when
-// its -bench flag is provided. Benchmarks are run sequentially.
-//
-// For a description of the testing flags, see
-// http://golang.org/cmd/go/#hdr-Description_of_testing_flags.
-//
-// A sample benchmark function looks like this:
-// func BenchmarkHello(b *testing.B) {
-// for i := 0; i < b.N; i++ {
-// fmt.Sprintf("hello")
-// }
-// }
-//
-// The benchmark function must run the target code b.N times.
-// The benchmark package will vary b.N until the benchmark function lasts
-// long enough to be timed reliably. The output
-// BenchmarkHello 10000000 282 ns/op
-// means that the loop ran 10000000 times at a speed of 282 ns per loop.
-//
-// If a benchmark needs some expensive setup before running, the timer
-// may be reset:
-//
-// func BenchmarkBigLen(b *testing.B) {
-// big := NewBig()
-// b.ResetTimer()
-// for i := 0; i < b.N; i++ {
-// big.Len()
-// }
-// }
-//
-// If a benchmark needs to test performance in a parallel setting, it may use
-// the RunParallel helper function; such benchmarks are intended to be used with
-// the go test -cpu flag:
-//
-// 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
-//
-// The package also runs and verifies example code. Example functions may
-// include a concluding line comment that begins with "Output:" and is compared with
-// the standard output of the function when the tests are run. (The comparison
-// ignores leading and trailing space.) These are examples of an example:
-//
-// func ExampleHello() {
-// fmt.Println("hello")
-// // Output: hello
-// }
-//
-// func ExampleSalutations() {
-// fmt.Println("hello, and")
-// fmt.Println("goodbye")
-// // Output:
-// // hello, and
-// // goodbye
-// }
-//
-// Example functions without output comments are compiled but not executed.
-//
-// The naming convention to declare examples for the package, a function F, a type T and
-// method M on type T are:
-//
-// func Example() { ... }
-// func ExampleF() { ... }
-// func ExampleT() { ... }
-// func ExampleT_M() { ... }
-//
-// Multiple example functions for a package/type/function/method may be provided by
-// appending a distinct suffix to the name. The suffix must start with a
-// lower-case letter.
-//
-// func Example_suffix() { ... }
-// func ExampleF_suffix() { ... }
-// func ExampleT_suffix() { ... }
-// func ExampleT_M_suffix() { ... }
-//
-// The entire test file is presented as the example when it contains a single
-// example function, at least one other function, type, variable, or constant
-// declaration, and no test or benchmark functions.
-package testing
-
-import (
- "bytes"
- "flag"
- "fmt"
- "os"
- "runtime"
- "runtime/pprof"
- "strconv"
- "strings"
- "sync"
- "time"
-)
-
-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")
-
- // The directory in which to create profile files and the like. When run from
- // "go test", the binary always runs in the source directory for the package;
- // this flag lets "go test" tell the binary to write the files in the directory where
- // the "go test" command is run.
- outputDir = flag.String("test.outputdir", "", "directory in which to write profiles")
-
- // Report as tests are run; default is silent for success.
- chatty = flag.Bool("test.v", false, "verbose: print additional output")
- coverProfile = flag.String("test.coverprofile", "", "write a coverage profile to the named file after execution")
- match = flag.String("test.run", "", "regular expression to select tests and examples 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")
- blockProfile = flag.String("test.blockprofile", "", "write a goroutine blocking profile to the named file after execution")
- blockProfileRate = flag.Int("test.blockprofilerate", 1, "if >= 0, calls runtime.SetBlockProfileRate()")
- 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")
-
- haveExamples bool // are there examples?
-
- cpuList []int
-)
-
-// common holds the elements common between T and B and
-// captures common methods such as Errorf.
-type common struct {
- mu sync.RWMutex // guards output and failed
- output []byte // Output generated by test or benchmark.
- failed bool // Test or benchmark has failed.
- skipped bool // Test of benchmark has been skipped.
- finished bool
-
- 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.
-}
-
-// Short reports whether the -test.short flag is set.
-func Short() bool {
- return *short
-}
-
-// Verbose reports whether the -test.v flag is set.
-func Verbose() bool {
- return *chatty
-}
-
-// decorate prefixes the string with the file and line of the call site
-// and inserts the final newline if needed and indentation tabs for formatting.
-func decorate(s string) string {
- _, file, line, ok := runtime.Caller(3) // decorate + log + public function.
- if ok {
- // Truncate file name at last file name separator.
- if index := strings.LastIndex(file, "/"); index >= 0 {
- file = file[index+1:]
- } else if index = strings.LastIndex(file, "\\"); index >= 0 {
- file = file[index+1:]
- }
- } else {
- file = "???"
- line = 1
- }
- buf := new(bytes.Buffer)
- // Every line is indented at least one tab.
- buf.WriteByte('\t')
- fmt.Fprintf(buf, "%s:%d: ", file, line)
- lines := strings.Split(s, "\n")
- if l := len(lines); l > 1 && lines[l-1] == "" {
- lines = lines[:l-1]
- }
- for i, line := range lines {
- if i > 0 {
- // Second and subsequent lines are indented an extra tab.
- buf.WriteString("\n\t\t")
- }
- buf.WriteString(line)
- }
- buf.WriteByte('\n')
- return buf.String()
-}
-
-// TB is the interface common to T and 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{})
- Skip(args ...interface{})
- SkipNow()
- Skipf(format string, args ...interface{})
- Skipped() bool
-
- // A private method to prevent users implementing the
- // interface and so future additions to it will not
- // violate Go 1 compatibility.
- private()
-}
-
-var _ TB = (*T)(nil)
-var _ TB = (*B)(nil)
-
-// T is a type passed to Test functions to manage test state and support formatted test logs.
-// Logs are accumulated during execution and dumped to standard error when done.
-type T struct {
- common
- name string // Name of test.
- startParallel chan bool // Parallel tests will wait on this.
-}
-
-func (c *common) private() {}
-
-// Fail marks the function as having failed but continues execution.
-func (c *common) Fail() {
- c.mu.Lock()
- defer c.mu.Unlock()
- c.failed = true
-}
-
-// Failed reports whether the function has failed.
-func (c *common) Failed() bool {
- c.mu.RLock()
- defer c.mu.RUnlock()
- return c.failed
-}
-
-// FailNow marks the function as having failed and stops its execution.
-// Execution will continue at the next test or benchmark.
-// FailNow must be called from the goroutine running the
-// test or benchmark function, not from other goroutines
-// created during the test. Calling FailNow does not stop
-// those other goroutines.
-func (c *common) FailNow() {
- c.Fail()
-
- // Calling runtime.Goexit will exit the goroutine, which
- // will run the deferred functions in this goroutine,
- // which will eventually run the deferred lines in tRunner,
- // which will signal to the test loop that this test is done.
- //
- // A previous version of this code said:
- //
- // c.duration = ...
- // c.signal <- c.self
- // runtime.Goexit()
- //
- // This previous version duplicated code (those lines are in
- // tRunner no matter what), but worse the goroutine teardown
- // implicit in runtime.Goexit was not guaranteed to complete
- // before the test exited. If a test deferred an important cleanup
- // function (like removing temporary files), there was no guarantee
- // it would run on a test failure. Because we send on c.signal during
- // a top-of-stack deferred function now, we know that the send
- // only happens after any other stacked defers have completed.
- c.finished = true
- runtime.Goexit()
-}
-
-// log generates the output. It's always at the same stack depth.
-func (c *common) log(s string) {
- c.mu.Lock()
- defer c.mu.Unlock()
- c.output = append(c.output, decorate(s)...)
-}
-
-// Log formats its arguments using default formatting, analogous to Println,
-// and records the text in the error log. The text will be printed only if
-// the test fails or the -test.v flag is set.
-func (c *common) Log(args ...interface{}) { c.log(fmt.Sprintln(args...)) }
-
-// Logf formats its arguments according to the format, analogous to Printf,
-// and records the text in the error log. The text will be printed only if
-// the test fails or the -test.v flag is set.
-func (c *common) Logf(format string, args ...interface{}) { c.log(fmt.Sprintf(format, args...)) }
-
-// Error is equivalent to Log followed by Fail.
-func (c *common) Error(args ...interface{}) {
- c.log(fmt.Sprintln(args...))
- c.Fail()
-}
-
-// Errorf is equivalent to Logf followed by Fail.
-func (c *common) Errorf(format string, args ...interface{}) {
- c.log(fmt.Sprintf(format, args...))
- c.Fail()
-}
-
-// Fatal is equivalent to Log followed by FailNow.
-func (c *common) Fatal(args ...interface{}) {
- c.log(fmt.Sprintln(args...))
- c.FailNow()
-}
-
-// Fatalf is equivalent to Logf followed by FailNow.
-func (c *common) Fatalf(format string, args ...interface{}) {
- c.log(fmt.Sprintf(format, args...))
- c.FailNow()
-}
-
-// Skip is equivalent to Log followed by SkipNow.
-func (c *common) Skip(args ...interface{}) {
- c.log(fmt.Sprintln(args...))
- c.SkipNow()
-}
-
-// Skipf is equivalent to Logf followed by SkipNow.
-func (c *common) Skipf(format string, args ...interface{}) {
- c.log(fmt.Sprintf(format, args...))
- c.SkipNow()
-}
-
-// SkipNow marks the test as having been skipped and stops its execution.
-// Execution will continue at the next test or benchmark. See also FailNow.
-// SkipNow must be called from the goroutine running the test, not from
-// other goroutines created during the test. Calling SkipNow does not stop
-// those other goroutines.
-func (c *common) SkipNow() {
- c.skip()
- c.finished = true
- runtime.Goexit()
-}
-
-func (c *common) skip() {
- c.mu.Lock()
- defer c.mu.Unlock()
- c.skipped = true
-}
-
-// Skipped reports whether the test was skipped.
-func (c *common) Skipped() bool {
- c.mu.RLock()
- defer c.mu.RUnlock()
- return c.skipped
-}
-
-// Parallel signals that this test is to be run in parallel with (and only with)
-// other parallel tests.
-func (t *T) Parallel() {
- t.signal <- (*T)(nil) // Release main testing loop
- <-t.startParallel // Wait for serial tests to finish
- // Assuming Parallel is the first thing a test does, which is reasonable,
- // reinitialize the test's start time because it's actually starting now.
- t.start = time.Now()
-}
-
-// 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)
-}
-
-func tRunner(t *T, test *InternalTest) {
- // When this goroutine is done, either because test.F(t)
- // returned normally or because a test failure triggered
- // a call to runtime.Goexit, record the duration and send
- // a signal saying that the test is done.
- defer func() {
- t.duration = time.Now().Sub(t.start)
- // If the test panicked, print any test output before dying.
- err := recover()
- if !t.finished && err == nil {
- err = fmt.Errorf("test executed panic(nil) or runtime.Goexit")
- }
- if err != nil {
- t.Fail()
- t.report()
- panic(err)
- }
- t.signal <- t
- }()
-
- t.start = time.Now()
- test.F(t)
- t.finished = true
-}
-
-// An internal function but exported because it is cross-package; part of the implementation
-// of the "go test" command.
-func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample) {
- flag.Parse()
- parseCpuList()
-
- before()
- startAlarm()
- haveExamples = len(examples) > 0
- testOk := RunTests(matchString, tests)
- exampleOk := RunExamples(matchString, examples)
- stopAlarm()
- if !testOk || !exampleOk {
- fmt.Println("FAIL")
- after()
- os.Exit(1)
- }
- fmt.Println("PASS")
- RunBenchmarks(matchString, benchmarks)
- after()
-}
-
-func (t *T) report() {
- tstr := fmt.Sprintf("(%.2f seconds)", t.duration.Seconds())
- format := "--- %s: %s %s\n%s"
- if t.Failed() {
- fmt.Printf(format, "FAIL", t.name, tstr, t.output)
- } else if *chatty {
- if t.Skipped() {
- fmt.Printf(format, "SKIP", t.name, tstr, t.output)
- } else {
- fmt.Printf(format, "PASS", t.name, tstr, t.output)
- }
- }
-}
-
-func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool) {
- ok = true
- if len(tests) == 0 && !haveExamples {
- fmt.Fprintln(os.Stderr, "testing: warning: no tests to run")
- return
- }
- for _, procs := range cpuList {
- runtime.GOMAXPROCS(procs)
- // We build a new channel tree for each run of the loop.
- // collector merges in one channel all the upstream signals from parallel tests.
- // If all tests pump to the same channel, a bug can occur where a test
- // kicks off a goroutine that Fails, yet the test still delivers a completion signal,
- // which skews the counting.
- var collector = make(chan interface{})
-
- numParallel := 0
- startParallel := make(chan bool)
-
- for i := 0; i < len(tests); i++ {
- matched, err := matchString(*match, tests[i].Name)
- if err != nil {
- fmt.Fprintf(os.Stderr, "testing: invalid regexp for -test.run: %s\n", err)
- os.Exit(1)
- }
- if !matched {
- continue
- }
- testName := tests[i].Name
- if procs != 1 {
- testName = fmt.Sprintf("%s-%d", tests[i].Name, procs)
- }
- t := &T{
- common: common{
- signal: make(chan interface{}),
- },
- name: testName,
- startParallel: startParallel,
- }
- t.self = t
- if *chatty {
- fmt.Printf("=== RUN %s\n", t.name)
- }
- go tRunner(t, &tests[i])
- out := (<-t.signal).(*T)
- if out == nil { // Parallel run.
- go func() {
- collector <- <-t.signal
- }()
- numParallel++
- continue
- }
- t.report()
- ok = ok && !out.Failed()
- }
-
- running := 0
- for numParallel+running > 0 {
- if running < *parallel && numParallel > 0 {
- startParallel <- true
- running++
- numParallel--
- continue
- }
- t := (<-collector).(*T)
- t.report()
- ok = ok && !t.Failed()
- running--
- }
- }
- return
-}
-
-// before runs before all testing.
-func before() {
- if *memProfileRate > 0 {
- runtime.MemProfileRate = *memProfileRate
- }
- if *cpuProfile != "" {
- f, err := os.Create(toOutputDir(*cpuProfile))
- if err != nil {
- fmt.Fprintf(os.Stderr, "testing: %s", err)
- return
- }
- if err := pprof.StartCPUProfile(f); err != nil {
- fmt.Fprintf(os.Stderr, "testing: can't start cpu profile: %s", err)
- f.Close()
- return
- }
- // Could save f so after can call f.Close; not worth the effort.
- }
- if *blockProfile != "" && *blockProfileRate >= 0 {
- runtime.SetBlockProfileRate(*blockProfileRate)
- }
- if *coverProfile != "" && cover.Mode == "" {
- fmt.Fprintf(os.Stderr, "testing: cannot use -test.coverprofile because test binary was not built with coverage enabled\n")
- os.Exit(2)
- }
-}
-
-// after runs after all testing.
-func after() {
- if *cpuProfile != "" {
- pprof.StopCPUProfile() // flushes profile to disk
- }
- if *memProfile != "" {
- f, err := os.Create(toOutputDir(*memProfile))
- if err != nil {
- fmt.Fprintf(os.Stderr, "testing: %s\n", err)
- os.Exit(2)
- }
- if err = pprof.WriteHeapProfile(f); err != nil {
- fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *memProfile, err)
- os.Exit(2)
- }
- f.Close()
- }
- if *blockProfile != "" && *blockProfileRate >= 0 {
- f, err := os.Create(toOutputDir(*blockProfile))
- if err != nil {
- fmt.Fprintf(os.Stderr, "testing: %s\n", err)
- os.Exit(2)
- }
- if err = pprof.Lookup("block").WriteTo(f, 0); err != nil {
- fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *blockProfile, err)
- os.Exit(2)
- }
- f.Close()
- }
- if cover.Mode != "" {
- coverReport()
- }
-}
-
-// toOutputDir returns the file name relocated, if required, to outputDir.
-// Simple implementation to avoid pulling in path/filepath.
-func toOutputDir(path string) string {
- if *outputDir == "" || path == "" {
- return path
- }
- if runtime.GOOS == "windows" {
- // On Windows, it's clumsy, but we can be almost always correct
- // by just looking for a drive letter and a colon.
- // Absolute paths always have a drive letter (ignoring UNC).
- // Problem: if path == "C:A" and outputdir == "C:\Go" it's unclear
- // what to do, but even then path/filepath doesn't help.
- // TODO: Worth doing better? Probably not, because we're here only
- // under the management of go test.
- if len(path) >= 2 {
- letter, colon := path[0], path[1]
- if ('a' <= letter && letter <= 'z' || 'A' <= letter && letter <= 'Z') && colon == ':' {
- // If path starts with a drive letter we're stuck with it regardless.
- return path
- }
- }
- }
- if os.IsPathSeparator(path[0]) {
- return path
- }
- return fmt.Sprintf("%s%c%s", *outputDir, os.PathSeparator, path)
-}
-
-var timer *time.Timer
-
-// startAlarm starts an alarm if requested.
-func startAlarm() {
- if *timeout > 0 {
- timer = time.AfterFunc(*timeout, func() {
- panic(fmt.Sprintf("test timed out after %v", *timeout))
- })
- }
-}
-
-// stopAlarm turns off the alarm.
-func stopAlarm() {
- if *timeout > 0 {
- timer.Stop()
- }
-}
-
-func parseCpuList() {
- for _, val := range strings.Split(*cpuListStr, ",") {
- val = strings.TrimSpace(val)
- if val == "" {
- continue
- }
- cpu, err := strconv.Atoi(val)
- if err != nil || cpu <= 0 {
- fmt.Fprintf(os.Stderr, "testing: invalid value %q for -test.cpu\n", val)
- os.Exit(1)
- }
- cpuList = append(cpuList, cpu)
- }
- if cpuList == nil {
- cpuList = append(cpuList, runtime.GOMAXPROCS(-1))
- }
-}
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-30 14:47:38 +0000