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