Source file src/testing/testing.go

Documentation: testing

		 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 does not start with a lowercase letter. The function name
		10  // 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  // A simple test function looks like this:
		21  //
		22  //		 func TestAbs(t *testing.T) {
		23  //				 got := Abs(-1)
		24  //				 if got != 1 {
		25  //						 t.Errorf("Abs(-1) = %d; want 1", got)
		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-Testing_flags
		38  //
		39  // A sample benchmark function looks like this:
		40  //		 func BenchmarkRandInt(b *testing.B) {
		41  //				 for i := 0; i < b.N; i++ {
		42  //						 rand.Int()
		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  //		 BenchmarkRandInt-8	 	68453040					17.8 ns/op
		50  // means that the loop ran 68453040 times at a speed of 17.8 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  // The comment prefix "Unordered output:" is like "Output:", but matches any
		99  // line order:
	 100  //
	 101  //		 func ExamplePerm() {
	 102  //				 for _, value := range Perm(5) {
	 103  //						 fmt.Println(value)
	 104  //				 }
	 105  //				 // Unordered output: 4
	 106  //				 // 2
	 107  //				 // 1
	 108  //				 // 3
	 109  //				 // 0
	 110  //		 }
	 111  //
	 112  // Example functions without output comments are compiled but not executed.
	 113  //
	 114  // The naming convention to declare examples for the package, a function F, a type T and
	 115  // method M on type T are:
	 116  //
	 117  //		 func Example() { ... }
	 118  //		 func ExampleF() { ... }
	 119  //		 func ExampleT() { ... }
	 120  //		 func ExampleT_M() { ... }
	 121  //
	 122  // Multiple example functions for a package/type/function/method may be provided by
	 123  // appending a distinct suffix to the name. The suffix must start with a
	 124  // lower-case letter.
	 125  //
	 126  //		 func Example_suffix() { ... }
	 127  //		 func ExampleF_suffix() { ... }
	 128  //		 func ExampleT_suffix() { ... }
	 129  //		 func ExampleT_M_suffix() { ... }
	 130  //
	 131  // The entire test file is presented as the example when it contains a single
	 132  // example function, at least one other function, type, variable, or constant
	 133  // declaration, and no test or benchmark functions.
	 134  //
	 135  // Skipping
	 136  //
	 137  // Tests or benchmarks may be skipped at run time with a call to
	 138  // the Skip method of *T or *B:
	 139  //
	 140  //		 func TestTimeConsuming(t *testing.T) {
	 141  //				 if testing.Short() {
	 142  //						 t.Skip("skipping test in short mode.")
	 143  //				 }
	 144  //				 ...
	 145  //		 }
	 146  //
	 147  // Subtests and Sub-benchmarks
	 148  //
	 149  // The Run methods of T and B allow defining subtests and sub-benchmarks,
	 150  // without having to define separate functions for each. This enables uses
	 151  // like table-driven benchmarks and creating hierarchical tests.
	 152  // It also provides a way to share common setup and tear-down code:
	 153  //
	 154  //		 func TestFoo(t *testing.T) {
	 155  //				 // <setup code>
	 156  //				 t.Run("A=1", func(t *testing.T) { ... })
	 157  //				 t.Run("A=2", func(t *testing.T) { ... })
	 158  //				 t.Run("B=1", func(t *testing.T) { ... })
	 159  //				 // <tear-down code>
	 160  //		 }
	 161  //
	 162  // Each subtest and sub-benchmark has a unique name: the combination of the name
	 163  // of the top-level test and the sequence of names passed to Run, separated by
	 164  // slashes, with an optional trailing sequence number for disambiguation.
	 165  //
	 166  // The argument to the -run and -bench command-line flags is an unanchored regular
	 167  // expression that matches the test's name. For tests with multiple slash-separated
	 168  // elements, such as subtests, the argument is itself slash-separated, with
	 169  // expressions matching each name element in turn. Because it is unanchored, an
	 170  // empty expression matches any string.
	 171  // For example, using "matching" to mean "whose name contains":
	 172  //
	 173  //		 go test -run ''			# Run all tests.
	 174  //		 go test -run Foo		 # Run top-level tests matching "Foo", such as "TestFooBar".
	 175  //		 go test -run Foo/A=	# For top-level tests matching "Foo", run subtests matching "A=".
	 176  //		 go test -run /A=1		# For all top-level tests, run subtests matching "A=1".
	 177  //
	 178  // Subtests can also be used to control parallelism. A parent test will only
	 179  // complete once all of its subtests complete. In this example, all tests are
	 180  // run in parallel with each other, and only with each other, regardless of
	 181  // other top-level tests that may be defined:
	 182  //
	 183  //		 func TestGroupedParallel(t *testing.T) {
	 184  //				 for _, tc := range tests {
	 185  //						 tc := tc // capture range variable
	 186  //						 t.Run(tc.Name, func(t *testing.T) {
	 187  //								 t.Parallel()
	 188  //								 ...
	 189  //						 })
	 190  //				 }
	 191  //		 }
	 192  //
	 193  // The race detector kills the program if it exceeds 8128 concurrent goroutines,
	 194  // so use care when running parallel tests with the -race flag set.
	 195  //
	 196  // Run does not return until parallel subtests have completed, providing a way
	 197  // to clean up after a group of parallel tests:
	 198  //
	 199  //		 func TestTeardownParallel(t *testing.T) {
	 200  //				 // This Run will not return until the parallel tests finish.
	 201  //				 t.Run("group", func(t *testing.T) {
	 202  //						 t.Run("Test1", parallelTest1)
	 203  //						 t.Run("Test2", parallelTest2)
	 204  //						 t.Run("Test3", parallelTest3)
	 205  //				 })
	 206  //				 // <tear-down code>
	 207  //		 }
	 208  //
	 209  // Main
	 210  //
	 211  // It is sometimes necessary for a test or benchmark program to do extra setup or teardown
	 212  // before or after it executes. It is also sometimes necessary to control
	 213  // which code runs on the main thread. To support these and other cases,
	 214  // if a test file contains a function:
	 215  //
	 216  //	func TestMain(m *testing.M)
	 217  //
	 218  // then the generated test will call TestMain(m) instead of running the tests or benchmarks
	 219  // directly. TestMain runs in the main goroutine and can do whatever setup
	 220  // and teardown is necessary around a call to m.Run. m.Run will return an exit
	 221  // code that may be passed to os.Exit. If TestMain returns, the test wrapper
	 222  // will pass the result of m.Run to os.Exit itself.
	 223  //
	 224  // When TestMain is called, flag.Parse has not been run. If TestMain depends on
	 225  // command-line flags, including those of the testing package, it should call
	 226  // flag.Parse explicitly. Command line flags are always parsed by the time test
	 227  // or benchmark functions run.
	 228  //
	 229  // A simple implementation of TestMain is:
	 230  //
	 231  //	func TestMain(m *testing.M) {
	 232  //		// call flag.Parse() here if TestMain uses flags
	 233  //		os.Exit(m.Run())
	 234  //	}
	 235  //
	 236  // TestMain is a low-level primitive and should not be necessary for casual
	 237  // testing needs, where ordinary test functions suffice.
	 238  package testing
	 239  
	 240  import (
	 241  	"bytes"
	 242  	"errors"
	 243  	"flag"
	 244  	"fmt"
	 245  	"internal/race"
	 246  	"io"
	 247  	"math/rand"
	 248  	"os"
	 249  	"runtime"
	 250  	"runtime/debug"
	 251  	"runtime/trace"
	 252  	"strconv"
	 253  	"strings"
	 254  	"sync"
	 255  	"sync/atomic"
	 256  	"time"
	 257  	"unicode"
	 258  	"unicode/utf8"
	 259  )
	 260  
	 261  var initRan bool
	 262  
	 263  // Init registers testing flags. These flags are automatically registered by
	 264  // the "go test" command before running test functions, so Init is only needed
	 265  // when calling functions such as Benchmark without using "go test".
	 266  //
	 267  // Init has no effect if it was already called.
	 268  func Init() {
	 269  	if initRan {
	 270  		return
	 271  	}
	 272  	initRan = true
	 273  	// The short flag requests that tests run more quickly, but its functionality
	 274  	// is provided by test writers themselves. The testing package is just its
	 275  	// home. The all.bash installation script sets it to make installation more
	 276  	// efficient, but by default the flag is off so a plain "go test" will do a
	 277  	// full test of the package.
	 278  	short = flag.Bool("test.short", false, "run smaller test suite to save time")
	 279  
	 280  	// The failfast flag requests that test execution stop after the first test failure.
	 281  	failFast = flag.Bool("test.failfast", false, "do not start new tests after the first test failure")
	 282  
	 283  	// The directory in which to create profile files and the like. When run from
	 284  	// "go test", the binary always runs in the source directory for the package;
	 285  	// this flag lets "go test" tell the binary to write the files in the directory where
	 286  	// the "go test" command is run.
	 287  	outputDir = flag.String("test.outputdir", "", "write profiles to `dir`")
	 288  	// Report as tests are run; default is silent for success.
	 289  	chatty = flag.Bool("test.v", false, "verbose: print additional output")
	 290  	count = flag.Uint("test.count", 1, "run tests and benchmarks `n` times")
	 291  	coverProfile = flag.String("test.coverprofile", "", "write a coverage profile to `file`")
	 292  	matchList = flag.String("test.list", "", "list tests, examples, and benchmarks matching `regexp` then exit")
	 293  	match = flag.String("test.run", "", "run only tests and examples matching `regexp`")
	 294  	memProfile = flag.String("test.memprofile", "", "write an allocation profile to `file`")
	 295  	memProfileRate = flag.Int("test.memprofilerate", 0, "set memory allocation profiling `rate` (see runtime.MemProfileRate)")
	 296  	cpuProfile = flag.String("test.cpuprofile", "", "write a cpu profile to `file`")
	 297  	blockProfile = flag.String("test.blockprofile", "", "write a goroutine blocking profile to `file`")
	 298  	blockProfileRate = flag.Int("test.blockprofilerate", 1, "set blocking profile `rate` (see runtime.SetBlockProfileRate)")
	 299  	mutexProfile = flag.String("test.mutexprofile", "", "write a mutex contention profile to the named file after execution")
	 300  	mutexProfileFraction = flag.Int("test.mutexprofilefraction", 1, "if >= 0, calls runtime.SetMutexProfileFraction()")
	 301  	panicOnExit0 = flag.Bool("test.paniconexit0", false, "panic on call to os.Exit(0)")
	 302  	traceFile = flag.String("test.trace", "", "write an execution trace to `file`")
	 303  	timeout = flag.Duration("test.timeout", 0, "panic test binary after duration `d` (default 0, timeout disabled)")
	 304  	cpuListStr = flag.String("test.cpu", "", "comma-separated `list` of cpu counts to run each test with")
	 305  	parallel = flag.Int("test.parallel", runtime.GOMAXPROCS(0), "run at most `n` tests in parallel")
	 306  	testlog = flag.String("test.testlogfile", "", "write test action log to `file` (for use only by cmd/go)")
	 307  	shuffle = flag.String("test.shuffle", "off", "randomize the execution order of tests and benchmarks")
	 308  
	 309  	initBenchmarkFlags()
	 310  }
	 311  
	 312  var (
	 313  	// Flags, registered during Init.
	 314  	short								*bool
	 315  	failFast						 *bool
	 316  	outputDir						*string
	 317  	chatty							 *bool
	 318  	count								*uint
	 319  	coverProfile				 *string
	 320  	matchList						*string
	 321  	match								*string
	 322  	memProfile					 *string
	 323  	memProfileRate			 *int
	 324  	cpuProfile					 *string
	 325  	blockProfile				 *string
	 326  	blockProfileRate		 *int
	 327  	mutexProfile				 *string
	 328  	mutexProfileFraction *int
	 329  	panicOnExit0				 *bool
	 330  	traceFile						*string
	 331  	timeout							*time.Duration
	 332  	cpuListStr					 *string
	 333  	parallel						 *int
	 334  	shuffle							*string
	 335  	testlog							*string
	 336  
	 337  	haveExamples bool // are there examples?
	 338  
	 339  	cpuList		 []int
	 340  	testlogFile *os.File
	 341  
	 342  	numFailed uint32 // number of test failures
	 343  )
	 344  
	 345  type chattyPrinter struct {
	 346  	w					io.Writer
	 347  	lastNameMu sync.Mutex // guards lastName
	 348  	lastName	 string		 // last printed test name in chatty mode
	 349  }
	 350  
	 351  func newChattyPrinter(w io.Writer) *chattyPrinter {
	 352  	return &chattyPrinter{w: w}
	 353  }
	 354  
	 355  // Updatef prints a message about the status of the named test to w.
	 356  //
	 357  // The formatted message must include the test name itself.
	 358  func (p *chattyPrinter) Updatef(testName, format string, args ...interface{}) {
	 359  	p.lastNameMu.Lock()
	 360  	defer p.lastNameMu.Unlock()
	 361  
	 362  	// Since the message already implies an association with a specific new test,
	 363  	// we don't need to check what the old test name was or log an extra CONT line
	 364  	// for it. (We're updating it anyway, and the current message already includes
	 365  	// the test name.)
	 366  	p.lastName = testName
	 367  	fmt.Fprintf(p.w, format, args...)
	 368  }
	 369  
	 370  // Printf prints a message, generated by the named test, that does not
	 371  // necessarily mention that tests's name itself.
	 372  func (p *chattyPrinter) Printf(testName, format string, args ...interface{}) {
	 373  	p.lastNameMu.Lock()
	 374  	defer p.lastNameMu.Unlock()
	 375  
	 376  	if p.lastName == "" {
	 377  		p.lastName = testName
	 378  	} else if p.lastName != testName {
	 379  		fmt.Fprintf(p.w, "=== CONT	%s\n", testName)
	 380  		p.lastName = testName
	 381  	}
	 382  
	 383  	fmt.Fprintf(p.w, format, args...)
	 384  }
	 385  
	 386  // The maximum number of stack frames to go through when skipping helper functions for
	 387  // the purpose of decorating log messages.
	 388  const maxStackLen = 50
	 389  
	 390  // common holds the elements common between T and B and
	 391  // captures common methods such as Errorf.
	 392  type common struct {
	 393  	mu					sync.RWMutex				 // guards this group of fields
	 394  	output			[]byte							 // Output generated by test or benchmark.
	 395  	w					 io.Writer						// For flushToParent.
	 396  	ran				 bool								 // Test or benchmark (or one of its subtests) was executed.
	 397  	failed			bool								 // Test or benchmark has failed.
	 398  	skipped		 bool								 // Test or benchmark has been skipped.
	 399  	done				bool								 // Test is finished and all subtests have completed.
	 400  	helperPCs	 map[uintptr]struct{} // functions to be skipped when writing file/line info
	 401  	helperNames map[string]struct{}	// helperPCs converted to function names
	 402  	cleanups		[]func()						 // optional functions to be called at the end of the test
	 403  	cleanupName string							 // Name of the cleanup function.
	 404  	cleanupPc	 []uintptr						// The stack trace at the point where Cleanup was called.
	 405  	finished		bool								 // Test function has completed.
	 406  
	 407  	chatty		 *chattyPrinter // A copy of chattyPrinter, if the chatty flag is set.
	 408  	bench			bool					 // Whether the current test is a benchmark.
	 409  	hasSub		 int32					// Written atomically.
	 410  	raceErrors int						// Number of races detected during test.
	 411  	runner		 string				 // Function name of tRunner running the test.
	 412  
	 413  	parent	 *common
	 414  	level		int			 // Nesting depth of test or benchmark.
	 415  	creator	[]uintptr // If level > 0, the stack trace at the point where the parent called t.Run.
	 416  	name		 string		// Name of test or benchmark.
	 417  	start		time.Time // Time test or benchmark started
	 418  	duration time.Duration
	 419  	barrier	chan bool // To signal parallel subtests they may start.
	 420  	signal	 chan bool // To signal a test is done.
	 421  	sub			[]*T			// Queue of subtests to be run in parallel.
	 422  
	 423  	tempDirMu	sync.Mutex
	 424  	tempDir		string
	 425  	tempDirErr error
	 426  	tempDirSeq int32
	 427  }
	 428  
	 429  // Short reports whether the -test.short flag is set.
	 430  func Short() bool {
	 431  	if short == nil {
	 432  		panic("testing: Short called before Init")
	 433  	}
	 434  	// Catch code that calls this from TestMain without first calling flag.Parse.
	 435  	if !flag.Parsed() {
	 436  		panic("testing: Short called before Parse")
	 437  	}
	 438  
	 439  	return *short
	 440  }
	 441  
	 442  // CoverMode reports what the test coverage mode is set to. The
	 443  // values are "set", "count", or "atomic". The return value will be
	 444  // empty if test coverage is not enabled.
	 445  func CoverMode() string {
	 446  	return cover.Mode
	 447  }
	 448  
	 449  // Verbose reports whether the -test.v flag is set.
	 450  func Verbose() bool {
	 451  	// Same as in Short.
	 452  	if chatty == nil {
	 453  		panic("testing: Verbose called before Init")
	 454  	}
	 455  	if !flag.Parsed() {
	 456  		panic("testing: Verbose called before Parse")
	 457  	}
	 458  	return *chatty
	 459  }
	 460  
	 461  // frameSkip searches, starting after skip frames, for the first caller frame
	 462  // in a function not marked as a helper and returns that frame.
	 463  // The search stops if it finds a tRunner function that
	 464  // was the entry point into the test and the test is not a subtest.
	 465  // This function must be called with c.mu held.
	 466  func (c *common) frameSkip(skip int) runtime.Frame {
	 467  	// If the search continues into the parent test, we'll have to hold
	 468  	// its mu temporarily. If we then return, we need to unlock it.
	 469  	shouldUnlock := false
	 470  	defer func() {
	 471  		if shouldUnlock {
	 472  			c.mu.Unlock()
	 473  		}
	 474  	}()
	 475  	var pc [maxStackLen]uintptr
	 476  	// Skip two extra frames to account for this function
	 477  	// and runtime.Callers itself.
	 478  	n := runtime.Callers(skip+2, pc[:])
	 479  	if n == 0 {
	 480  		panic("testing: zero callers found")
	 481  	}
	 482  	frames := runtime.CallersFrames(pc[:n])
	 483  	var firstFrame, prevFrame, frame runtime.Frame
	 484  	for more := true; more; prevFrame = frame {
	 485  		frame, more = frames.Next()
	 486  		if frame.Function == c.cleanupName {
	 487  			frames = runtime.CallersFrames(c.cleanupPc)
	 488  			continue
	 489  		}
	 490  		if firstFrame.PC == 0 {
	 491  			firstFrame = frame
	 492  		}
	 493  		if frame.Function == c.runner {
	 494  			// We've gone up all the way to the tRunner calling
	 495  			// the test function (so the user must have
	 496  			// called tb.Helper from inside that test function).
	 497  			// If this is a top-level test, only skip up to the test function itself.
	 498  			// If we're in a subtest, continue searching in the parent test,
	 499  			// starting from the point of the call to Run which created this subtest.
	 500  			if c.level > 1 {
	 501  				frames = runtime.CallersFrames(c.creator)
	 502  				parent := c.parent
	 503  				// We're no longer looking at the current c after this point,
	 504  				// so we should unlock its mu, unless it's the original receiver,
	 505  				// in which case our caller doesn't expect us to do that.
	 506  				if shouldUnlock {
	 507  					c.mu.Unlock()
	 508  				}
	 509  				c = parent
	 510  				// Remember to unlock c.mu when we no longer need it, either
	 511  				// because we went up another nesting level, or because we
	 512  				// returned.
	 513  				shouldUnlock = true
	 514  				c.mu.Lock()
	 515  				continue
	 516  			}
	 517  			return prevFrame
	 518  		}
	 519  		// If more helper PCs have been added since we last did the conversion
	 520  		if c.helperNames == nil {
	 521  			c.helperNames = make(map[string]struct{})
	 522  			for pc := range c.helperPCs {
	 523  				c.helperNames[pcToName(pc)] = struct{}{}
	 524  			}
	 525  		}
	 526  		if _, ok := c.helperNames[frame.Function]; !ok {
	 527  			// Found a frame that wasn't inside a helper function.
	 528  			return frame
	 529  		}
	 530  	}
	 531  	return firstFrame
	 532  }
	 533  
	 534  // decorate prefixes the string with the file and line of the call site
	 535  // and inserts the final newline if needed and indentation spaces for formatting.
	 536  // This function must be called with c.mu held.
	 537  func (c *common) decorate(s string, skip int) string {
	 538  	frame := c.frameSkip(skip)
	 539  	file := frame.File
	 540  	line := frame.Line
	 541  	if file != "" {
	 542  		// Truncate file name at last file name separator.
	 543  		if index := strings.LastIndex(file, "/"); index >= 0 {
	 544  			file = file[index+1:]
	 545  		} else if index = strings.LastIndex(file, "\\"); index >= 0 {
	 546  			file = file[index+1:]
	 547  		}
	 548  	} else {
	 549  		file = "???"
	 550  	}
	 551  	if line == 0 {
	 552  		line = 1
	 553  	}
	 554  	buf := new(strings.Builder)
	 555  	// Every line is indented at least 4 spaces.
	 556  	buf.WriteString("		")
	 557  	fmt.Fprintf(buf, "%s:%d: ", file, line)
	 558  	lines := strings.Split(s, "\n")
	 559  	if l := len(lines); l > 1 && lines[l-1] == "" {
	 560  		lines = lines[:l-1]
	 561  	}
	 562  	for i, line := range lines {
	 563  		if i > 0 {
	 564  			// Second and subsequent lines are indented an additional 4 spaces.
	 565  			buf.WriteString("\n				")
	 566  		}
	 567  		buf.WriteString(line)
	 568  	}
	 569  	buf.WriteByte('\n')
	 570  	return buf.String()
	 571  }
	 572  
	 573  // flushToParent writes c.output to the parent after first writing the header
	 574  // with the given format and arguments.
	 575  func (c *common) flushToParent(testName, format string, args ...interface{}) {
	 576  	p := c.parent
	 577  	p.mu.Lock()
	 578  	defer p.mu.Unlock()
	 579  
	 580  	c.mu.Lock()
	 581  	defer c.mu.Unlock()
	 582  
	 583  	if len(c.output) > 0 {
	 584  		format += "%s"
	 585  		args = append(args[:len(args):len(args)], c.output)
	 586  		c.output = c.output[:0] // but why?
	 587  	}
	 588  
	 589  	if c.chatty != nil && p.w == c.chatty.w {
	 590  		// We're flushing to the actual output, so track that this output is
	 591  		// associated with a specific test (and, specifically, that the next output
	 592  		// is *not* associated with that test).
	 593  		//
	 594  		// Moreover, if c.output is non-empty it is important that this write be
	 595  		// atomic with respect to the output of other tests, so that we don't end up
	 596  		// with confusing '=== CONT' lines in the middle of our '--- PASS' block.
	 597  		// Neither humans nor cmd/test2json can parse those easily.
	 598  		// (See https://golang.org/issue/40771.)
	 599  		c.chatty.Updatef(testName, format, args...)
	 600  	} else {
	 601  		// We're flushing to the output buffer of the parent test, which will
	 602  		// itself follow a test-name header when it is finally flushed to stdout.
	 603  		fmt.Fprintf(p.w, format, args...)
	 604  	}
	 605  }
	 606  
	 607  type indenter struct {
	 608  	c *common
	 609  }
	 610  
	 611  func (w indenter) Write(b []byte) (n int, err error) {
	 612  	n = len(b)
	 613  	for len(b) > 0 {
	 614  		end := bytes.IndexByte(b, '\n')
	 615  		if end == -1 {
	 616  			end = len(b)
	 617  		} else {
	 618  			end++
	 619  		}
	 620  		// An indent of 4 spaces will neatly align the dashes with the status
	 621  		// indicator of the parent.
	 622  		const indent = "		"
	 623  		w.c.output = append(w.c.output, indent...)
	 624  		w.c.output = append(w.c.output, b[:end]...)
	 625  		b = b[end:]
	 626  	}
	 627  	return
	 628  }
	 629  
	 630  // fmtDuration returns a string representing d in the form "87.00s".
	 631  func fmtDuration(d time.Duration) string {
	 632  	return fmt.Sprintf("%.2fs", d.Seconds())
	 633  }
	 634  
	 635  // TB is the interface common to T and B.
	 636  type TB interface {
	 637  	Cleanup(func())
	 638  	Error(args ...interface{})
	 639  	Errorf(format string, args ...interface{})
	 640  	Fail()
	 641  	FailNow()
	 642  	Failed() bool
	 643  	Fatal(args ...interface{})
	 644  	Fatalf(format string, args ...interface{})
	 645  	Helper()
	 646  	Log(args ...interface{})
	 647  	Logf(format string, args ...interface{})
	 648  	Name() string
	 649  	Setenv(key, value string)
	 650  	Skip(args ...interface{})
	 651  	SkipNow()
	 652  	Skipf(format string, args ...interface{})
	 653  	Skipped() bool
	 654  	TempDir() string
	 655  
	 656  	// A private method to prevent users implementing the
	 657  	// interface and so future additions to it will not
	 658  	// violate Go 1 compatibility.
	 659  	private()
	 660  }
	 661  
	 662  var _ TB = (*T)(nil)
	 663  var _ TB = (*B)(nil)
	 664  
	 665  // T is a type passed to Test functions to manage test state and support formatted test logs.
	 666  //
	 667  // A test ends when its Test function returns or calls any of the methods
	 668  // FailNow, Fatal, Fatalf, SkipNow, Skip, or Skipf. Those methods, as well as
	 669  // the Parallel method, must be called only from the goroutine running the
	 670  // Test function.
	 671  //
	 672  // The other reporting methods, such as the variations of Log and Error,
	 673  // may be called simultaneously from multiple goroutines.
	 674  type T struct {
	 675  	common
	 676  	isParallel bool
	 677  	isEnvSet	 bool
	 678  	context		*testContext // For running tests and subtests.
	 679  }
	 680  
	 681  func (c *common) private() {}
	 682  
	 683  // Name returns the name of the running (sub-) test or benchmark.
	 684  //
	 685  // The name will include the name of the test along with the names of
	 686  // any nested sub-tests. If two sibling sub-tests have the same name,
	 687  // Name will append a suffix to guarantee the returned name is unique.
	 688  func (c *common) Name() string {
	 689  	return c.name
	 690  }
	 691  
	 692  func (c *common) setRan() {
	 693  	if c.parent != nil {
	 694  		c.parent.setRan()
	 695  	}
	 696  	c.mu.Lock()
	 697  	defer c.mu.Unlock()
	 698  	c.ran = true
	 699  }
	 700  
	 701  // Fail marks the function as having failed but continues execution.
	 702  func (c *common) Fail() {
	 703  	if c.parent != nil {
	 704  		c.parent.Fail()
	 705  	}
	 706  	c.mu.Lock()
	 707  	defer c.mu.Unlock()
	 708  	// c.done needs to be locked to synchronize checks to c.done in parent tests.
	 709  	if c.done {
	 710  		panic("Fail in goroutine after " + c.name + " has completed")
	 711  	}
	 712  	c.failed = true
	 713  }
	 714  
	 715  // Failed reports whether the function has failed.
	 716  func (c *common) Failed() bool {
	 717  	c.mu.RLock()
	 718  	failed := c.failed
	 719  	c.mu.RUnlock()
	 720  	return failed || c.raceErrors+race.Errors() > 0
	 721  }
	 722  
	 723  // FailNow marks the function as having failed and stops its execution
	 724  // by calling runtime.Goexit (which then runs all deferred calls in the
	 725  // current goroutine).
	 726  // Execution will continue at the next test or benchmark.
	 727  // FailNow must be called from the goroutine running the
	 728  // test or benchmark function, not from other goroutines
	 729  // created during the test. Calling FailNow does not stop
	 730  // those other goroutines.
	 731  func (c *common) FailNow() {
	 732  	c.Fail()
	 733  
	 734  	// Calling runtime.Goexit will exit the goroutine, which
	 735  	// will run the deferred functions in this goroutine,
	 736  	// which will eventually run the deferred lines in tRunner,
	 737  	// which will signal to the test loop that this test is done.
	 738  	//
	 739  	// A previous version of this code said:
	 740  	//
	 741  	//	c.duration = ...
	 742  	//	c.signal <- c.self
	 743  	//	runtime.Goexit()
	 744  	//
	 745  	// This previous version duplicated code (those lines are in
	 746  	// tRunner no matter what), but worse the goroutine teardown
	 747  	// implicit in runtime.Goexit was not guaranteed to complete
	 748  	// before the test exited. If a test deferred an important cleanup
	 749  	// function (like removing temporary files), there was no guarantee
	 750  	// it would run on a test failure. Because we send on c.signal during
	 751  	// a top-of-stack deferred function now, we know that the send
	 752  	// only happens after any other stacked defers have completed.
	 753  	c.mu.Lock()
	 754  	c.finished = true
	 755  	c.mu.Unlock()
	 756  	runtime.Goexit()
	 757  }
	 758  
	 759  // log generates the output. It's always at the same stack depth.
	 760  func (c *common) log(s string) {
	 761  	c.logDepth(s, 3) // logDepth + log + public function
	 762  }
	 763  
	 764  // logDepth generates the output at an arbitrary stack depth.
	 765  func (c *common) logDepth(s string, depth int) {
	 766  	c.mu.Lock()
	 767  	defer c.mu.Unlock()
	 768  	if c.done {
	 769  		// This test has already finished. Try and log this message
	 770  		// with our parent. If we don't have a parent, panic.
	 771  		for parent := c.parent; parent != nil; parent = parent.parent {
	 772  			parent.mu.Lock()
	 773  			defer parent.mu.Unlock()
	 774  			if !parent.done {
	 775  				parent.output = append(parent.output, parent.decorate(s, depth+1)...)
	 776  				return
	 777  			}
	 778  		}
	 779  		panic("Log in goroutine after " + c.name + " has completed: " + s)
	 780  	} else {
	 781  		if c.chatty != nil {
	 782  			if c.bench {
	 783  				// Benchmarks don't print === CONT, so we should skip the test
	 784  				// printer and just print straight to stdout.
	 785  				fmt.Print(c.decorate(s, depth+1))
	 786  			} else {
	 787  				c.chatty.Printf(c.name, "%s", c.decorate(s, depth+1))
	 788  			}
	 789  
	 790  			return
	 791  		}
	 792  		c.output = append(c.output, c.decorate(s, depth+1)...)
	 793  	}
	 794  }
	 795  
	 796  // Log formats its arguments using default formatting, analogous to Println,
	 797  // and records the text in the error log. For tests, the text will be printed only if
	 798  // the test fails or the -test.v flag is set. For benchmarks, the text is always
	 799  // printed to avoid having performance depend on the value of the -test.v flag.
	 800  func (c *common) Log(args ...interface{}) { c.log(fmt.Sprintln(args...)) }
	 801  
	 802  // Logf formats its arguments according to the format, analogous to Printf, and
	 803  // records the text in the error log. A final newline is added if not provided. For
	 804  // tests, the text will be printed only if the test fails or the -test.v flag is
	 805  // set. For benchmarks, the text is always printed to avoid having performance
	 806  // depend on the value of the -test.v flag.
	 807  func (c *common) Logf(format string, args ...interface{}) { c.log(fmt.Sprintf(format, args...)) }
	 808  
	 809  // Error is equivalent to Log followed by Fail.
	 810  func (c *common) Error(args ...interface{}) {
	 811  	c.log(fmt.Sprintln(args...))
	 812  	c.Fail()
	 813  }
	 814  
	 815  // Errorf is equivalent to Logf followed by Fail.
	 816  func (c *common) Errorf(format string, args ...interface{}) {
	 817  	c.log(fmt.Sprintf(format, args...))
	 818  	c.Fail()
	 819  }
	 820  
	 821  // Fatal is equivalent to Log followed by FailNow.
	 822  func (c *common) Fatal(args ...interface{}) {
	 823  	c.log(fmt.Sprintln(args...))
	 824  	c.FailNow()
	 825  }
	 826  
	 827  // Fatalf is equivalent to Logf followed by FailNow.
	 828  func (c *common) Fatalf(format string, args ...interface{}) {
	 829  	c.log(fmt.Sprintf(format, args...))
	 830  	c.FailNow()
	 831  }
	 832  
	 833  // Skip is equivalent to Log followed by SkipNow.
	 834  func (c *common) Skip(args ...interface{}) {
	 835  	c.log(fmt.Sprintln(args...))
	 836  	c.SkipNow()
	 837  }
	 838  
	 839  // Skipf is equivalent to Logf followed by SkipNow.
	 840  func (c *common) Skipf(format string, args ...interface{}) {
	 841  	c.log(fmt.Sprintf(format, args...))
	 842  	c.SkipNow()
	 843  }
	 844  
	 845  // SkipNow marks the test as having been skipped and stops its execution
	 846  // by calling runtime.Goexit.
	 847  // If a test fails (see Error, Errorf, Fail) and is then skipped,
	 848  // it is still considered to have failed.
	 849  // Execution will continue at the next test or benchmark. See also FailNow.
	 850  // SkipNow must be called from the goroutine running the test, not from
	 851  // other goroutines created during the test. Calling SkipNow does not stop
	 852  // those other goroutines.
	 853  func (c *common) SkipNow() {
	 854  	c.mu.Lock()
	 855  	c.skipped = true
	 856  	c.finished = true
	 857  	c.mu.Unlock()
	 858  	runtime.Goexit()
	 859  }
	 860  
	 861  // Skipped reports whether the test was skipped.
	 862  func (c *common) Skipped() bool {
	 863  	c.mu.RLock()
	 864  	defer c.mu.RUnlock()
	 865  	return c.skipped
	 866  }
	 867  
	 868  // Helper marks the calling function as a test helper function.
	 869  // When printing file and line information, that function will be skipped.
	 870  // Helper may be called simultaneously from multiple goroutines.
	 871  func (c *common) Helper() {
	 872  	c.mu.Lock()
	 873  	defer c.mu.Unlock()
	 874  	if c.helperPCs == nil {
	 875  		c.helperPCs = make(map[uintptr]struct{})
	 876  	}
	 877  	// repeating code from callerName here to save walking a stack frame
	 878  	var pc [1]uintptr
	 879  	n := runtime.Callers(2, pc[:]) // skip runtime.Callers + Helper
	 880  	if n == 0 {
	 881  		panic("testing: zero callers found")
	 882  	}
	 883  	if _, found := c.helperPCs[pc[0]]; !found {
	 884  		c.helperPCs[pc[0]] = struct{}{}
	 885  		c.helperNames = nil // map will be recreated next time it is needed
	 886  	}
	 887  }
	 888  
	 889  // Cleanup registers a function to be called when the test (or subtest) and all its
	 890  // subtests complete. Cleanup functions will be called in last added,
	 891  // first called order.
	 892  func (c *common) Cleanup(f func()) {
	 893  	var pc [maxStackLen]uintptr
	 894  	// Skip two extra frames to account for this function and runtime.Callers itself.
	 895  	n := runtime.Callers(2, pc[:])
	 896  	cleanupPc := pc[:n]
	 897  
	 898  	fn := func() {
	 899  		defer func() {
	 900  			c.mu.Lock()
	 901  			defer c.mu.Unlock()
	 902  			c.cleanupName = ""
	 903  			c.cleanupPc = nil
	 904  		}()
	 905  
	 906  		name := callerName(0)
	 907  		c.mu.Lock()
	 908  		c.cleanupName = name
	 909  		c.cleanupPc = cleanupPc
	 910  		c.mu.Unlock()
	 911  
	 912  		f()
	 913  	}
	 914  
	 915  	c.mu.Lock()
	 916  	defer c.mu.Unlock()
	 917  	c.cleanups = append(c.cleanups, fn)
	 918  }
	 919  
	 920  // TempDir returns a temporary directory for the test to use.
	 921  // The directory is automatically removed by Cleanup when the test and
	 922  // all its subtests complete.
	 923  // Each subsequent call to t.TempDir returns a unique directory;
	 924  // if the directory creation fails, TempDir terminates the test by calling Fatal.
	 925  func (c *common) TempDir() string {
	 926  	// Use a single parent directory for all the temporary directories
	 927  	// created by a test, each numbered sequentially.
	 928  	c.tempDirMu.Lock()
	 929  	var nonExistent bool
	 930  	if c.tempDir == "" { // Usually the case with js/wasm
	 931  		nonExistent = true
	 932  	} else {
	 933  		_, err := os.Stat(c.tempDir)
	 934  		nonExistent = os.IsNotExist(err)
	 935  		if err != nil && !nonExistent {
	 936  			c.Fatalf("TempDir: %v", err)
	 937  		}
	 938  	}
	 939  
	 940  	if nonExistent {
	 941  		c.Helper()
	 942  
	 943  		// Drop unusual characters (such as path separators or
	 944  		// characters interacting with globs) from the directory name to
	 945  		// avoid surprising os.MkdirTemp behavior.
	 946  		mapper := func(r rune) rune {
	 947  			if r < utf8.RuneSelf {
	 948  				const allowed = "!#$%&()+,-.=@^_{}~ "
	 949  				if '0' <= r && r <= '9' ||
	 950  					'a' <= r && r <= 'z' ||
	 951  					'A' <= r && r <= 'Z' {
	 952  					return r
	 953  				}
	 954  				if strings.ContainsRune(allowed, r) {
	 955  					return r
	 956  				}
	 957  			} else if unicode.IsLetter(r) || unicode.IsNumber(r) {
	 958  				return r
	 959  			}
	 960  			return -1
	 961  		}
	 962  		pattern := strings.Map(mapper, c.Name())
	 963  		c.tempDir, c.tempDirErr = os.MkdirTemp("", pattern)
	 964  		if c.tempDirErr == nil {
	 965  			c.Cleanup(func() {
	 966  				if err := os.RemoveAll(c.tempDir); err != nil {
	 967  					c.Errorf("TempDir RemoveAll cleanup: %v", err)
	 968  				}
	 969  			})
	 970  		}
	 971  	}
	 972  	c.tempDirMu.Unlock()
	 973  
	 974  	if c.tempDirErr != nil {
	 975  		c.Fatalf("TempDir: %v", c.tempDirErr)
	 976  	}
	 977  	seq := atomic.AddInt32(&c.tempDirSeq, 1)
	 978  	dir := fmt.Sprintf("%s%c%03d", c.tempDir, os.PathSeparator, seq)
	 979  	if err := os.Mkdir(dir, 0777); err != nil {
	 980  		c.Fatalf("TempDir: %v", err)
	 981  	}
	 982  	return dir
	 983  }
	 984  
	 985  // Setenv calls os.Setenv(key, value) and uses Cleanup to
	 986  // restore the environment variable to its original value
	 987  // after the test.
	 988  //
	 989  // This cannot be used in parallel tests.
	 990  func (c *common) Setenv(key, value string) {
	 991  	prevValue, ok := os.LookupEnv(key)
	 992  
	 993  	if err := os.Setenv(key, value); err != nil {
	 994  		c.Fatalf("cannot set environment variable: %v", err)
	 995  	}
	 996  
	 997  	if ok {
	 998  		c.Cleanup(func() {
	 999  			os.Setenv(key, prevValue)
	1000  		})
	1001  	} else {
	1002  		c.Cleanup(func() {
	1003  			os.Unsetenv(key)
	1004  		})
	1005  	}
	1006  }
	1007  
	1008  // panicHanding is an argument to runCleanup.
	1009  type panicHandling int
	1010  
	1011  const (
	1012  	normalPanic panicHandling = iota
	1013  	recoverAndReturnPanic
	1014  )
	1015  
	1016  // runCleanup is called at the end of the test.
	1017  // If catchPanic is true, this will catch panics, and return the recovered
	1018  // value if any.
	1019  func (c *common) runCleanup(ph panicHandling) (panicVal interface{}) {
	1020  	if ph == recoverAndReturnPanic {
	1021  		defer func() {
	1022  			panicVal = recover()
	1023  		}()
	1024  	}
	1025  
	1026  	// Make sure that if a cleanup function panics,
	1027  	// we still run the remaining cleanup functions.
	1028  	defer func() {
	1029  		c.mu.Lock()
	1030  		recur := len(c.cleanups) > 0
	1031  		c.mu.Unlock()
	1032  		if recur {
	1033  			c.runCleanup(normalPanic)
	1034  		}
	1035  	}()
	1036  
	1037  	for {
	1038  		var cleanup func()
	1039  		c.mu.Lock()
	1040  		if len(c.cleanups) > 0 {
	1041  			last := len(c.cleanups) - 1
	1042  			cleanup = c.cleanups[last]
	1043  			c.cleanups = c.cleanups[:last]
	1044  		}
	1045  		c.mu.Unlock()
	1046  		if cleanup == nil {
	1047  			return nil
	1048  		}
	1049  		cleanup()
	1050  	}
	1051  }
	1052  
	1053  // callerName gives the function name (qualified with a package path)
	1054  // for the caller after skip frames (where 0 means the current function).
	1055  func callerName(skip int) string {
	1056  	var pc [1]uintptr
	1057  	n := runtime.Callers(skip+2, pc[:]) // skip + runtime.Callers + callerName
	1058  	if n == 0 {
	1059  		panic("testing: zero callers found")
	1060  	}
	1061  	return pcToName(pc[0])
	1062  }
	1063  
	1064  func pcToName(pc uintptr) string {
	1065  	pcs := []uintptr{pc}
	1066  	frames := runtime.CallersFrames(pcs)
	1067  	frame, _ := frames.Next()
	1068  	return frame.Function
	1069  }
	1070  
	1071  // Parallel signals that this test is to be run in parallel with (and only with)
	1072  // other parallel tests. When a test is run multiple times due to use of
	1073  // -test.count or -test.cpu, multiple instances of a single test never run in
	1074  // parallel with each other.
	1075  func (t *T) Parallel() {
	1076  	if t.isParallel {
	1077  		panic("testing: t.Parallel called multiple times")
	1078  	}
	1079  	if t.isEnvSet {
	1080  		panic("testing: t.Parallel called after t.Setenv; cannot set environment variables in parallel tests")
	1081  	}
	1082  	t.isParallel = true
	1083  
	1084  	// We don't want to include the time we spend waiting for serial tests
	1085  	// in the test duration. Record the elapsed time thus far and reset the
	1086  	// timer afterwards.
	1087  	t.duration += time.Since(t.start)
	1088  
	1089  	// Add to the list of tests to be released by the parent.
	1090  	t.parent.sub = append(t.parent.sub, t)
	1091  	t.raceErrors += race.Errors()
	1092  
	1093  	if t.chatty != nil {
	1094  		// Unfortunately, even though PAUSE indicates that the named test is *no
	1095  		// longer* running, cmd/test2json interprets it as changing the active test
	1096  		// for the purpose of log parsing. We could fix cmd/test2json, but that
	1097  		// won't fix existing deployments of third-party tools that already shell
	1098  		// out to older builds of cmd/test2json — so merely fixing cmd/test2json
	1099  		// isn't enough for now.
	1100  		t.chatty.Updatef(t.name, "=== PAUSE %s\n", t.name)
	1101  	}
	1102  
	1103  	t.signal <- true	 // Release calling test.
	1104  	<-t.parent.barrier // Wait for the parent test to complete.
	1105  	t.context.waitParallel()
	1106  
	1107  	if t.chatty != nil {
	1108  		t.chatty.Updatef(t.name, "=== CONT	%s\n", t.name)
	1109  	}
	1110  
	1111  	t.start = time.Now()
	1112  	t.raceErrors += -race.Errors()
	1113  }
	1114  
	1115  // Setenv calls os.Setenv(key, value) and uses Cleanup to
	1116  // restore the environment variable to its original value
	1117  // after the test.
	1118  //
	1119  // This cannot be used in parallel tests.
	1120  func (t *T) Setenv(key, value string) {
	1121  	if t.isParallel {
	1122  		panic("testing: t.Setenv called after t.Parallel; cannot set environment variables in parallel tests")
	1123  	}
	1124  
	1125  	t.isEnvSet = true
	1126  
	1127  	t.common.Setenv(key, value)
	1128  }
	1129  
	1130  // InternalTest is an internal type but exported because it is cross-package;
	1131  // it is part of the implementation of the "go test" command.
	1132  type InternalTest struct {
	1133  	Name string
	1134  	F		func(*T)
	1135  }
	1136  
	1137  var errNilPanicOrGoexit = errors.New("test executed panic(nil) or runtime.Goexit")
	1138  
	1139  func tRunner(t *T, fn func(t *T)) {
	1140  	t.runner = callerName(0)
	1141  
	1142  	// When this goroutine is done, either because fn(t)
	1143  	// returned normally or because a test failure triggered
	1144  	// a call to runtime.Goexit, record the duration and send
	1145  	// a signal saying that the test is done.
	1146  	defer func() {
	1147  		if t.Failed() {
	1148  			atomic.AddUint32(&numFailed, 1)
	1149  		}
	1150  
	1151  		if t.raceErrors+race.Errors() > 0 {
	1152  			t.Errorf("race detected during execution of test")
	1153  		}
	1154  
	1155  		// If the test panicked, print any test output before dying.
	1156  		err := recover()
	1157  		signal := true
	1158  
	1159  		t.mu.RLock()
	1160  		finished := t.finished
	1161  		t.mu.RUnlock()
	1162  		if !finished && err == nil {
	1163  			err = errNilPanicOrGoexit
	1164  			for p := t.parent; p != nil; p = p.parent {
	1165  				p.mu.RLock()
	1166  				finished = p.finished
	1167  				p.mu.RUnlock()
	1168  				if finished {
	1169  					t.Errorf("%v: subtest may have called FailNow on a parent test", err)
	1170  					err = nil
	1171  					signal = false
	1172  					break
	1173  				}
	1174  			}
	1175  		}
	1176  		// Use a deferred call to ensure that we report that the test is
	1177  		// complete even if a cleanup function calls t.FailNow. See issue 41355.
	1178  		didPanic := false
	1179  		defer func() {
	1180  			if didPanic {
	1181  				return
	1182  			}
	1183  			if err != nil {
	1184  				panic(err)
	1185  			}
	1186  			// Only report that the test is complete if it doesn't panic,
	1187  			// as otherwise the test binary can exit before the panic is
	1188  			// reported to the user. See issue 41479.
	1189  			t.signal <- signal
	1190  		}()
	1191  
	1192  		doPanic := func(err interface{}) {
	1193  			t.Fail()
	1194  			if r := t.runCleanup(recoverAndReturnPanic); r != nil {
	1195  				t.Logf("cleanup panicked with %v", r)
	1196  			}
	1197  			// Flush the output log up to the root before dying.
	1198  			for root := &t.common; root.parent != nil; root = root.parent {
	1199  				root.mu.Lock()
	1200  				root.duration += time.Since(root.start)
	1201  				d := root.duration
	1202  				root.mu.Unlock()
	1203  				root.flushToParent(root.name, "--- FAIL: %s (%s)\n", root.name, fmtDuration(d))
	1204  				if r := root.parent.runCleanup(recoverAndReturnPanic); r != nil {
	1205  					fmt.Fprintf(root.parent.w, "cleanup panicked with %v", r)
	1206  				}
	1207  			}
	1208  			didPanic = true
	1209  			panic(err)
	1210  		}
	1211  		if err != nil {
	1212  			doPanic(err)
	1213  		}
	1214  
	1215  		t.duration += time.Since(t.start)
	1216  
	1217  		if len(t.sub) > 0 {
	1218  			// Run parallel subtests.
	1219  			// Decrease the running count for this test.
	1220  			t.context.release()
	1221  			// Release the parallel subtests.
	1222  			close(t.barrier)
	1223  			// Wait for subtests to complete.
	1224  			for _, sub := range t.sub {
	1225  				<-sub.signal
	1226  			}
	1227  			cleanupStart := time.Now()
	1228  			err := t.runCleanup(recoverAndReturnPanic)
	1229  			t.duration += time.Since(cleanupStart)
	1230  			if err != nil {
	1231  				doPanic(err)
	1232  			}
	1233  			if !t.isParallel {
	1234  				// Reacquire the count for sequential tests. See comment in Run.
	1235  				t.context.waitParallel()
	1236  			}
	1237  		} else if t.isParallel {
	1238  			// Only release the count for this test if it was run as a parallel
	1239  			// test. See comment in Run method.
	1240  			t.context.release()
	1241  		}
	1242  		t.report() // Report after all subtests have finished.
	1243  
	1244  		// Do not lock t.done to allow race detector to detect race in case
	1245  		// the user does not appropriately synchronizes a goroutine.
	1246  		t.done = true
	1247  		if t.parent != nil && atomic.LoadInt32(&t.hasSub) == 0 {
	1248  			t.setRan()
	1249  		}
	1250  	}()
	1251  	defer func() {
	1252  		if len(t.sub) == 0 {
	1253  			t.runCleanup(normalPanic)
	1254  		}
	1255  	}()
	1256  
	1257  	t.start = time.Now()
	1258  	t.raceErrors = -race.Errors()
	1259  	fn(t)
	1260  
	1261  	// code beyond here will not be executed when FailNow is invoked
	1262  	t.mu.Lock()
	1263  	t.finished = true
	1264  	t.mu.Unlock()
	1265  }
	1266  
	1267  // Run runs f as a subtest of t called name. It runs f in a separate goroutine
	1268  // and blocks until f returns or calls t.Parallel to become a parallel test.
	1269  // Run reports whether f succeeded (or at least did not fail before calling t.Parallel).
	1270  //
	1271  // Run may be called simultaneously from multiple goroutines, but all such calls
	1272  // must return before the outer test function for t returns.
	1273  func (t *T) Run(name string, f func(t *T)) bool {
	1274  	atomic.StoreInt32(&t.hasSub, 1)
	1275  	testName, ok, _ := t.context.match.fullName(&t.common, name)
	1276  	if !ok || shouldFailFast() {
	1277  		return true
	1278  	}
	1279  	// Record the stack trace at the point of this call so that if the subtest
	1280  	// function - which runs in a separate stack - is marked as a helper, we can
	1281  	// continue walking the stack into the parent test.
	1282  	var pc [maxStackLen]uintptr
	1283  	n := runtime.Callers(2, pc[:])
	1284  	t = &T{
	1285  		common: common{
	1286  			barrier: make(chan bool),
	1287  			signal:	make(chan bool, 1),
	1288  			name:		testName,
	1289  			parent:	&t.common,
	1290  			level:	 t.level + 1,
	1291  			creator: pc[:n],
	1292  			chatty:	t.chatty,
	1293  		},
	1294  		context: t.context,
	1295  	}
	1296  	t.w = indenter{&t.common}
	1297  
	1298  	if t.chatty != nil {
	1299  		t.chatty.Updatef(t.name, "=== RUN	 %s\n", t.name)
	1300  	}
	1301  	// Instead of reducing the running count of this test before calling the
	1302  	// tRunner and increasing it afterwards, we rely on tRunner keeping the
	1303  	// count correct. This ensures that a sequence of sequential tests runs
	1304  	// without being preempted, even when their parent is a parallel test. This
	1305  	// may especially reduce surprises if *parallel == 1.
	1306  	go tRunner(t, f)
	1307  	if !<-t.signal {
	1308  		// At this point, it is likely that FailNow was called on one of the
	1309  		// parent tests by one of the subtests. Continue aborting up the chain.
	1310  		runtime.Goexit()
	1311  	}
	1312  	return !t.failed
	1313  }
	1314  
	1315  // Deadline reports the time at which the test binary will have
	1316  // exceeded the timeout specified by the -timeout flag.
	1317  //
	1318  // The ok result is false if the -timeout flag indicates “no timeout” (0).
	1319  func (t *T) Deadline() (deadline time.Time, ok bool) {
	1320  	deadline = t.context.deadline
	1321  	return deadline, !deadline.IsZero()
	1322  }
	1323  
	1324  // testContext holds all fields that are common to all tests. This includes
	1325  // synchronization primitives to run at most *parallel tests.
	1326  type testContext struct {
	1327  	match		*matcher
	1328  	deadline time.Time
	1329  
	1330  	mu sync.Mutex
	1331  
	1332  	// Channel used to signal tests that are ready to be run in parallel.
	1333  	startParallel chan bool
	1334  
	1335  	// running is the number of tests currently running in parallel.
	1336  	// This does not include tests that are waiting for subtests to complete.
	1337  	running int
	1338  
	1339  	// numWaiting is the number tests waiting to be run in parallel.
	1340  	numWaiting int
	1341  
	1342  	// maxParallel is a copy of the parallel flag.
	1343  	maxParallel int
	1344  }
	1345  
	1346  func newTestContext(maxParallel int, m *matcher) *testContext {
	1347  	return &testContext{
	1348  		match:				 m,
	1349  		startParallel: make(chan bool),
	1350  		maxParallel:	 maxParallel,
	1351  		running:			 1, // Set the count to 1 for the main (sequential) test.
	1352  	}
	1353  }
	1354  
	1355  func (c *testContext) waitParallel() {
	1356  	c.mu.Lock()
	1357  	if c.running < c.maxParallel {
	1358  		c.running++
	1359  		c.mu.Unlock()
	1360  		return
	1361  	}
	1362  	c.numWaiting++
	1363  	c.mu.Unlock()
	1364  	<-c.startParallel
	1365  }
	1366  
	1367  func (c *testContext) release() {
	1368  	c.mu.Lock()
	1369  	if c.numWaiting == 0 {
	1370  		c.running--
	1371  		c.mu.Unlock()
	1372  		return
	1373  	}
	1374  	c.numWaiting--
	1375  	c.mu.Unlock()
	1376  	c.startParallel <- true // Pick a waiting test to be run.
	1377  }
	1378  
	1379  // No one should be using func Main anymore.
	1380  // See the doc comment on func Main and use MainStart instead.
	1381  var errMain = errors.New("testing: unexpected use of func Main")
	1382  
	1383  type matchStringOnly func(pat, str string) (bool, error)
	1384  
	1385  func (f matchStringOnly) MatchString(pat, str string) (bool, error)	 { return f(pat, str) }
	1386  func (f matchStringOnly) StartCPUProfile(w io.Writer) error					 { return errMain }
	1387  func (f matchStringOnly) StopCPUProfile()														 {}
	1388  func (f matchStringOnly) WriteProfileTo(string, io.Writer, int) error { return errMain }
	1389  func (f matchStringOnly) ImportPath() string													{ return "" }
	1390  func (f matchStringOnly) StartTestLog(io.Writer)											{}
	1391  func (f matchStringOnly) StopTestLog() error													{ return errMain }
	1392  func (f matchStringOnly) SetPanicOnExit0(bool)												{}
	1393  
	1394  // Main is an internal function, part of the implementation of the "go test" command.
	1395  // It was exported because it is cross-package and predates "internal" packages.
	1396  // It is no longer used by "go test" but preserved, as much as possible, for other
	1397  // systems that simulate "go test" using Main, but Main sometimes cannot be updated as
	1398  // new functionality is added to the testing package.
	1399  // Systems simulating "go test" should be updated to use MainStart.
	1400  func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample) {
	1401  	os.Exit(MainStart(matchStringOnly(matchString), tests, benchmarks, examples).Run())
	1402  }
	1403  
	1404  // M is a type passed to a TestMain function to run the actual tests.
	1405  type M struct {
	1406  	deps			 testDeps
	1407  	tests			[]InternalTest
	1408  	benchmarks []InternalBenchmark
	1409  	examples	 []InternalExample
	1410  
	1411  	timer		 *time.Timer
	1412  	afterOnce sync.Once
	1413  
	1414  	numRun int
	1415  
	1416  	// value to pass to os.Exit, the outer test func main
	1417  	// harness calls os.Exit with this code. See #34129.
	1418  	exitCode int
	1419  }
	1420  
	1421  // testDeps is an internal interface of functionality that is
	1422  // passed into this package by a test's generated main package.
	1423  // The canonical implementation of this interface is
	1424  // testing/internal/testdeps's TestDeps.
	1425  type testDeps interface {
	1426  	ImportPath() string
	1427  	MatchString(pat, str string) (bool, error)
	1428  	SetPanicOnExit0(bool)
	1429  	StartCPUProfile(io.Writer) error
	1430  	StopCPUProfile()
	1431  	StartTestLog(io.Writer)
	1432  	StopTestLog() error
	1433  	WriteProfileTo(string, io.Writer, int) error
	1434  }
	1435  
	1436  // MainStart is meant for use by tests generated by 'go test'.
	1437  // It is not meant to be called directly and is not subject to the Go 1 compatibility document.
	1438  // It may change signature from release to release.
	1439  func MainStart(deps testDeps, tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample) *M {
	1440  	Init()
	1441  	return &M{
	1442  		deps:			 deps,
	1443  		tests:			tests,
	1444  		benchmarks: benchmarks,
	1445  		examples:	 examples,
	1446  	}
	1447  }
	1448  
	1449  // Run runs the tests. It returns an exit code to pass to os.Exit.
	1450  func (m *M) Run() (code int) {
	1451  	defer func() {
	1452  		code = m.exitCode
	1453  	}()
	1454  
	1455  	// Count the number of calls to m.Run.
	1456  	// We only ever expected 1, but we didn't enforce that,
	1457  	// and now there are tests in the wild that call m.Run multiple times.
	1458  	// Sigh. golang.org/issue/23129.
	1459  	m.numRun++
	1460  
	1461  	// TestMain may have already called flag.Parse.
	1462  	if !flag.Parsed() {
	1463  		flag.Parse()
	1464  	}
	1465  
	1466  	if *parallel < 1 {
	1467  		fmt.Fprintln(os.Stderr, "testing: -parallel can only be given a positive integer")
	1468  		flag.Usage()
	1469  		m.exitCode = 2
	1470  		return
	1471  	}
	1472  
	1473  	if len(*matchList) != 0 {
	1474  		listTests(m.deps.MatchString, m.tests, m.benchmarks, m.examples)
	1475  		m.exitCode = 0
	1476  		return
	1477  	}
	1478  
	1479  	if *shuffle != "off" {
	1480  		var n int64
	1481  		var err error
	1482  		if *shuffle == "on" {
	1483  			n = time.Now().UnixNano()
	1484  		} else {
	1485  			n, err = strconv.ParseInt(*shuffle, 10, 64)
	1486  			if err != nil {
	1487  				fmt.Fprintln(os.Stderr, `testing: -shuffle should be "off", "on", or a valid integer:`, err)
	1488  				m.exitCode = 2
	1489  				return
	1490  			}
	1491  		}
	1492  		fmt.Println("-test.shuffle", n)
	1493  		rng := rand.New(rand.NewSource(n))
	1494  		rng.Shuffle(len(m.tests), func(i, j int) { m.tests[i], m.tests[j] = m.tests[j], m.tests[i] })
	1495  		rng.Shuffle(len(m.benchmarks), func(i, j int) { m.benchmarks[i], m.benchmarks[j] = m.benchmarks[j], m.benchmarks[i] })
	1496  	}
	1497  
	1498  	parseCpuList()
	1499  
	1500  	m.before()
	1501  	defer m.after()
	1502  	deadline := m.startAlarm()
	1503  	haveExamples = len(m.examples) > 0
	1504  	testRan, testOk := runTests(m.deps.MatchString, m.tests, deadline)
	1505  	exampleRan, exampleOk := runExamples(m.deps.MatchString, m.examples)
	1506  	m.stopAlarm()
	1507  	if !testRan && !exampleRan && *matchBenchmarks == "" {
	1508  		fmt.Fprintln(os.Stderr, "testing: warning: no tests to run")
	1509  	}
	1510  	if !testOk || !exampleOk || !runBenchmarks(m.deps.ImportPath(), m.deps.MatchString, m.benchmarks) || race.Errors() > 0 {
	1511  		fmt.Println("FAIL")
	1512  		m.exitCode = 1
	1513  		return
	1514  	}
	1515  
	1516  	fmt.Println("PASS")
	1517  	m.exitCode = 0
	1518  	return
	1519  }
	1520  
	1521  func (t *T) report() {
	1522  	if t.parent == nil {
	1523  		return
	1524  	}
	1525  	dstr := fmtDuration(t.duration)
	1526  	format := "--- %s: %s (%s)\n"
	1527  	if t.Failed() {
	1528  		t.flushToParent(t.name, format, "FAIL", t.name, dstr)
	1529  	} else if t.chatty != nil {
	1530  		if t.Skipped() {
	1531  			t.flushToParent(t.name, format, "SKIP", t.name, dstr)
	1532  		} else {
	1533  			t.flushToParent(t.name, format, "PASS", t.name, dstr)
	1534  		}
	1535  	}
	1536  }
	1537  
	1538  func listTests(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample) {
	1539  	if _, err := matchString(*matchList, "non-empty"); err != nil {
	1540  		fmt.Fprintf(os.Stderr, "testing: invalid regexp in -test.list (%q): %s\n", *matchList, err)
	1541  		os.Exit(1)
	1542  	}
	1543  
	1544  	for _, test := range tests {
	1545  		if ok, _ := matchString(*matchList, test.Name); ok {
	1546  			fmt.Println(test.Name)
	1547  		}
	1548  	}
	1549  	for _, bench := range benchmarks {
	1550  		if ok, _ := matchString(*matchList, bench.Name); ok {
	1551  			fmt.Println(bench.Name)
	1552  		}
	1553  	}
	1554  	for _, example := range examples {
	1555  		if ok, _ := matchString(*matchList, example.Name); ok {
	1556  			fmt.Println(example.Name)
	1557  		}
	1558  	}
	1559  }
	1560  
	1561  // RunTests is an internal function but exported because it is cross-package;
	1562  // it is part of the implementation of the "go test" command.
	1563  func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool) {
	1564  	var deadline time.Time
	1565  	if *timeout > 0 {
	1566  		deadline = time.Now().Add(*timeout)
	1567  	}
	1568  	ran, ok := runTests(matchString, tests, deadline)
	1569  	if !ran && !haveExamples {
	1570  		fmt.Fprintln(os.Stderr, "testing: warning: no tests to run")
	1571  	}
	1572  	return ok
	1573  }
	1574  
	1575  func runTests(matchString func(pat, str string) (bool, error), tests []InternalTest, deadline time.Time) (ran, ok bool) {
	1576  	ok = true
	1577  	for _, procs := range cpuList {
	1578  		runtime.GOMAXPROCS(procs)
	1579  		for i := uint(0); i < *count; i++ {
	1580  			if shouldFailFast() {
	1581  				break
	1582  			}
	1583  			ctx := newTestContext(*parallel, newMatcher(matchString, *match, "-test.run"))
	1584  			ctx.deadline = deadline
	1585  			t := &T{
	1586  				common: common{
	1587  					signal:	make(chan bool, 1),
	1588  					barrier: make(chan bool),
	1589  					w:			 os.Stdout,
	1590  				},
	1591  				context: ctx,
	1592  			}
	1593  			if Verbose() {
	1594  				t.chatty = newChattyPrinter(t.w)
	1595  			}
	1596  			tRunner(t, func(t *T) {
	1597  				for _, test := range tests {
	1598  					t.Run(test.Name, test.F)
	1599  				}
	1600  			})
	1601  			select {
	1602  			case <-t.signal:
	1603  			default:
	1604  				panic("internal error: tRunner exited without sending on t.signal")
	1605  			}
	1606  			ok = ok && !t.Failed()
	1607  			ran = ran || t.ran
	1608  		}
	1609  	}
	1610  	return ran, ok
	1611  }
	1612  
	1613  // before runs before all testing.
	1614  func (m *M) before() {
	1615  	if *memProfileRate > 0 {
	1616  		runtime.MemProfileRate = *memProfileRate
	1617  	}
	1618  	if *cpuProfile != "" {
	1619  		f, err := os.Create(toOutputDir(*cpuProfile))
	1620  		if err != nil {
	1621  			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
	1622  			return
	1623  		}
	1624  		if err := m.deps.StartCPUProfile(f); err != nil {
	1625  			fmt.Fprintf(os.Stderr, "testing: can't start cpu profile: %s\n", err)
	1626  			f.Close()
	1627  			return
	1628  		}
	1629  		// Could save f so after can call f.Close; not worth the effort.
	1630  	}
	1631  	if *traceFile != "" {
	1632  		f, err := os.Create(toOutputDir(*traceFile))
	1633  		if err != nil {
	1634  			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
	1635  			return
	1636  		}
	1637  		if err := trace.Start(f); err != nil {
	1638  			fmt.Fprintf(os.Stderr, "testing: can't start tracing: %s\n", err)
	1639  			f.Close()
	1640  			return
	1641  		}
	1642  		// Could save f so after can call f.Close; not worth the effort.
	1643  	}
	1644  	if *blockProfile != "" && *blockProfileRate >= 0 {
	1645  		runtime.SetBlockProfileRate(*blockProfileRate)
	1646  	}
	1647  	if *mutexProfile != "" && *mutexProfileFraction >= 0 {
	1648  		runtime.SetMutexProfileFraction(*mutexProfileFraction)
	1649  	}
	1650  	if *coverProfile != "" && cover.Mode == "" {
	1651  		fmt.Fprintf(os.Stderr, "testing: cannot use -test.coverprofile because test binary was not built with coverage enabled\n")
	1652  		os.Exit(2)
	1653  	}
	1654  	if *testlog != "" {
	1655  		// Note: Not using toOutputDir.
	1656  		// This file is for use by cmd/go, not users.
	1657  		var f *os.File
	1658  		var err error
	1659  		if m.numRun == 1 {
	1660  			f, err = os.Create(*testlog)
	1661  		} else {
	1662  			f, err = os.OpenFile(*testlog, os.O_WRONLY, 0)
	1663  			if err == nil {
	1664  				f.Seek(0, io.SeekEnd)
	1665  			}
	1666  		}
	1667  		if err != nil {
	1668  			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
	1669  			os.Exit(2)
	1670  		}
	1671  		m.deps.StartTestLog(f)
	1672  		testlogFile = f
	1673  	}
	1674  	if *panicOnExit0 {
	1675  		m.deps.SetPanicOnExit0(true)
	1676  	}
	1677  }
	1678  
	1679  // after runs after all testing.
	1680  func (m *M) after() {
	1681  	m.afterOnce.Do(func() {
	1682  		m.writeProfiles()
	1683  	})
	1684  
	1685  	// Restore PanicOnExit0 after every run, because we set it to true before
	1686  	// every run. Otherwise, if m.Run is called multiple times the behavior of
	1687  	// os.Exit(0) will not be restored after the second run.
	1688  	if *panicOnExit0 {
	1689  		m.deps.SetPanicOnExit0(false)
	1690  	}
	1691  }
	1692  
	1693  func (m *M) writeProfiles() {
	1694  	if *testlog != "" {
	1695  		if err := m.deps.StopTestLog(); err != nil {
	1696  			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *testlog, err)
	1697  			os.Exit(2)
	1698  		}
	1699  		if err := testlogFile.Close(); err != nil {
	1700  			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *testlog, err)
	1701  			os.Exit(2)
	1702  		}
	1703  	}
	1704  	if *cpuProfile != "" {
	1705  		m.deps.StopCPUProfile() // flushes profile to disk
	1706  	}
	1707  	if *traceFile != "" {
	1708  		trace.Stop() // flushes trace to disk
	1709  	}
	1710  	if *memProfile != "" {
	1711  		f, err := os.Create(toOutputDir(*memProfile))
	1712  		if err != nil {
	1713  			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
	1714  			os.Exit(2)
	1715  		}
	1716  		runtime.GC() // materialize all statistics
	1717  		if err = m.deps.WriteProfileTo("allocs", f, 0); err != nil {
	1718  			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *memProfile, err)
	1719  			os.Exit(2)
	1720  		}
	1721  		f.Close()
	1722  	}
	1723  	if *blockProfile != "" && *blockProfileRate >= 0 {
	1724  		f, err := os.Create(toOutputDir(*blockProfile))
	1725  		if err != nil {
	1726  			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
	1727  			os.Exit(2)
	1728  		}
	1729  		if err = m.deps.WriteProfileTo("block", f, 0); err != nil {
	1730  			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *blockProfile, err)
	1731  			os.Exit(2)
	1732  		}
	1733  		f.Close()
	1734  	}
	1735  	if *mutexProfile != "" && *mutexProfileFraction >= 0 {
	1736  		f, err := os.Create(toOutputDir(*mutexProfile))
	1737  		if err != nil {
	1738  			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
	1739  			os.Exit(2)
	1740  		}
	1741  		if err = m.deps.WriteProfileTo("mutex", f, 0); err != nil {
	1742  			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *mutexProfile, err)
	1743  			os.Exit(2)
	1744  		}
	1745  		f.Close()
	1746  	}
	1747  	if cover.Mode != "" {
	1748  		coverReport()
	1749  	}
	1750  }
	1751  
	1752  // toOutputDir returns the file name relocated, if required, to outputDir.
	1753  // Simple implementation to avoid pulling in path/filepath.
	1754  func toOutputDir(path string) string {
	1755  	if *outputDir == "" || path == "" {
	1756  		return path
	1757  	}
	1758  	// On Windows, it's clumsy, but we can be almost always correct
	1759  	// by just looking for a drive letter and a colon.
	1760  	// Absolute paths always have a drive letter (ignoring UNC).
	1761  	// Problem: if path == "C:A" and outputdir == "C:\Go" it's unclear
	1762  	// what to do, but even then path/filepath doesn't help.
	1763  	// TODO: Worth doing better? Probably not, because we're here only
	1764  	// under the management of go test.
	1765  	if runtime.GOOS == "windows" && len(path) >= 2 {
	1766  		letter, colon := path[0], path[1]
	1767  		if ('a' <= letter && letter <= 'z' || 'A' <= letter && letter <= 'Z') && colon == ':' {
	1768  			// If path starts with a drive letter we're stuck with it regardless.
	1769  			return path
	1770  		}
	1771  	}
	1772  	if os.IsPathSeparator(path[0]) {
	1773  		return path
	1774  	}
	1775  	return fmt.Sprintf("%s%c%s", *outputDir, os.PathSeparator, path)
	1776  }
	1777  
	1778  // startAlarm starts an alarm if requested.
	1779  func (m *M) startAlarm() time.Time {
	1780  	if *timeout <= 0 {
	1781  		return time.Time{}
	1782  	}
	1783  
	1784  	deadline := time.Now().Add(*timeout)
	1785  	m.timer = time.AfterFunc(*timeout, func() {
	1786  		m.after()
	1787  		debug.SetTraceback("all")
	1788  		panic(fmt.Sprintf("test timed out after %v", *timeout))
	1789  	})
	1790  	return deadline
	1791  }
	1792  
	1793  // stopAlarm turns off the alarm.
	1794  func (m *M) stopAlarm() {
	1795  	if *timeout > 0 {
	1796  		m.timer.Stop()
	1797  	}
	1798  }
	1799  
	1800  func parseCpuList() {
	1801  	for _, val := range strings.Split(*cpuListStr, ",") {
	1802  		val = strings.TrimSpace(val)
	1803  		if val == "" {
	1804  			continue
	1805  		}
	1806  		cpu, err := strconv.Atoi(val)
	1807  		if err != nil || cpu <= 0 {
	1808  			fmt.Fprintf(os.Stderr, "testing: invalid value %q for -test.cpu\n", val)
	1809  			os.Exit(1)
	1810  		}
	1811  		cpuList = append(cpuList, cpu)
	1812  	}
	1813  	if cpuList == nil {
	1814  		cpuList = append(cpuList, runtime.GOMAXPROCS(-1))
	1815  	}
	1816  }
	1817  
	1818  func shouldFailFast() bool {
	1819  	return *failFast && atomic.LoadUint32(&numFailed) > 0
	1820  }
	1821  

View as plain text