Imported Upstream version 1.4upstream/1.4

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))
-	}
-}