github.com/sean-/go@v0.0.0-20151219100004-97f854cd7bb6/src/testing/testing.go (about) 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/debug" 153 "runtime/pprof" 154 "runtime/trace" 155 "strconv" 156 "strings" 157 "sync" 158 "time" 159 ) 160 161 var ( 162 // The short flag requests that tests run more quickly, but its functionality 163 // is provided by test writers themselves. The testing package is just its 164 // home. The all.bash installation script sets it to make installation more 165 // efficient, but by default the flag is off so a plain "go test" will do a 166 // full test of the package. 167 short = flag.Bool("test.short", false, "run smaller test suite to save time") 168 169 // The directory in which to create profile files and the like. When run from 170 // "go test", the binary always runs in the source directory for the package; 171 // this flag lets "go test" tell the binary to write the files in the directory where 172 // the "go test" command is run. 173 outputDir = flag.String("test.outputdir", "", "directory in which to write profiles") 174 175 // Report as tests are run; default is silent for success. 176 chatty = flag.Bool("test.v", false, "verbose: print additional output") 177 count = flag.Uint("test.count", 1, "run tests and benchmarks `n` times") 178 coverProfile = flag.String("test.coverprofile", "", "write a coverage profile to the named file after execution") 179 match = flag.String("test.run", "", "regular expression to select tests and examples to run") 180 memProfile = flag.String("test.memprofile", "", "write a memory profile to the named file after execution") 181 memProfileRate = flag.Int("test.memprofilerate", 0, "if >=0, sets runtime.MemProfileRate") 182 cpuProfile = flag.String("test.cpuprofile", "", "write a cpu profile to the named file during execution") 183 blockProfile = flag.String("test.blockprofile", "", "write a goroutine blocking profile to the named file after execution") 184 blockProfileRate = flag.Int("test.blockprofilerate", 1, "if >= 0, calls runtime.SetBlockProfileRate()") 185 traceFile = flag.String("test.trace", "", "write an execution trace to the named file after execution") 186 timeout = flag.Duration("test.timeout", 0, "if positive, sets an aggregate time limit for all tests") 187 cpuListStr = flag.String("test.cpu", "", "comma-separated list of number of CPUs to use for each test") 188 parallel = flag.Int("test.parallel", runtime.GOMAXPROCS(0), "maximum test parallelism") 189 190 haveExamples bool // are there examples? 191 192 cpuList []int 193 ) 194 195 // common holds the elements common between T and B and 196 // captures common methods such as Errorf. 197 type common struct { 198 mu sync.RWMutex // guards output and failed 199 output []byte // Output generated by test or benchmark. 200 failed bool // Test or benchmark has failed. 201 skipped bool // Test of benchmark has been skipped. 202 finished bool 203 204 start time.Time // Time test or benchmark started 205 duration time.Duration 206 self interface{} // To be sent on signal channel when done. 207 signal chan interface{} // Output for serial tests. 208 } 209 210 // Short reports whether the -test.short flag is set. 211 func Short() bool { 212 return *short 213 } 214 215 // Verbose reports whether the -test.v flag is set. 216 func Verbose() bool { 217 return *chatty 218 } 219 220 // decorate prefixes the string with the file and line of the call site 221 // and inserts the final newline if needed and indentation tabs for formatting. 222 func decorate(s string) string { 223 _, file, line, ok := runtime.Caller(3) // decorate + log + public function. 224 if ok { 225 // Truncate file name at last file name separator. 226 if index := strings.LastIndex(file, "/"); index >= 0 { 227 file = file[index+1:] 228 } else if index = strings.LastIndex(file, "\\"); index >= 0 { 229 file = file[index+1:] 230 } 231 } else { 232 file = "???" 233 line = 1 234 } 235 buf := new(bytes.Buffer) 236 // Every line is indented at least one tab. 237 buf.WriteByte('\t') 238 fmt.Fprintf(buf, "%s:%d: ", file, line) 239 lines := strings.Split(s, "\n") 240 if l := len(lines); l > 1 && lines[l-1] == "" { 241 lines = lines[:l-1] 242 } 243 for i, line := range lines { 244 if i > 0 { 245 // Second and subsequent lines are indented an extra tab. 246 buf.WriteString("\n\t\t") 247 } 248 buf.WriteString(line) 249 } 250 buf.WriteByte('\n') 251 return buf.String() 252 } 253 254 // fmtDuration returns a string representing d in the form "87.00s". 255 func fmtDuration(d time.Duration) string { 256 return fmt.Sprintf("%.2fs", d.Seconds()) 257 } 258 259 // TB is the interface common to T and B. 260 type TB interface { 261 Error(args ...interface{}) 262 Errorf(format string, args ...interface{}) 263 Fail() 264 FailNow() 265 Failed() bool 266 Fatal(args ...interface{}) 267 Fatalf(format string, args ...interface{}) 268 Log(args ...interface{}) 269 Logf(format string, args ...interface{}) 270 Skip(args ...interface{}) 271 SkipNow() 272 Skipf(format string, args ...interface{}) 273 Skipped() bool 274 275 // A private method to prevent users implementing the 276 // interface and so future additions to it will not 277 // violate Go 1 compatibility. 278 private() 279 } 280 281 var _ TB = (*T)(nil) 282 var _ TB = (*B)(nil) 283 284 // T is a type passed to Test functions to manage test state and support formatted test logs. 285 // Logs are accumulated during execution and dumped to standard error when done. 286 // 287 // A test ends when its Test function returns or calls any of the methods 288 // FailNow, Fatal, Fatalf, SkipNow, Skip, or Skipf. Those methods, as well as 289 // the Parallel method, must be called only from the goroutine running the 290 // Test function. 291 // 292 // The other reporting methods, such as the variations of Log and Error, 293 // may be called simultaneously from multiple goroutines. 294 type T struct { 295 common 296 name string // Name of test. 297 startParallel chan bool // Parallel tests will wait on this. 298 } 299 300 func (c *common) private() {} 301 302 // Fail marks the function as having failed but continues execution. 303 func (c *common) Fail() { 304 c.mu.Lock() 305 defer c.mu.Unlock() 306 c.failed = true 307 } 308 309 // Failed reports whether the function has failed. 310 func (c *common) Failed() bool { 311 c.mu.RLock() 312 defer c.mu.RUnlock() 313 return c.failed 314 } 315 316 // FailNow marks the function as having failed and stops its execution. 317 // Execution will continue at the next test or benchmark. 318 // FailNow must be called from the goroutine running the 319 // test or benchmark function, not from other goroutines 320 // created during the test. Calling FailNow does not stop 321 // those other goroutines. 322 func (c *common) FailNow() { 323 c.Fail() 324 325 // Calling runtime.Goexit will exit the goroutine, which 326 // will run the deferred functions in this goroutine, 327 // which will eventually run the deferred lines in tRunner, 328 // which will signal to the test loop that this test is done. 329 // 330 // A previous version of this code said: 331 // 332 // c.duration = ... 333 // c.signal <- c.self 334 // runtime.Goexit() 335 // 336 // This previous version duplicated code (those lines are in 337 // tRunner no matter what), but worse the goroutine teardown 338 // implicit in runtime.Goexit was not guaranteed to complete 339 // before the test exited. If a test deferred an important cleanup 340 // function (like removing temporary files), there was no guarantee 341 // it would run on a test failure. Because we send on c.signal during 342 // a top-of-stack deferred function now, we know that the send 343 // only happens after any other stacked defers have completed. 344 c.finished = true 345 runtime.Goexit() 346 } 347 348 // log generates the output. It's always at the same stack depth. 349 func (c *common) log(s string) { 350 c.mu.Lock() 351 defer c.mu.Unlock() 352 c.output = append(c.output, decorate(s)...) 353 } 354 355 // Log formats its arguments using default formatting, analogous to Println, 356 // and records the text in the error log. For tests, the text will be printed only if 357 // the test fails or the -test.v flag is set. For benchmarks, the text is always 358 // printed to avoid having performance depend on the value of the -test.v flag. 359 func (c *common) Log(args ...interface{}) { c.log(fmt.Sprintln(args...)) } 360 361 // Logf formats its arguments according to the format, analogous to Printf, 362 // and records the text in the error log. For tests, the text will be printed only if 363 // the test fails or the -test.v flag is set. For benchmarks, the text is always 364 // printed to avoid having performance depend on the value of the -test.v flag. 365 func (c *common) Logf(format string, args ...interface{}) { c.log(fmt.Sprintf(format, args...)) } 366 367 // Error is equivalent to Log followed by Fail. 368 func (c *common) Error(args ...interface{}) { 369 c.log(fmt.Sprintln(args...)) 370 c.Fail() 371 } 372 373 // Errorf is equivalent to Logf followed by Fail. 374 func (c *common) Errorf(format string, args ...interface{}) { 375 c.log(fmt.Sprintf(format, args...)) 376 c.Fail() 377 } 378 379 // Fatal is equivalent to Log followed by FailNow. 380 func (c *common) Fatal(args ...interface{}) { 381 c.log(fmt.Sprintln(args...)) 382 c.FailNow() 383 } 384 385 // Fatalf is equivalent to Logf followed by FailNow. 386 func (c *common) Fatalf(format string, args ...interface{}) { 387 c.log(fmt.Sprintf(format, args...)) 388 c.FailNow() 389 } 390 391 // Skip is equivalent to Log followed by SkipNow. 392 func (c *common) Skip(args ...interface{}) { 393 c.log(fmt.Sprintln(args...)) 394 c.SkipNow() 395 } 396 397 // Skipf is equivalent to Logf followed by SkipNow. 398 func (c *common) Skipf(format string, args ...interface{}) { 399 c.log(fmt.Sprintf(format, args...)) 400 c.SkipNow() 401 } 402 403 // SkipNow marks the test as having been skipped and stops its execution. 404 // Execution will continue at the next test or benchmark. See also FailNow. 405 // SkipNow must be called from the goroutine running the test, not from 406 // other goroutines created during the test. Calling SkipNow does not stop 407 // those other goroutines. 408 func (c *common) SkipNow() { 409 c.skip() 410 c.finished = true 411 runtime.Goexit() 412 } 413 414 func (c *common) skip() { 415 c.mu.Lock() 416 defer c.mu.Unlock() 417 c.skipped = true 418 } 419 420 // Skipped reports whether the test was skipped. 421 func (c *common) Skipped() bool { 422 c.mu.RLock() 423 defer c.mu.RUnlock() 424 return c.skipped 425 } 426 427 // Parallel signals that this test is to be run in parallel with (and only with) 428 // other parallel tests. 429 func (t *T) Parallel() { 430 // We don't want to include the time we spend waiting for serial tests 431 // in the test duration. Record the elapsed time thus far and reset the 432 // timer afterwards. 433 t.duration += time.Since(t.start) 434 t.signal <- (*T)(nil) // Release main testing loop 435 <-t.startParallel // Wait for serial tests to finish 436 t.start = time.Now() 437 } 438 439 // An internal type but exported because it is cross-package; part of the implementation 440 // of the "go test" command. 441 type InternalTest struct { 442 Name string 443 F func(*T) 444 } 445 446 func tRunner(t *T, test *InternalTest) { 447 // When this goroutine is done, either because test.F(t) 448 // returned normally or because a test failure triggered 449 // a call to runtime.Goexit, record the duration and send 450 // a signal saying that the test is done. 451 defer func() { 452 t.duration += time.Now().Sub(t.start) 453 // If the test panicked, print any test output before dying. 454 err := recover() 455 if !t.finished && err == nil { 456 err = fmt.Errorf("test executed panic(nil) or runtime.Goexit") 457 } 458 if err != nil { 459 t.Fail() 460 t.report() 461 panic(err) 462 } 463 t.signal <- t 464 }() 465 466 t.start = time.Now() 467 test.F(t) 468 t.finished = true 469 } 470 471 // An internal function but exported because it is cross-package; part of the implementation 472 // of the "go test" command. 473 func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample) { 474 os.Exit(MainStart(matchString, tests, benchmarks, examples).Run()) 475 } 476 477 // M is a type passed to a TestMain function to run the actual tests. 478 type M struct { 479 matchString func(pat, str string) (bool, error) 480 tests []InternalTest 481 benchmarks []InternalBenchmark 482 examples []InternalExample 483 } 484 485 // MainStart is meant for use by tests generated by 'go test'. 486 // It is not meant to be called directly and is not subject to the Go 1 compatibility document. 487 // It may change signature from release to release. 488 func MainStart(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample) *M { 489 return &M{ 490 matchString: matchString, 491 tests: tests, 492 benchmarks: benchmarks, 493 examples: examples, 494 } 495 } 496 497 // Run runs the tests. It returns an exit code to pass to os.Exit. 498 func (m *M) Run() int { 499 // TestMain may have already called flag.Parse. 500 if !flag.Parsed() { 501 flag.Parse() 502 } 503 504 parseCpuList() 505 506 before() 507 startAlarm() 508 haveExamples = len(m.examples) > 0 509 testOk := RunTests(m.matchString, m.tests) 510 exampleOk := RunExamples(m.matchString, m.examples) 511 stopAlarm() 512 if !testOk || !exampleOk { 513 fmt.Println("FAIL") 514 after() 515 return 1 516 } 517 fmt.Println("PASS") 518 RunBenchmarks(m.matchString, m.benchmarks) 519 after() 520 return 0 521 } 522 523 func (t *T) report() { 524 dstr := fmtDuration(t.duration) 525 format := "--- %s: %s (%s)\n%s" 526 if t.Failed() { 527 fmt.Printf(format, "FAIL", t.name, dstr, t.output) 528 } else if *chatty { 529 if t.Skipped() { 530 fmt.Printf(format, "SKIP", t.name, dstr, t.output) 531 } else { 532 fmt.Printf(format, "PASS", t.name, dstr, t.output) 533 } 534 } 535 } 536 537 func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool) { 538 ok = true 539 if len(tests) == 0 && !haveExamples { 540 fmt.Fprintln(os.Stderr, "testing: warning: no tests to run") 541 return 542 } 543 for _, procs := range cpuList { 544 runtime.GOMAXPROCS(procs) 545 // We build a new channel tree for each run of the loop. 546 // collector merges in one channel all the upstream signals from parallel tests. 547 // If all tests pump to the same channel, a bug can occur where a test 548 // kicks off a goroutine that Fails, yet the test still delivers a completion signal, 549 // which skews the counting. 550 var collector = make(chan interface{}) 551 552 numParallel := 0 553 startParallel := make(chan bool) 554 555 for i := 0; i < len(tests); i++ { 556 matched, err := matchString(*match, tests[i].Name) 557 if err != nil { 558 fmt.Fprintf(os.Stderr, "testing: invalid regexp for -test.run: %s\n", err) 559 os.Exit(1) 560 } 561 if !matched { 562 continue 563 } 564 testName := tests[i].Name 565 t := &T{ 566 common: common{ 567 signal: make(chan interface{}), 568 }, 569 name: testName, 570 startParallel: startParallel, 571 } 572 t.self = t 573 if *chatty { 574 fmt.Printf("=== RUN %s\n", t.name) 575 } 576 go tRunner(t, &tests[i]) 577 out := (<-t.signal).(*T) 578 if out == nil { // Parallel run. 579 go func() { 580 collector <- <-t.signal 581 }() 582 numParallel++ 583 continue 584 } 585 t.report() 586 ok = ok && !out.Failed() 587 } 588 589 running := 0 590 for numParallel+running > 0 { 591 if running < *parallel && numParallel > 0 { 592 startParallel <- true 593 running++ 594 numParallel-- 595 continue 596 } 597 t := (<-collector).(*T) 598 t.report() 599 ok = ok && !t.Failed() 600 running-- 601 } 602 } 603 return 604 } 605 606 // before runs before all testing. 607 func before() { 608 if *memProfileRate > 0 { 609 runtime.MemProfileRate = *memProfileRate 610 } 611 if *cpuProfile != "" { 612 f, err := os.Create(toOutputDir(*cpuProfile)) 613 if err != nil { 614 fmt.Fprintf(os.Stderr, "testing: %s", err) 615 return 616 } 617 if err := pprof.StartCPUProfile(f); err != nil { 618 fmt.Fprintf(os.Stderr, "testing: can't start cpu profile: %s", err) 619 f.Close() 620 return 621 } 622 // Could save f so after can call f.Close; not worth the effort. 623 } 624 if *traceFile != "" { 625 f, err := os.Create(toOutputDir(*traceFile)) 626 if err != nil { 627 fmt.Fprintf(os.Stderr, "testing: %s", err) 628 return 629 } 630 if err := trace.Start(f); err != nil { 631 fmt.Fprintf(os.Stderr, "testing: can't start tracing: %s", err) 632 f.Close() 633 return 634 } 635 // Could save f so after can call f.Close; not worth the effort. 636 } 637 if *blockProfile != "" && *blockProfileRate >= 0 { 638 runtime.SetBlockProfileRate(*blockProfileRate) 639 } 640 if *coverProfile != "" && cover.Mode == "" { 641 fmt.Fprintf(os.Stderr, "testing: cannot use -test.coverprofile because test binary was not built with coverage enabled\n") 642 os.Exit(2) 643 } 644 } 645 646 // after runs after all testing. 647 func after() { 648 if *cpuProfile != "" { 649 pprof.StopCPUProfile() // flushes profile to disk 650 } 651 if *traceFile != "" { 652 trace.Stop() // flushes trace to disk 653 } 654 if *memProfile != "" { 655 f, err := os.Create(toOutputDir(*memProfile)) 656 if err != nil { 657 fmt.Fprintf(os.Stderr, "testing: %s\n", err) 658 os.Exit(2) 659 } 660 runtime.GC() // materialize all statistics 661 if err = pprof.WriteHeapProfile(f); err != nil { 662 fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *memProfile, err) 663 os.Exit(2) 664 } 665 f.Close() 666 } 667 if *blockProfile != "" && *blockProfileRate >= 0 { 668 f, err := os.Create(toOutputDir(*blockProfile)) 669 if err != nil { 670 fmt.Fprintf(os.Stderr, "testing: %s\n", err) 671 os.Exit(2) 672 } 673 if err = pprof.Lookup("block").WriteTo(f, 0); err != nil { 674 fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *blockProfile, err) 675 os.Exit(2) 676 } 677 f.Close() 678 } 679 if cover.Mode != "" { 680 coverReport() 681 } 682 } 683 684 // toOutputDir returns the file name relocated, if required, to outputDir. 685 // Simple implementation to avoid pulling in path/filepath. 686 func toOutputDir(path string) string { 687 if *outputDir == "" || path == "" { 688 return path 689 } 690 if runtime.GOOS == "windows" { 691 // On Windows, it's clumsy, but we can be almost always correct 692 // by just looking for a drive letter and a colon. 693 // Absolute paths always have a drive letter (ignoring UNC). 694 // Problem: if path == "C:A" and outputdir == "C:\Go" it's unclear 695 // what to do, but even then path/filepath doesn't help. 696 // TODO: Worth doing better? Probably not, because we're here only 697 // under the management of go test. 698 if len(path) >= 2 { 699 letter, colon := path[0], path[1] 700 if ('a' <= letter && letter <= 'z' || 'A' <= letter && letter <= 'Z') && colon == ':' { 701 // If path starts with a drive letter we're stuck with it regardless. 702 return path 703 } 704 } 705 } 706 if os.IsPathSeparator(path[0]) { 707 return path 708 } 709 return fmt.Sprintf("%s%c%s", *outputDir, os.PathSeparator, path) 710 } 711 712 var timer *time.Timer 713 714 // startAlarm starts an alarm if requested. 715 func startAlarm() { 716 if *timeout > 0 { 717 timer = time.AfterFunc(*timeout, func() { 718 debug.SetTraceback("all") 719 panic(fmt.Sprintf("test timed out after %v", *timeout)) 720 }) 721 } 722 } 723 724 // stopAlarm turns off the alarm. 725 func stopAlarm() { 726 if *timeout > 0 { 727 timer.Stop() 728 } 729 } 730 731 func parseCpuList() { 732 for _, val := range strings.Split(*cpuListStr, ",") { 733 val = strings.TrimSpace(val) 734 if val == "" { 735 continue 736 } 737 cpu, err := strconv.Atoi(val) 738 if err != nil || cpu <= 0 { 739 fmt.Fprintf(os.Stderr, "testing: invalid value %q for -test.cpu\n", val) 740 os.Exit(1) 741 } 742 for i := uint(0); i < *count; i++ { 743 cpuList = append(cpuList, cpu) 744 } 745 } 746 if cpuList == nil { 747 for i := uint(0); i < *count; i++ { 748 cpuList = append(cpuList, runtime.GOMAXPROCS(-1)) 749 } 750 } 751 }