...
Run Format

Source file src/testing/testing.go

     1	// Copyright 2009 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// Package testing provides support for automated testing of Go packages.
     6	// It is intended to be used in concert with the ``go test'' command, which automates
     7	// execution of any function of the form
     8	//     func TestXxx(*testing.T)
     9	// where Xxx can be any alphanumeric string (but the first letter must not be in
    10	// [a-z]) and serves to identify the test routine.
    11	//
    12	// Within these functions, use the Error, Fail or related methods to signal failure.
    13	//
    14	// To write a new test suite, create a file whose name ends _test.go that
    15	// contains the TestXxx functions as described here. Put the file in the same
    16	// package as the one being tested. The file will be excluded from regular
    17	// package builds but will be included when the ``go test'' command is run.
    18	// For more detail, run ``go help test'' and ``go help testflag''.
    19	//
    20	// Tests and benchmarks may be skipped if not applicable with a call to
    21	// the Skip method of *T and *B:
    22	//     func TestTimeConsuming(t *testing.T) {
    23	//         if testing.Short() {
    24	//             t.Skip("skipping test in short mode.")
    25	//         }
    26	//         ...
    27	//     }
    28	//
    29	// Benchmarks
    30	//
    31	// Functions of the form
    32	//     func BenchmarkXxx(*testing.B)
    33	// are considered benchmarks, and are executed by the "go test" command when
    34	// its -bench flag is provided. Benchmarks are run sequentially.
    35	//
    36	// For a description of the testing flags, see
    37	// https://golang.org/cmd/go/#hdr-Description_of_testing_flags.
    38	//
    39	// A sample benchmark function looks like this:
    40	//     func BenchmarkHello(b *testing.B) {
    41	//         for i := 0; i < b.N; i++ {
    42	//             fmt.Sprintf("hello")
    43	//         }
    44	//     }
    45	//
    46	// The benchmark function must run the target code b.N times.
    47	// During benchmark execution, b.N is adjusted until the benchmark function lasts
    48	// long enough to be timed reliably.  The output
    49	//     BenchmarkHello    10000000    282 ns/op
    50	// means that the loop ran 10000000 times at a speed of 282 ns per loop.
    51	//
    52	// If a benchmark needs some expensive setup before running, the timer
    53	// may be reset:
    54	//
    55	//     func BenchmarkBigLen(b *testing.B) {
    56	//         big := NewBig()
    57	//         b.ResetTimer()
    58	//         for i := 0; i < b.N; i++ {
    59	//             big.Len()
    60	//         }
    61	//     }
    62	//
    63	// If a benchmark needs to test performance in a parallel setting, it may use
    64	// the RunParallel helper function; such benchmarks are intended to be used with
    65	// the go test -cpu flag:
    66	//
    67	//     func BenchmarkTemplateParallel(b *testing.B) {
    68	//         templ := template.Must(template.New("test").Parse("Hello, {{.}}!"))
    69	//         b.RunParallel(func(pb *testing.PB) {
    70	//             var buf bytes.Buffer
    71	//             for pb.Next() {
    72	//                 buf.Reset()
    73	//                 templ.Execute(&buf, "World")
    74	//             }
    75	//         })
    76	//     }
    77	//
    78	// Examples
    79	//
    80	// The package also runs and verifies example code. Example functions may
    81	// include a concluding line comment that begins with "Output:" and is compared with
    82	// the standard output of the function when the tests are run. (The comparison
    83	// ignores leading and trailing space.) These are examples of an example:
    84	//
    85	//     func ExampleHello() {
    86	//             fmt.Println("hello")
    87	//             // Output: hello
    88	//     }
    89	//
    90	//     func ExampleSalutations() {
    91	//             fmt.Println("hello, and")
    92	//             fmt.Println("goodbye")
    93	//             // Output:
    94	//             // hello, and
    95	//             // goodbye
    96	//     }
    97	//
    98	// Example functions without output comments are compiled but not executed.
    99	//
   100	// The naming convention to declare examples for the package, a function F, a type T and
   101	// method M on type T are:
   102	//
   103	//     func Example() { ... }
   104	//     func ExampleF() { ... }
   105	//     func ExampleT() { ... }
   106	//     func ExampleT_M() { ... }
   107	//
   108	// Multiple example functions for a package/type/function/method may be provided by
   109	// appending a distinct suffix to the name. The suffix must start with a
   110	// lower-case letter.
   111	//
   112	//     func Example_suffix() { ... }
   113	//     func ExampleF_suffix() { ... }
   114	//     func ExampleT_suffix() { ... }
   115	//     func ExampleT_M_suffix() { ... }
   116	//
   117	// The entire test file is presented as the example when it contains a single
   118	// example function, at least one other function, type, variable, or constant
   119	// declaration, and no test or benchmark functions.
   120	//
   121	// Main
   122	//
   123	// It is sometimes necessary for a test program to do extra setup or teardown
   124	// before or after testing. It is also sometimes necessary for a test to control
   125	// which code runs on the main thread. To support these and other cases,
   126	// if a test file contains a function:
   127	//
   128	//	func TestMain(m *testing.M)
   129	//
   130	// then the generated test will call TestMain(m) instead of running the tests
   131	// directly. TestMain runs in the main goroutine and can do whatever setup
   132	// and teardown is necessary around a call to m.Run. It should then call
   133	// os.Exit with the result of m.Run. When TestMain is called, flag.Parse has
   134	// not been run. If TestMain depends on command-line flags, including those
   135	// of the testing package, it should call flag.Parse explicitly.
   136	//
   137	// A simple implementation of TestMain is:
   138	//
   139	//	func TestMain(m *testing.M) {
   140	//		flag.Parse()
   141	//		os.Exit(m.Run())
   142	//	}
   143	//
   144	package testing
   145	
   146	import (
   147		"bytes"
   148		"flag"
   149		"fmt"
   150		"os"
   151		"runtime"
   152		"runtime/pprof"
   153		"runtime/trace"
   154		"strconv"
   155		"strings"
   156		"sync"
   157		"time"
   158	)
   159	
   160	var (
   161		// The short flag requests that tests run more quickly, but its functionality
   162		// is provided by test writers themselves.  The testing package is just its
   163		// home.  The all.bash installation script sets it to make installation more
   164		// efficient, but by default the flag is off so a plain "go test" will do a
   165		// full test of the package.
   166		short = flag.Bool("test.short", false, "run smaller test suite to save time")
   167	
   168		// The directory in which to create profile files and the like. When run from
   169		// "go test", the binary always runs in the source directory for the package;
   170		// this flag lets "go test" tell the binary to write the files in the directory where
   171		// the "go test" command is run.
   172		outputDir = flag.String("test.outputdir", "", "directory in which to write profiles")
   173	
   174		// Report as tests are run; default is silent for success.
   175		chatty           = flag.Bool("test.v", false, "verbose: print additional output")
   176		count            = flag.Uint("test.count", 1, "run tests and benchmarks `n` times")
   177		coverProfile     = flag.String("test.coverprofile", "", "write a coverage profile to the named file after execution")
   178		match            = flag.String("test.run", "", "regular expression to select tests and examples to run")
   179		memProfile       = flag.String("test.memprofile", "", "write a memory profile to the named file after execution")
   180		memProfileRate   = flag.Int("test.memprofilerate", 0, "if >=0, sets runtime.MemProfileRate")
   181		cpuProfile       = flag.String("test.cpuprofile", "", "write a cpu profile to the named file during execution")
   182		blockProfile     = flag.String("test.blockprofile", "", "write a goroutine blocking profile to the named file after execution")
   183		blockProfileRate = flag.Int("test.blockprofilerate", 1, "if >= 0, calls runtime.SetBlockProfileRate()")
   184		traceFile        = flag.String("test.trace", "", "write an execution trace to the named file after execution")
   185		timeout          = flag.Duration("test.timeout", 0, "if positive, sets an aggregate time limit for all tests")
   186		cpuListStr       = flag.String("test.cpu", "", "comma-separated list of number of CPUs to use for each test")
   187		parallel         = flag.Int("test.parallel", runtime.GOMAXPROCS(0), "maximum test parallelism")
   188	
   189		haveExamples bool // are there examples?
   190	
   191		cpuList []int
   192	)
   193	
   194	// common holds the elements common between T and B and
   195	// captures common methods such as Errorf.
   196	type common struct {
   197		mu       sync.RWMutex // guards output and failed
   198		output   []byte       // Output generated by test or benchmark.
   199		failed   bool         // Test or benchmark has failed.
   200		skipped  bool         // Test of benchmark has been skipped.
   201		finished bool
   202	
   203		start    time.Time // Time test or benchmark started
   204		duration time.Duration
   205		self     interface{}      // To be sent on signal channel when done.
   206		signal   chan interface{} // Output for serial tests.
   207	}
   208	
   209	// Short reports whether the -test.short flag is set.
   210	func Short() bool {
   211		return *short
   212	}
   213	
   214	// Verbose reports whether the -test.v flag is set.
   215	func Verbose() bool {
   216		return *chatty
   217	}
   218	
   219	// decorate prefixes the string with the file and line of the call site
   220	// and inserts the final newline if needed and indentation tabs for formatting.
   221	func decorate(s string) string {
   222		_, file, line, ok := runtime.Caller(3) // decorate + log + public function.
   223		if ok {
   224			// Truncate file name at last file name separator.
   225			if index := strings.LastIndex(file, "/"); index >= 0 {
   226				file = file[index+1:]
   227			} else if index = strings.LastIndex(file, "\\"); index >= 0 {
   228				file = file[index+1:]
   229			}
   230		} else {
   231			file = "???"
   232			line = 1
   233		}
   234		buf := new(bytes.Buffer)
   235		// Every line is indented at least one tab.
   236		buf.WriteByte('\t')
   237		fmt.Fprintf(buf, "%s:%d: ", file, line)
   238		lines := strings.Split(s, "\n")
   239		if l := len(lines); l > 1 && lines[l-1] == "" {
   240			lines = lines[:l-1]
   241		}
   242		for i, line := range lines {
   243			if i > 0 {
   244				// Second and subsequent lines are indented an extra tab.
   245				buf.WriteString("\n\t\t")
   246			}
   247			buf.WriteString(line)
   248		}
   249		buf.WriteByte('\n')
   250		return buf.String()
   251	}
   252	
   253	// fmtDuration returns a string representing d in the form "87.00s".
   254	func fmtDuration(d time.Duration) string {
   255		return fmt.Sprintf("%.2fs", d.Seconds())
   256	}
   257	
   258	// TB is the interface common to T and B.
   259	type TB interface {
   260		Error(args ...interface{})
   261		Errorf(format string, args ...interface{})
   262		Fail()
   263		FailNow()
   264		Failed() bool
   265		Fatal(args ...interface{})
   266		Fatalf(format string, args ...interface{})
   267		Log(args ...interface{})
   268		Logf(format string, args ...interface{})
   269		Skip(args ...interface{})
   270		SkipNow()
   271		Skipf(format string, args ...interface{})
   272		Skipped() bool
   273	
   274		// A private method to prevent users implementing the
   275		// interface and so future additions to it will not
   276		// violate Go 1 compatibility.
   277		private()
   278	}
   279	
   280	var _ TB = (*T)(nil)
   281	var _ TB = (*B)(nil)
   282	
   283	// T is a type passed to Test functions to manage test state and support formatted test logs.
   284	// Logs are accumulated during execution and dumped to standard error when done.
   285	type T struct {
   286		common
   287		name          string    // Name of test.
   288		startParallel chan bool // Parallel tests will wait on this.
   289	}
   290	
   291	func (c *common) private() {}
   292	
   293	// Fail marks the function as having failed but continues execution.
   294	func (c *common) Fail() {
   295		c.mu.Lock()
   296		defer c.mu.Unlock()
   297		c.failed = true
   298	}
   299	
   300	// Failed reports whether the function has failed.
   301	func (c *common) Failed() bool {
   302		c.mu.RLock()
   303		defer c.mu.RUnlock()
   304		return c.failed
   305	}
   306	
   307	// FailNow marks the function as having failed and stops its execution.
   308	// Execution will continue at the next test or benchmark.
   309	// FailNow must be called from the goroutine running the
   310	// test or benchmark function, not from other goroutines
   311	// created during the test. Calling FailNow does not stop
   312	// those other goroutines.
   313	func (c *common) FailNow() {
   314		c.Fail()
   315	
   316		// Calling runtime.Goexit will exit the goroutine, which
   317		// will run the deferred functions in this goroutine,
   318		// which will eventually run the deferred lines in tRunner,
   319		// which will signal to the test loop that this test is done.
   320		//
   321		// A previous version of this code said:
   322		//
   323		//	c.duration = ...
   324		//	c.signal <- c.self
   325		//	runtime.Goexit()
   326		//
   327		// This previous version duplicated code (those lines are in
   328		// tRunner no matter what), but worse the goroutine teardown
   329		// implicit in runtime.Goexit was not guaranteed to complete
   330		// before the test exited.  If a test deferred an important cleanup
   331		// function (like removing temporary files), there was no guarantee
   332		// it would run on a test failure.  Because we send on c.signal during
   333		// a top-of-stack deferred function now, we know that the send
   334		// only happens after any other stacked defers have completed.
   335		c.finished = true
   336		runtime.Goexit()
   337	}
   338	
   339	// log generates the output. It's always at the same stack depth.
   340	func (c *common) log(s string) {
   341		c.mu.Lock()
   342		defer c.mu.Unlock()
   343		c.output = append(c.output, decorate(s)...)
   344	}
   345	
   346	// Log formats its arguments using default formatting, analogous to Println,
   347	// and records the text in the error log. For tests, the text will be printed only if
   348	// the test fails or the -test.v flag is set. For benchmarks, the text is always
   349	// printed to avoid having performance depend on the value of the -test.v flag.
   350	func (c *common) Log(args ...interface{}) { c.log(fmt.Sprintln(args...)) }
   351	
   352	// Logf formats its arguments according to the format, analogous to Printf,
   353	// and records the text in the error log. For tests, the text will be printed only if
   354	// the test fails or the -test.v flag is set. For benchmarks, the text is always
   355	// printed to avoid having performance depend on the value of the -test.v flag.
   356	func (c *common) Logf(format string, args ...interface{}) { c.log(fmt.Sprintf(format, args...)) }
   357	
   358	// Error is equivalent to Log followed by Fail.
   359	func (c *common) Error(args ...interface{}) {
   360		c.log(fmt.Sprintln(args...))
   361		c.Fail()
   362	}
   363	
   364	// Errorf is equivalent to Logf followed by Fail.
   365	func (c *common) Errorf(format string, args ...interface{}) {
   366		c.log(fmt.Sprintf(format, args...))
   367		c.Fail()
   368	}
   369	
   370	// Fatal is equivalent to Log followed by FailNow.
   371	func (c *common) Fatal(args ...interface{}) {
   372		c.log(fmt.Sprintln(args...))
   373		c.FailNow()
   374	}
   375	
   376	// Fatalf is equivalent to Logf followed by FailNow.
   377	func (c *common) Fatalf(format string, args ...interface{}) {
   378		c.log(fmt.Sprintf(format, args...))
   379		c.FailNow()
   380	}
   381	
   382	// Skip is equivalent to Log followed by SkipNow.
   383	func (c *common) Skip(args ...interface{}) {
   384		c.log(fmt.Sprintln(args...))
   385		c.SkipNow()
   386	}
   387	
   388	// Skipf is equivalent to Logf followed by SkipNow.
   389	func (c *common) Skipf(format string, args ...interface{}) {
   390		c.log(fmt.Sprintf(format, args...))
   391		c.SkipNow()
   392	}
   393	
   394	// SkipNow marks the test as having been skipped and stops its execution.
   395	// Execution will continue at the next test or benchmark. See also FailNow.
   396	// SkipNow must be called from the goroutine running the test, not from
   397	// other goroutines created during the test. Calling SkipNow does not stop
   398	// those other goroutines.
   399	func (c *common) SkipNow() {
   400		c.skip()
   401		c.finished = true
   402		runtime.Goexit()
   403	}
   404	
   405	func (c *common) skip() {
   406		c.mu.Lock()
   407		defer c.mu.Unlock()
   408		c.skipped = true
   409	}
   410	
   411	// Skipped reports whether the test was skipped.
   412	func (c *common) Skipped() bool {
   413		c.mu.RLock()
   414		defer c.mu.RUnlock()
   415		return c.skipped
   416	}
   417	
   418	// Parallel signals that this test is to be run in parallel with (and only with)
   419	// other parallel tests.
   420	func (t *T) Parallel() {
   421		t.signal <- (*T)(nil) // Release main testing loop
   422		<-t.startParallel     // Wait for serial tests to finish
   423		// Assuming Parallel is the first thing a test does, which is reasonable,
   424		// reinitialize the test's start time because it's actually starting now.
   425		t.start = time.Now()
   426	}
   427	
   428	// An internal type but exported because it is cross-package; part of the implementation
   429	// of the "go test" command.
   430	type InternalTest struct {
   431		Name string
   432		F    func(*T)
   433	}
   434	
   435	func tRunner(t *T, test *InternalTest) {
   436		// When this goroutine is done, either because test.F(t)
   437		// returned normally or because a test failure triggered
   438		// a call to runtime.Goexit, record the duration and send
   439		// a signal saying that the test is done.
   440		defer func() {
   441			t.duration = time.Now().Sub(t.start)
   442			// If the test panicked, print any test output before dying.
   443			err := recover()
   444			if !t.finished && err == nil {
   445				err = fmt.Errorf("test executed panic(nil) or runtime.Goexit")
   446			}
   447			if err != nil {
   448				t.Fail()
   449				t.report()
   450				panic(err)
   451			}
   452			t.signal <- t
   453		}()
   454	
   455		t.start = time.Now()
   456		test.F(t)
   457		t.finished = true
   458	}
   459	
   460	// An internal function but exported because it is cross-package; part of the implementation
   461	// of the "go test" command.
   462	func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample) {
   463		os.Exit(MainStart(matchString, tests, benchmarks, examples).Run())
   464	}
   465	
   466	// M is a type passed to a TestMain function to run the actual tests.
   467	type M struct {
   468		matchString func(pat, str string) (bool, error)
   469		tests       []InternalTest
   470		benchmarks  []InternalBenchmark
   471		examples    []InternalExample
   472	}
   473	
   474	// MainStart is meant for use by tests generated by 'go test'.
   475	// It is not meant to be called directly and is not subject to the Go 1 compatibility document.
   476	// It may change signature from release to release.
   477	func MainStart(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample) *M {
   478		return &M{
   479			matchString: matchString,
   480			tests:       tests,
   481			benchmarks:  benchmarks,
   482			examples:    examples,
   483		}
   484	}
   485	
   486	// Run runs the tests. It returns an exit code to pass to os.Exit.
   487	func (m *M) Run() int {
   488		flag.Parse()
   489		parseCpuList()
   490	
   491		before()
   492		startAlarm()
   493		haveExamples = len(m.examples) > 0
   494		testOk := RunTests(m.matchString, m.tests)
   495		exampleOk := RunExamples(m.matchString, m.examples)
   496		stopAlarm()
   497		if !testOk || !exampleOk {
   498			fmt.Println("FAIL")
   499			after()
   500			return 1
   501		}
   502		fmt.Println("PASS")
   503		RunBenchmarks(m.matchString, m.benchmarks)
   504		after()
   505		return 0
   506	}
   507	
   508	func (t *T) report() {
   509		dstr := fmtDuration(t.duration)
   510		format := "--- %s: %s (%s)\n%s"
   511		if t.Failed() {
   512			fmt.Printf(format, "FAIL", t.name, dstr, t.output)
   513		} else if *chatty {
   514			if t.Skipped() {
   515				fmt.Printf(format, "SKIP", t.name, dstr, t.output)
   516			} else {
   517				fmt.Printf(format, "PASS", t.name, dstr, t.output)
   518			}
   519		}
   520	}
   521	
   522	func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool) {
   523		ok = true
   524		if len(tests) == 0 && !haveExamples {
   525			fmt.Fprintln(os.Stderr, "testing: warning: no tests to run")
   526			return
   527		}
   528		for _, procs := range cpuList {
   529			runtime.GOMAXPROCS(procs)
   530			// We build a new channel tree for each run of the loop.
   531			// collector merges in one channel all the upstream signals from parallel tests.
   532			// If all tests pump to the same channel, a bug can occur where a test
   533			// kicks off a goroutine that Fails, yet the test still delivers a completion signal,
   534			// which skews the counting.
   535			var collector = make(chan interface{})
   536	
   537			numParallel := 0
   538			startParallel := make(chan bool)
   539	
   540			for i := 0; i < len(tests); i++ {
   541				matched, err := matchString(*match, tests[i].Name)
   542				if err != nil {
   543					fmt.Fprintf(os.Stderr, "testing: invalid regexp for -test.run: %s\n", err)
   544					os.Exit(1)
   545				}
   546				if !matched {
   547					continue
   548				}
   549				testName := tests[i].Name
   550				t := &T{
   551					common: common{
   552						signal: make(chan interface{}),
   553					},
   554					name:          testName,
   555					startParallel: startParallel,
   556				}
   557				t.self = t
   558				if *chatty {
   559					fmt.Printf("=== RUN   %s\n", t.name)
   560				}
   561				go tRunner(t, &tests[i])
   562				out := (<-t.signal).(*T)
   563				if out == nil { // Parallel run.
   564					go func() {
   565						collector <- <-t.signal
   566					}()
   567					numParallel++
   568					continue
   569				}
   570				t.report()
   571				ok = ok && !out.Failed()
   572			}
   573	
   574			running := 0
   575			for numParallel+running > 0 {
   576				if running < *parallel && numParallel > 0 {
   577					startParallel <- true
   578					running++
   579					numParallel--
   580					continue
   581				}
   582				t := (<-collector).(*T)
   583				t.report()
   584				ok = ok && !t.Failed()
   585				running--
   586			}
   587		}
   588		return
   589	}
   590	
   591	// before runs before all testing.
   592	func before() {
   593		if *memProfileRate > 0 {
   594			runtime.MemProfileRate = *memProfileRate
   595		}
   596		if *cpuProfile != "" {
   597			f, err := os.Create(toOutputDir(*cpuProfile))
   598			if err != nil {
   599				fmt.Fprintf(os.Stderr, "testing: %s", err)
   600				return
   601			}
   602			if err := pprof.StartCPUProfile(f); err != nil {
   603				fmt.Fprintf(os.Stderr, "testing: can't start cpu profile: %s", err)
   604				f.Close()
   605				return
   606			}
   607			// Could save f so after can call f.Close; not worth the effort.
   608		}
   609		if *traceFile != "" {
   610			f, err := os.Create(toOutputDir(*traceFile))
   611			if err != nil {
   612				fmt.Fprintf(os.Stderr, "testing: %s", err)
   613				return
   614			}
   615			if err := trace.Start(f); err != nil {
   616				fmt.Fprintf(os.Stderr, "testing: can't start tracing: %s", err)
   617				f.Close()
   618				return
   619			}
   620			// Could save f so after can call f.Close; not worth the effort.
   621		}
   622		if *blockProfile != "" && *blockProfileRate >= 0 {
   623			runtime.SetBlockProfileRate(*blockProfileRate)
   624		}
   625		if *coverProfile != "" && cover.Mode == "" {
   626			fmt.Fprintf(os.Stderr, "testing: cannot use -test.coverprofile because test binary was not built with coverage enabled\n")
   627			os.Exit(2)
   628		}
   629	}
   630	
   631	// after runs after all testing.
   632	func after() {
   633		if *cpuProfile != "" {
   634			pprof.StopCPUProfile() // flushes profile to disk
   635		}
   636		if *traceFile != "" {
   637			trace.Stop() // flushes trace to disk
   638		}
   639		if *memProfile != "" {
   640			f, err := os.Create(toOutputDir(*memProfile))
   641			if err != nil {
   642				fmt.Fprintf(os.Stderr, "testing: %s\n", err)
   643				os.Exit(2)
   644			}
   645			runtime.GC() // materialize all statistics
   646			if err = pprof.WriteHeapProfile(f); err != nil {
   647				fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *memProfile, err)
   648				os.Exit(2)
   649			}
   650			f.Close()
   651		}
   652		if *blockProfile != "" && *blockProfileRate >= 0 {
   653			f, err := os.Create(toOutputDir(*blockProfile))
   654			if err != nil {
   655				fmt.Fprintf(os.Stderr, "testing: %s\n", err)
   656				os.Exit(2)
   657			}
   658			if err = pprof.Lookup("block").WriteTo(f, 0); err != nil {
   659				fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *blockProfile, err)
   660				os.Exit(2)
   661			}
   662			f.Close()
   663		}
   664		if cover.Mode != "" {
   665			coverReport()
   666		}
   667	}
   668	
   669	// toOutputDir returns the file name relocated, if required, to outputDir.
   670	// Simple implementation to avoid pulling in path/filepath.
   671	func toOutputDir(path string) string {
   672		if *outputDir == "" || path == "" {
   673			return path
   674		}
   675		if runtime.GOOS == "windows" {
   676			// On Windows, it's clumsy, but we can be almost always correct
   677			// by just looking for a drive letter and a colon.
   678			// Absolute paths always have a drive letter (ignoring UNC).
   679			// Problem: if path == "C:A" and outputdir == "C:\Go" it's unclear
   680			// what to do, but even then path/filepath doesn't help.
   681			// TODO: Worth doing better? Probably not, because we're here only
   682			// under the management of go test.
   683			if len(path) >= 2 {
   684				letter, colon := path[0], path[1]
   685				if ('a' <= letter && letter <= 'z' || 'A' <= letter && letter <= 'Z') && colon == ':' {
   686					// If path starts with a drive letter we're stuck with it regardless.
   687					return path
   688				}
   689			}
   690		}
   691		if os.IsPathSeparator(path[0]) {
   692			return path
   693		}
   694		return fmt.Sprintf("%s%c%s", *outputDir, os.PathSeparator, path)
   695	}
   696	
   697	var timer *time.Timer
   698	
   699	// startAlarm starts an alarm if requested.
   700	func startAlarm() {
   701		if *timeout > 0 {
   702			timer = time.AfterFunc(*timeout, func() {
   703				panic(fmt.Sprintf("test timed out after %v", *timeout))
   704			})
   705		}
   706	}
   707	
   708	// stopAlarm turns off the alarm.
   709	func stopAlarm() {
   710		if *timeout > 0 {
   711			timer.Stop()
   712		}
   713	}
   714	
   715	func parseCpuList() {
   716		for _, val := range strings.Split(*cpuListStr, ",") {
   717			val = strings.TrimSpace(val)
   718			if val == "" {
   719				continue
   720			}
   721			cpu, err := strconv.Atoi(val)
   722			if err != nil || cpu <= 0 {
   723				fmt.Fprintf(os.Stderr, "testing: invalid value %q for -test.cpu\n", val)
   724				os.Exit(1)
   725			}
   726			for i := uint(0); i < *count; i++ {
   727				cpuList = append(cpuList, cpu)
   728			}
   729		}
   730		if cpuList == nil {
   731			for i := uint(0); i < *count; i++ {
   732				cpuList = append(cpuList, runtime.GOMAXPROCS(-1))
   733			}
   734		}
   735	}
   736	

View as plain text