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  //
     9  //	func TestXxx(*testing.T)
    10  //
    11  // where Xxx does not start with a lowercase letter. The function name
    12  // serves to identify the test routine.
    13  //
    14  // Within these functions, use the Error, Fail or related methods to signal failure.
    15  //
    16  // To write a new test suite, create a file that
    17  // contains the TestXxx functions as described here,
    18  // and give that file a name ending in "_test.go".
    19  // The file will be excluded from regular
    20  // package builds but will be included when the "go test" command is run.
    21  //
    22  // The test file can be in the same package as the one being tested,
    23  // or in a corresponding package with the suffix "_test".
    24  //
    25  // If the test file is in the same package, it may refer to unexported
    26  // identifiers within the package, as in this example:
    27  //
    28  //	package abs
    29  //
    30  //	import "testing"
    31  //
    32  //	func TestAbs(t *testing.T) {
    33  //	    got := Abs(-1)
    34  //	    if got != 1 {
    35  //	        t.Errorf("Abs(-1) = %d; want 1", got)
    36  //	    }
    37  //	}
    38  //
    39  // If the file is in a separate "_test" package, the package being tested
    40  // must be imported explicitly and only its exported identifiers may be used.
    41  // This is known as "black box" testing.
    42  //
    43  //	package abs_test
    44  //
    45  //	import (
    46  //		"testing"
    47  //
    48  //		"path_to_pkg/abs"
    49  //	)
    50  //
    51  //	func TestAbs(t *testing.T) {
    52  //	    got := abs.Abs(-1)
    53  //	    if got != 1 {
    54  //	        t.Errorf("Abs(-1) = %d; want 1", got)
    55  //	    }
    56  //	}
    57  //
    58  // For more detail, run "go help test" and "go help testflag".
    59  //
    60  // # Benchmarks
    61  //
    62  // Functions of the form
    63  //
    64  //	func BenchmarkXxx(*testing.B)
    65  //
    66  // are considered benchmarks, and are executed by the "go test" command when
    67  // its -bench flag is provided. Benchmarks are run sequentially.
    68  //
    69  // For a description of the testing flags, see
    70  // https://golang.org/cmd/go/#hdr-Testing_flags.
    71  //
    72  // A sample benchmark function looks like this:
    73  //
    74  //	func BenchmarkRandInt(b *testing.B) {
    75  //	    for i := 0; i < b.N; i++ {
    76  //	        rand.Int()
    77  //	    }
    78  //	}
    79  //
    80  // The benchmark function must run the target code b.N times.
    81  // During benchmark execution, b.N is adjusted until the benchmark function lasts
    82  // long enough to be timed reliably. The output
    83  //
    84  //	BenchmarkRandInt-8   	68453040	        17.8 ns/op
    85  //
    86  // means that the loop ran 68453040 times at a speed of 17.8 ns per loop.
    87  //
    88  // If a benchmark needs some expensive setup before running, the timer
    89  // may be reset:
    90  //
    91  //	func BenchmarkBigLen(b *testing.B) {
    92  //	    big := NewBig()
    93  //	    b.ResetTimer()
    94  //	    for i := 0; i < b.N; i++ {
    95  //	        big.Len()
    96  //	    }
    97  //	}
    98  //
    99  // If a benchmark needs to test performance in a parallel setting, it may use
   100  // the RunParallel helper function; such benchmarks are intended to be used with
   101  // the go test -cpu flag:
   102  //
   103  //	func BenchmarkTemplateParallel(b *testing.B) {
   104  //	    templ := template.Must(template.New("test").Parse("Hello, {{.}}!"))
   105  //	    b.RunParallel(func(pb *testing.PB) {
   106  //	        var buf bytes.Buffer
   107  //	        for pb.Next() {
   108  //	            buf.Reset()
   109  //	            templ.Execute(&buf, "World")
   110  //	        }
   111  //	    })
   112  //	}
   113  //
   114  // A detailed specification of the benchmark results format is given
   115  // in https://golang.org/design/14313-benchmark-format.
   116  //
   117  // There are standard tools for working with benchmark results at
   118  // https://golang.org/x/perf/cmd.
   119  // In particular, https://golang.org/x/perf/cmd/benchstat performs
   120  // statistically robust A/B comparisons.
   121  //
   122  // # Examples
   123  //
   124  // The package also runs and verifies example code. Example functions may
   125  // include a concluding line comment that begins with "Output:" and is compared with
   126  // the standard output of the function when the tests are run. (The comparison
   127  // ignores leading and trailing space.) These are examples of an example:
   128  //
   129  //	func ExampleHello() {
   130  //	    fmt.Println("hello")
   131  //	    // Output: hello
   132  //	}
   133  //
   134  //	func ExampleSalutations() {
   135  //	    fmt.Println("hello, and")
   136  //	    fmt.Println("goodbye")
   137  //	    // Output:
   138  //	    // hello, and
   139  //	    // goodbye
   140  //	}
   141  //
   142  // The comment prefix "Unordered output:" is like "Output:", but matches any
   143  // line order:
   144  //
   145  //	func ExamplePerm() {
   146  //	    for _, value := range Perm(5) {
   147  //	        fmt.Println(value)
   148  //	    }
   149  //	    // Unordered output: 4
   150  //	    // 2
   151  //	    // 1
   152  //	    // 3
   153  //	    // 0
   154  //	}
   155  //
   156  // Example functions without output comments are compiled but not executed.
   157  //
   158  // The naming convention to declare examples for the package, a function F, a type T and
   159  // method M on type T are:
   160  //
   161  //	func Example() { ... }
   162  //	func ExampleF() { ... }
   163  //	func ExampleT() { ... }
   164  //	func ExampleT_M() { ... }
   165  //
   166  // Multiple example functions for a package/type/function/method may be provided by
   167  // appending a distinct suffix to the name. The suffix must start with a
   168  // lower-case letter.
   169  //
   170  //	func Example_suffix() { ... }
   171  //	func ExampleF_suffix() { ... }
   172  //	func ExampleT_suffix() { ... }
   173  //	func ExampleT_M_suffix() { ... }
   174  //
   175  // The entire test file is presented as the example when it contains a single
   176  // example function, at least one other function, type, variable, or constant
   177  // declaration, and no test or benchmark functions.
   178  //
   179  // # Fuzzing
   180  //
   181  // 'go test' and the testing package support fuzzing, a testing technique where
   182  // a function is called with randomly generated inputs to find bugs not
   183  // anticipated by unit tests.
   184  //
   185  // Functions of the form
   186  //
   187  //	func FuzzXxx(*testing.F)
   188  //
   189  // are considered fuzz tests.
   190  //
   191  // For example:
   192  //
   193  //	func FuzzHex(f *testing.F) {
   194  //	  for _, seed := range [][]byte{{}, {0}, {9}, {0xa}, {0xf}, {1, 2, 3, 4}} {
   195  //	    f.Add(seed)
   196  //	  }
   197  //	  f.Fuzz(func(t *testing.T, in []byte) {
   198  //	    enc := hex.EncodeToString(in)
   199  //	    out, err := hex.DecodeString(enc)
   200  //	    if err != nil {
   201  //	      t.Fatalf("%v: decode: %v", in, err)
   202  //	    }
   203  //	    if !bytes.Equal(in, out) {
   204  //	      t.Fatalf("%v: not equal after round trip: %v", in, out)
   205  //	    }
   206  //	  })
   207  //	}
   208  //
   209  // A fuzz test maintains a seed corpus, or a set of inputs which are run by
   210  // default, and can seed input generation. Seed inputs may be registered by
   211  // calling (*F).Add or by storing files in the directory testdata/fuzz/<Name>
   212  // (where <Name> is the name of the fuzz test) within the package containing
   213  // the fuzz test. Seed inputs are optional, but the fuzzing engine may find
   214  // bugs more efficiently when provided with a set of small seed inputs with good
   215  // code coverage. These seed inputs can also serve as regression tests for bugs
   216  // identified through fuzzing.
   217  //
   218  // The function passed to (*F).Fuzz within the fuzz test is considered the fuzz
   219  // target. A fuzz target must accept a *T parameter, followed by one or more
   220  // parameters for random inputs. The types of arguments passed to (*F).Add must
   221  // be identical to the types of these parameters. The fuzz target may signal
   222  // that it's found a problem the same way tests do: by calling T.Fail (or any
   223  // method that calls it like T.Error or T.Fatal) or by panicking.
   224  //
   225  // When fuzzing is enabled (by setting the -fuzz flag to a regular expression
   226  // that matches a specific fuzz test), the fuzz target is called with arguments
   227  // generated by repeatedly making random changes to the seed inputs. On
   228  // supported platforms, 'go test' compiles the test executable with fuzzing
   229  // coverage instrumentation. The fuzzing engine uses that instrumentation to
   230  // find and cache inputs that expand coverage, increasing the likelihood of
   231  // finding bugs. If the fuzz target fails for a given input, the fuzzing engine
   232  // writes the inputs that caused the failure to a file in the directory
   233  // testdata/fuzz/<Name> within the package directory. This file later serves as
   234  // a seed input. If the file can't be written at that location (for example,
   235  // because the directory is read-only), the fuzzing engine writes the file to
   236  // the fuzz cache directory within the build cache instead.
   237  //
   238  // When fuzzing is disabled, the fuzz target is called with the seed inputs
   239  // registered with F.Add and seed inputs from testdata/fuzz/<Name>. In this
   240  // mode, the fuzz test acts much like a regular test, with subtests started
   241  // with F.Fuzz instead of T.Run.
   242  //
   243  // See https://go.dev/doc/fuzz for documentation about fuzzing.
   244  //
   245  // # Skipping
   246  //
   247  // Tests or benchmarks may be skipped at run time with a call to
   248  // the Skip method of *T or *B:
   249  //
   250  //	func TestTimeConsuming(t *testing.T) {
   251  //	    if testing.Short() {
   252  //	        t.Skip("skipping test in short mode.")
   253  //	    }
   254  //	    ...
   255  //	}
   256  //
   257  // The Skip method of *T can be used in a fuzz target if the input is invalid,
   258  // but should not be considered a failing input. For example:
   259  //
   260  //	func FuzzJSONMarshaling(f *testing.F) {
   261  //	    f.Fuzz(func(t *testing.T, b []byte) {
   262  //	        var v interface{}
   263  //	        if err := json.Unmarshal(b, &v); err != nil {
   264  //	            t.Skip()
   265  //	        }
   266  //	        if _, err := json.Marshal(v); err != nil {
   267  //	            t.Errorf("Marshal: %v", err)
   268  //	        }
   269  //	    })
   270  //	}
   271  //
   272  // # Subtests and Sub-benchmarks
   273  //
   274  // The Run methods of T and B allow defining subtests and sub-benchmarks,
   275  // without having to define separate functions for each. This enables uses
   276  // like table-driven benchmarks and creating hierarchical tests.
   277  // It also provides a way to share common setup and tear-down code:
   278  //
   279  //	func TestFoo(t *testing.T) {
   280  //	    // <setup code>
   281  //	    t.Run("A=1", func(t *testing.T) { ... })
   282  //	    t.Run("A=2", func(t *testing.T) { ... })
   283  //	    t.Run("B=1", func(t *testing.T) { ... })
   284  //	    // <tear-down code>
   285  //	}
   286  //
   287  // Each subtest and sub-benchmark has a unique name: the combination of the name
   288  // of the top-level test and the sequence of names passed to Run, separated by
   289  // slashes, with an optional trailing sequence number for disambiguation.
   290  //
   291  // The argument to the -run, -bench, and -fuzz command-line flags is an unanchored regular
   292  // expression that matches the test's name. For tests with multiple slash-separated
   293  // elements, such as subtests, the argument is itself slash-separated, with
   294  // expressions matching each name element in turn. Because it is unanchored, an
   295  // empty expression matches any string.
   296  // For example, using "matching" to mean "whose name contains":
   297  //
   298  //	go test -run ''        # Run all tests.
   299  //	go test -run Foo       # Run top-level tests matching "Foo", such as "TestFooBar".
   300  //	go test -run Foo/A=    # For top-level tests matching "Foo", run subtests matching "A=".
   301  //	go test -run /A=1      # For all top-level tests, run subtests matching "A=1".
   302  //	go test -fuzz FuzzFoo  # Fuzz the target matching "FuzzFoo"
   303  //
   304  // The -run argument can also be used to run a specific value in the seed
   305  // corpus, for debugging. For example:
   306  //
   307  //	go test -run=FuzzFoo/9ddb952d9814
   308  //
   309  // The -fuzz and -run flags can both be set, in order to fuzz a target but
   310  // skip the execution of all other tests.
   311  //
   312  // Subtests can also be used to control parallelism. A parent test will only
   313  // complete once all of its subtests complete. In this example, all tests are
   314  // run in parallel with each other, and only with each other, regardless of
   315  // other top-level tests that may be defined:
   316  //
   317  //	func TestGroupedParallel(t *testing.T) {
   318  //	    for _, tc := range tests {
   319  //	        tc := tc // capture range variable
   320  //	        t.Run(tc.Name, func(t *testing.T) {
   321  //	            t.Parallel()
   322  //	            ...
   323  //	        })
   324  //	    }
   325  //	}
   326  //
   327  // Run does not return until parallel subtests have completed, providing a way
   328  // to clean up after a group of parallel tests:
   329  //
   330  //	func TestTeardownParallel(t *testing.T) {
   331  //	    // This Run will not return until the parallel tests finish.
   332  //	    t.Run("group", func(t *testing.T) {
   333  //	        t.Run("Test1", parallelTest1)
   334  //	        t.Run("Test2", parallelTest2)
   335  //	        t.Run("Test3", parallelTest3)
   336  //	    })
   337  //	    // <tear-down code>
   338  //	}
   339  //
   340  // # Main
   341  //
   342  // It is sometimes necessary for a test or benchmark program to do extra setup or teardown
   343  // before or after it executes. It is also sometimes necessary to control
   344  // which code runs on the main thread. To support these and other cases,
   345  // if a test file contains a function:
   346  //
   347  //	func TestMain(m *testing.M)
   348  //
   349  // then the generated test will call TestMain(m) instead of running the tests or benchmarks
   350  // directly. TestMain runs in the main goroutine and can do whatever setup
   351  // and teardown is necessary around a call to m.Run. m.Run will return an exit
   352  // code that may be passed to os.Exit. If TestMain returns, the test wrapper
   353  // will pass the result of m.Run to os.Exit itself.
   354  //
   355  // When TestMain is called, flag.Parse has not been run. If TestMain depends on
   356  // command-line flags, including those of the testing package, it should call
   357  // flag.Parse explicitly. Command line flags are always parsed by the time test
   358  // or benchmark functions run.
   359  //
   360  // A simple implementation of TestMain is:
   361  //
   362  //	func TestMain(m *testing.M) {
   363  //		// call flag.Parse() here if TestMain uses flags
   364  //		os.Exit(m.Run())
   365  //	}
   366  //
   367  // TestMain is a low-level primitive and should not be necessary for casual
   368  // testing needs, where ordinary test functions suffice.
   369  package testing
   370  
   371  import (
   372  	"bytes"
   373  	"errors"
   374  	"flag"
   375  	"fmt"
   376  	"internal/goexperiment"
   377  	"internal/race"
   378  	"io"
   379  	"math/rand"
   380  	"os"
   381  	"reflect"
   382  	"runtime"
   383  	"runtime/debug"
   384  	"runtime/trace"
   385  	"sort"
   386  	"strconv"
   387  	"strings"
   388  	"sync"
   389  	"sync/atomic"
   390  	"time"
   391  	"unicode"
   392  	"unicode/utf8"
   393  )
   394  
   395  var initRan bool
   396  
   397  // Init registers testing flags. These flags are automatically registered by
   398  // the "go test" command before running test functions, so Init is only needed
   399  // when calling functions such as Benchmark without using "go test".
   400  //
   401  // Init is not safe to call concurrently. It has no effect if it was already called.
   402  func Init() {
   403  	if initRan {
   404  		return
   405  	}
   406  	initRan = true
   407  	// The short flag requests that tests run more quickly, but its functionality
   408  	// is provided by test writers themselves. The testing package is just its
   409  	// home. The all.bash installation script sets it to make installation more
   410  	// efficient, but by default the flag is off so a plain "go test" will do a
   411  	// full test of the package.
   412  	short = flag.Bool("test.short", false, "run smaller test suite to save time")
   413  
   414  	// The failfast flag requests that test execution stop after the first test failure.
   415  	failFast = flag.Bool("test.failfast", false, "do not start new tests after the first test failure")
   416  
   417  	// The directory in which to create profile files and the like. When run from
   418  	// "go test", the binary always runs in the source directory for the package;
   419  	// this flag lets "go test" tell the binary to write the files in the directory where
   420  	// the "go test" command is run.
   421  	outputDir = flag.String("test.outputdir", "", "write profiles to `dir`")
   422  	// Report as tests are run; default is silent for success.
   423  	flag.Var(&chatty, "test.v", "verbose: print additional output")
   424  	count = flag.Uint("test.count", 1, "run tests and benchmarks `n` times")
   425  	coverProfile = flag.String("test.coverprofile", "", "write a coverage profile to `file`")
   426  	gocoverdir = flag.String("test.gocoverdir", "", "write coverage intermediate files to this directory")
   427  	matchList = flag.String("test.list", "", "list tests, examples, and benchmarks matching `regexp` then exit")
   428  	match = flag.String("test.run", "", "run only tests and examples matching `regexp`")
   429  	skip = flag.String("test.skip", "", "do not list or run tests matching `regexp`")
   430  	memProfile = flag.String("test.memprofile", "", "write an allocation profile to `file`")
   431  	memProfileRate = flag.Int("test.memprofilerate", 0, "set memory allocation profiling `rate` (see runtime.MemProfileRate)")
   432  	cpuProfile = flag.String("test.cpuprofile", "", "write a cpu profile to `file`")
   433  	blockProfile = flag.String("test.blockprofile", "", "write a goroutine blocking profile to `file`")
   434  	blockProfileRate = flag.Int("test.blockprofilerate", 1, "set blocking profile `rate` (see runtime.SetBlockProfileRate)")
   435  	mutexProfile = flag.String("test.mutexprofile", "", "write a mutex contention profile to the named file after execution")
   436  	mutexProfileFraction = flag.Int("test.mutexprofilefraction", 1, "if >= 0, calls runtime.SetMutexProfileFraction()")
   437  	panicOnExit0 = flag.Bool("test.paniconexit0", false, "panic on call to os.Exit(0)")
   438  	traceFile = flag.String("test.trace", "", "write an execution trace to `file`")
   439  	timeout = flag.Duration("test.timeout", 0, "panic test binary after duration `d` (default 0, timeout disabled)")
   440  	cpuListStr = flag.String("test.cpu", "", "comma-separated `list` of cpu counts to run each test with")
   441  	parallel = flag.Int("test.parallel", runtime.GOMAXPROCS(0), "run at most `n` tests in parallel")
   442  	testlog = flag.String("test.testlogfile", "", "write test action log to `file` (for use only by cmd/go)")
   443  	shuffle = flag.String("test.shuffle", "off", "randomize the execution order of tests and benchmarks")
   444  	fullPath = flag.Bool("test.fullpath", false, "show full file names in error messages")
   445  
   446  	initBenchmarkFlags()
   447  	initFuzzFlags()
   448  }
   449  
   450  var (
   451  	// Flags, registered during Init.
   452  	short                *bool
   453  	failFast             *bool
   454  	outputDir            *string
   455  	chatty               chattyFlag
   456  	count                *uint
   457  	coverProfile         *string
   458  	gocoverdir           *string
   459  	matchList            *string
   460  	match                *string
   461  	skip                 *string
   462  	memProfile           *string
   463  	memProfileRate       *int
   464  	cpuProfile           *string
   465  	blockProfile         *string
   466  	blockProfileRate     *int
   467  	mutexProfile         *string
   468  	mutexProfileFraction *int
   469  	panicOnExit0         *bool
   470  	traceFile            *string
   471  	timeout              *time.Duration
   472  	cpuListStr           *string
   473  	parallel             *int
   474  	shuffle              *string
   475  	testlog              *string
   476  	fullPath             *bool
   477  
   478  	haveExamples bool // are there examples?
   479  
   480  	cpuList     []int
   481  	testlogFile *os.File
   482  
   483  	numFailed atomic.Uint32 // number of test failures
   484  
   485  	running sync.Map // map[string]time.Time of running, unpaused tests
   486  )
   487  
   488  type chattyFlag struct {
   489  	on   bool // -v is set in some form
   490  	json bool // -v=test2json is set, to make output better for test2json
   491  }
   492  
   493  func (*chattyFlag) IsBoolFlag() bool { return true }
   494  
   495  func (f *chattyFlag) Set(arg string) error {
   496  	switch arg {
   497  	default:
   498  		return fmt.Errorf("invalid flag -test.v=%s", arg)
   499  	case "true", "test2json":
   500  		f.on = true
   501  		f.json = arg == "test2json"
   502  	case "false":
   503  		f.on = false
   504  		f.json = false
   505  	}
   506  	return nil
   507  }
   508  
   509  func (f *chattyFlag) String() string {
   510  	if f.json {
   511  		return "test2json"
   512  	}
   513  	if f.on {
   514  		return "true"
   515  	}
   516  	return "false"
   517  }
   518  
   519  func (f *chattyFlag) Get() any {
   520  	if f.json {
   521  		return "test2json"
   522  	}
   523  	return f.on
   524  }
   525  
   526  const marker = byte(0x16) // ^V for framing
   527  
   528  func (f *chattyFlag) prefix() string {
   529  	if f.json {
   530  		return string(marker)
   531  	}
   532  	return ""
   533  }
   534  
   535  type chattyPrinter struct {
   536  	w          io.Writer
   537  	lastNameMu sync.Mutex // guards lastName
   538  	lastName   string     // last printed test name in chatty mode
   539  	json       bool       // -v=json output mode
   540  }
   541  
   542  func newChattyPrinter(w io.Writer) *chattyPrinter {
   543  	return &chattyPrinter{w: w, json: chatty.json}
   544  }
   545  
   546  // prefix is like chatty.prefix but using p.json instead of chatty.json.
   547  // Using p.json allows tests to check the json behavior without modifying
   548  // the global variable. For convenience, we allow p == nil and treat
   549  // that as not in json mode (because it's not chatty at all).
   550  func (p *chattyPrinter) prefix() string {
   551  	if p != nil && p.json {
   552  		return string(marker)
   553  	}
   554  	return ""
   555  }
   556  
   557  // Updatef prints a message about the status of the named test to w.
   558  //
   559  // The formatted message must include the test name itself.
   560  func (p *chattyPrinter) Updatef(testName, format string, args ...any) {
   561  	p.lastNameMu.Lock()
   562  	defer p.lastNameMu.Unlock()
   563  
   564  	// Since the message already implies an association with a specific new test,
   565  	// we don't need to check what the old test name was or log an extra NAME line
   566  	// for it. (We're updating it anyway, and the current message already includes
   567  	// the test name.)
   568  	p.lastName = testName
   569  	fmt.Fprintf(p.w, p.prefix()+format, args...)
   570  }
   571  
   572  // Printf prints a message, generated by the named test, that does not
   573  // necessarily mention that tests's name itself.
   574  func (p *chattyPrinter) Printf(testName, format string, args ...any) {
   575  	p.lastNameMu.Lock()
   576  	defer p.lastNameMu.Unlock()
   577  
   578  	if p.lastName == "" {
   579  		p.lastName = testName
   580  	} else if p.lastName != testName {
   581  		fmt.Fprintf(p.w, "%s=== NAME  %s\n", p.prefix(), testName)
   582  		p.lastName = testName
   583  	}
   584  
   585  	fmt.Fprintf(p.w, format, args...)
   586  }
   587  
   588  // The maximum number of stack frames to go through when skipping helper functions for
   589  // the purpose of decorating log messages.
   590  const maxStackLen = 50
   591  
   592  // common holds the elements common between T and B and
   593  // captures common methods such as Errorf.
   594  type common struct {
   595  	mu          sync.RWMutex         // guards this group of fields
   596  	output      []byte               // Output generated by test or benchmark.
   597  	w           io.Writer            // For flushToParent.
   598  	ran         bool                 // Test or benchmark (or one of its subtests) was executed.
   599  	failed      bool                 // Test or benchmark has failed.
   600  	skipped     bool                 // Test or benchmark has been skipped.
   601  	done        bool                 // Test is finished and all subtests have completed.
   602  	helperPCs   map[uintptr]struct{} // functions to be skipped when writing file/line info
   603  	helperNames map[string]struct{}  // helperPCs converted to function names
   604  	cleanups    []func()             // optional functions to be called at the end of the test
   605  	cleanupName string               // Name of the cleanup function.
   606  	cleanupPc   []uintptr            // The stack trace at the point where Cleanup was called.
   607  	finished    bool                 // Test function has completed.
   608  	inFuzzFn    bool                 // Whether the fuzz target, if this is one, is running.
   609  
   610  	chatty         *chattyPrinter // A copy of chattyPrinter, if the chatty flag is set.
   611  	bench          bool           // Whether the current test is a benchmark.
   612  	hasSub         atomic.Bool    // whether there are sub-benchmarks.
   613  	cleanupStarted atomic.Bool    // Registered cleanup callbacks have started to execute
   614  	runner         string         // Function name of tRunner running the test.
   615  	isParallel     bool           // Whether the test is parallel.
   616  
   617  	parent   *common
   618  	level    int       // Nesting depth of test or benchmark.
   619  	creator  []uintptr // If level > 0, the stack trace at the point where the parent called t.Run.
   620  	name     string    // Name of test or benchmark.
   621  	start    time.Time // Time test or benchmark started
   622  	duration time.Duration
   623  	barrier  chan bool // To signal parallel subtests they may start. Nil when T.Parallel is not present (B) or not usable (when fuzzing).
   624  	signal   chan bool // To signal a test is done.
   625  	sub      []*T      // Queue of subtests to be run in parallel.
   626  
   627  	lastRaceErrors  atomic.Int64 // Max value of race.Errors seen during the test or its subtests.
   628  	raceErrorLogged atomic.Bool
   629  
   630  	tempDirMu  sync.Mutex
   631  	tempDir    string
   632  	tempDirErr error
   633  	tempDirSeq int32
   634  }
   635  
   636  // Short reports whether the -test.short flag is set.
   637  func Short() bool {
   638  	if short == nil {
   639  		panic("testing: Short called before Init")
   640  	}
   641  	// Catch code that calls this from TestMain without first calling flag.Parse.
   642  	if !flag.Parsed() {
   643  		panic("testing: Short called before Parse")
   644  	}
   645  
   646  	return *short
   647  }
   648  
   649  // testBinary is set by cmd/go to "1" if this is a binary built by "go test".
   650  // The value is set to "1" by a -X option to cmd/link. We assume that
   651  // because this is possible, the compiler will not optimize testBinary
   652  // into a constant on the basis that it is an unexported package-scope
   653  // variable that is never changed. If the compiler ever starts implementing
   654  // such an optimization, we will need some technique to mark this variable
   655  // as "changed by a cmd/link -X option".
   656  var testBinary = "0"
   657  
   658  // Testing reports whether the current code is being run in a test.
   659  // This will report true in programs created by "go test",
   660  // false in programs created by "go build".
   661  func Testing() bool {
   662  	return testBinary == "1"
   663  }
   664  
   665  // CoverMode reports what the test coverage mode is set to. The
   666  // values are "set", "count", or "atomic". The return value will be
   667  // empty if test coverage is not enabled.
   668  func CoverMode() string {
   669  	if goexperiment.CoverageRedesign {
   670  		return cover2.mode
   671  	}
   672  	return cover.Mode
   673  }
   674  
   675  // Verbose reports whether the -test.v flag is set.
   676  func Verbose() bool {
   677  	// Same as in Short.
   678  	if !flag.Parsed() {
   679  		panic("testing: Verbose called before Parse")
   680  	}
   681  	return chatty.on
   682  }
   683  
   684  func (c *common) checkFuzzFn(name string) {
   685  	if c.inFuzzFn {
   686  		panic(fmt.Sprintf("testing: f.%s was called inside the fuzz target, use t.%s instead", name, name))
   687  	}
   688  }
   689  
   690  // frameSkip searches, starting after skip frames, for the first caller frame
   691  // in a function not marked as a helper and returns that frame.
   692  // The search stops if it finds a tRunner function that
   693  // was the entry point into the test and the test is not a subtest.
   694  // This function must be called with c.mu held.
   695  func (c *common) frameSkip(skip int) runtime.Frame {
   696  	// If the search continues into the parent test, we'll have to hold
   697  	// its mu temporarily. If we then return, we need to unlock it.
   698  	shouldUnlock := false
   699  	defer func() {
   700  		if shouldUnlock {
   701  			c.mu.Unlock()
   702  		}
   703  	}()
   704  	var pc [maxStackLen]uintptr
   705  	// Skip two extra frames to account for this function
   706  	// and runtime.Callers itself.
   707  	n := runtime.Callers(skip+2, pc[:])
   708  	if n == 0 {
   709  		panic("testing: zero callers found")
   710  	}
   711  	frames := runtime.CallersFrames(pc[:n])
   712  	var firstFrame, prevFrame, frame runtime.Frame
   713  	for more := true; more; prevFrame = frame {
   714  		frame, more = frames.Next()
   715  		if frame.Function == "runtime.gopanic" {
   716  			continue
   717  		}
   718  		if frame.Function == c.cleanupName {
   719  			frames = runtime.CallersFrames(c.cleanupPc)
   720  			continue
   721  		}
   722  		if firstFrame.PC == 0 {
   723  			firstFrame = frame
   724  		}
   725  		if frame.Function == c.runner {
   726  			// We've gone up all the way to the tRunner calling
   727  			// the test function (so the user must have
   728  			// called tb.Helper from inside that test function).
   729  			// If this is a top-level test, only skip up to the test function itself.
   730  			// If we're in a subtest, continue searching in the parent test,
   731  			// starting from the point of the call to Run which created this subtest.
   732  			if c.level > 1 {
   733  				frames = runtime.CallersFrames(c.creator)
   734  				parent := c.parent
   735  				// We're no longer looking at the current c after this point,
   736  				// so we should unlock its mu, unless it's the original receiver,
   737  				// in which case our caller doesn't expect us to do that.
   738  				if shouldUnlock {
   739  					c.mu.Unlock()
   740  				}
   741  				c = parent
   742  				// Remember to unlock c.mu when we no longer need it, either
   743  				// because we went up another nesting level, or because we
   744  				// returned.
   745  				shouldUnlock = true
   746  				c.mu.Lock()
   747  				continue
   748  			}
   749  			return prevFrame
   750  		}
   751  		// If more helper PCs have been added since we last did the conversion
   752  		if c.helperNames == nil {
   753  			c.helperNames = make(map[string]struct{})
   754  			for pc := range c.helperPCs {
   755  				c.helperNames[pcToName(pc)] = struct{}{}
   756  			}
   757  		}
   758  		if _, ok := c.helperNames[frame.Function]; !ok {
   759  			// Found a frame that wasn't inside a helper function.
   760  			return frame
   761  		}
   762  	}
   763  	return firstFrame
   764  }
   765  
   766  // decorate prefixes the string with the file and line of the call site
   767  // and inserts the final newline if needed and indentation spaces for formatting.
   768  // This function must be called with c.mu held.
   769  func (c *common) decorate(s string, skip int) string {
   770  	frame := c.frameSkip(skip)
   771  	file := frame.File
   772  	line := frame.Line
   773  	if file != "" {
   774  		if *fullPath {
   775  			// If relative path, truncate file name at last file name separator.
   776  		} else if index := strings.LastIndexAny(file, `/\`); index >= 0 {
   777  			file = file[index+1:]
   778  		}
   779  	} else {
   780  		file = "???"
   781  	}
   782  	if line == 0 {
   783  		line = 1
   784  	}
   785  	buf := new(strings.Builder)
   786  	// Every line is indented at least 4 spaces.
   787  	buf.WriteString("    ")
   788  	fmt.Fprintf(buf, "%s:%d: ", file, line)
   789  	lines := strings.Split(s, "\n")
   790  	if l := len(lines); l > 1 && lines[l-1] == "" {
   791  		lines = lines[:l-1]
   792  	}
   793  	for i, line := range lines {
   794  		if i > 0 {
   795  			// Second and subsequent lines are indented an additional 4 spaces.
   796  			buf.WriteString("\n        ")
   797  		}
   798  		buf.WriteString(line)
   799  	}
   800  	buf.WriteByte('\n')
   801  	return buf.String()
   802  }
   803  
   804  // flushToParent writes c.output to the parent after first writing the header
   805  // with the given format and arguments.
   806  func (c *common) flushToParent(testName, format string, args ...any) {
   807  	p := c.parent
   808  	p.mu.Lock()
   809  	defer p.mu.Unlock()
   810  
   811  	c.mu.Lock()
   812  	defer c.mu.Unlock()
   813  
   814  	if len(c.output) > 0 {
   815  		// Add the current c.output to the print,
   816  		// and then arrange for the print to replace c.output.
   817  		// (This displays the logged output after the --- FAIL line.)
   818  		format += "%s"
   819  		args = append(args[:len(args):len(args)], c.output)
   820  		c.output = c.output[:0]
   821  	}
   822  
   823  	if c.chatty != nil && (p.w == c.chatty.w || c.chatty.json) {
   824  		// We're flushing to the actual output, so track that this output is
   825  		// associated with a specific test (and, specifically, that the next output
   826  		// is *not* associated with that test).
   827  		//
   828  		// Moreover, if c.output is non-empty it is important that this write be
   829  		// atomic with respect to the output of other tests, so that we don't end up
   830  		// with confusing '=== NAME' lines in the middle of our '--- PASS' block.
   831  		// Neither humans nor cmd/test2json can parse those easily.
   832  		// (See https://go.dev/issue/40771.)
   833  		//
   834  		// If test2json is used, we never flush to parent tests,
   835  		// so that the json stream shows subtests as they finish.
   836  		// (See https://go.dev/issue/29811.)
   837  		c.chatty.Updatef(testName, format, args...)
   838  	} else {
   839  		// We're flushing to the output buffer of the parent test, which will
   840  		// itself follow a test-name header when it is finally flushed to stdout.
   841  		fmt.Fprintf(p.w, c.chatty.prefix()+format, args...)
   842  	}
   843  }
   844  
   845  type indenter struct {
   846  	c *common
   847  }
   848  
   849  func (w indenter) Write(b []byte) (n int, err error) {
   850  	n = len(b)
   851  	for len(b) > 0 {
   852  		end := bytes.IndexByte(b, '\n')
   853  		if end == -1 {
   854  			end = len(b)
   855  		} else {
   856  			end++
   857  		}
   858  		// An indent of 4 spaces will neatly align the dashes with the status
   859  		// indicator of the parent.
   860  		line := b[:end]
   861  		if line[0] == marker {
   862  			w.c.output = append(w.c.output, marker)
   863  			line = line[1:]
   864  		}
   865  		const indent = "    "
   866  		w.c.output = append(w.c.output, indent...)
   867  		w.c.output = append(w.c.output, line...)
   868  		b = b[end:]
   869  	}
   870  	return
   871  }
   872  
   873  // fmtDuration returns a string representing d in the form "87.00s".
   874  func fmtDuration(d time.Duration) string {
   875  	return fmt.Sprintf("%.2fs", d.Seconds())
   876  }
   877  
   878  // TB is the interface common to T, B, and F.
   879  type TB interface {
   880  	Cleanup(func())
   881  	Error(args ...any)
   882  	Errorf(format string, args ...any)
   883  	Fail()
   884  	FailNow()
   885  	Failed() bool
   886  	Fatal(args ...any)
   887  	Fatalf(format string, args ...any)
   888  	Helper()
   889  	Log(args ...any)
   890  	Logf(format string, args ...any)
   891  	Name() string
   892  	Setenv(key, value string)
   893  	Skip(args ...any)
   894  	SkipNow()
   895  	Skipf(format string, args ...any)
   896  	Skipped() bool
   897  	TempDir() string
   898  
   899  	// A private method to prevent users implementing the
   900  	// interface and so future additions to it will not
   901  	// violate Go 1 compatibility.
   902  	private()
   903  }
   904  
   905  var _ TB = (*T)(nil)
   906  var _ TB = (*B)(nil)
   907  
   908  // T is a type passed to Test functions to manage test state and support formatted test logs.
   909  //
   910  // A test ends when its Test function returns or calls any of the methods
   911  // FailNow, Fatal, Fatalf, SkipNow, Skip, or Skipf. Those methods, as well as
   912  // the Parallel method, must be called only from the goroutine running the
   913  // Test function.
   914  //
   915  // The other reporting methods, such as the variations of Log and Error,
   916  // may be called simultaneously from multiple goroutines.
   917  type T struct {
   918  	common
   919  	isEnvSet bool
   920  	context  *testContext // For running tests and subtests.
   921  }
   922  
   923  func (c *common) private() {}
   924  
   925  // Name returns the name of the running (sub-) test or benchmark.
   926  //
   927  // The name will include the name of the test along with the names of
   928  // any nested sub-tests. If two sibling sub-tests have the same name,
   929  // Name will append a suffix to guarantee the returned name is unique.
   930  func (c *common) Name() string {
   931  	return c.name
   932  }
   933  
   934  func (c *common) setRan() {
   935  	if c.parent != nil {
   936  		c.parent.setRan()
   937  	}
   938  	c.mu.Lock()
   939  	defer c.mu.Unlock()
   940  	c.ran = true
   941  }
   942  
   943  // Fail marks the function as having failed but continues execution.
   944  func (c *common) Fail() {
   945  	if c.parent != nil {
   946  		c.parent.Fail()
   947  	}
   948  	c.mu.Lock()
   949  	defer c.mu.Unlock()
   950  	// c.done needs to be locked to synchronize checks to c.done in parent tests.
   951  	if c.done {
   952  		panic("Fail in goroutine after " + c.name + " has completed")
   953  	}
   954  	c.failed = true
   955  }
   956  
   957  // Failed reports whether the function has failed.
   958  func (c *common) Failed() bool {
   959  	c.mu.RLock()
   960  	defer c.mu.RUnlock()
   961  
   962  	if !c.done && int64(race.Errors()) > c.lastRaceErrors.Load() {
   963  		c.mu.RUnlock()
   964  		c.checkRaces()
   965  		c.mu.RLock()
   966  	}
   967  
   968  	return c.failed
   969  }
   970  
   971  // FailNow marks the function as having failed and stops its execution
   972  // by calling runtime.Goexit (which then runs all deferred calls in the
   973  // current goroutine).
   974  // Execution will continue at the next test or benchmark.
   975  // FailNow must be called from the goroutine running the
   976  // test or benchmark function, not from other goroutines
   977  // created during the test. Calling FailNow does not stop
   978  // those other goroutines.
   979  func (c *common) FailNow() {
   980  	c.checkFuzzFn("FailNow")
   981  	c.Fail()
   982  
   983  	// Calling runtime.Goexit will exit the goroutine, which
   984  	// will run the deferred functions in this goroutine,
   985  	// which will eventually run the deferred lines in tRunner,
   986  	// which will signal to the test loop that this test is done.
   987  	//
   988  	// A previous version of this code said:
   989  	//
   990  	//	c.duration = ...
   991  	//	c.signal <- c.self
   992  	//	runtime.Goexit()
   993  	//
   994  	// This previous version duplicated code (those lines are in
   995  	// tRunner no matter what), but worse the goroutine teardown
   996  	// implicit in runtime.Goexit was not guaranteed to complete
   997  	// before the test exited. If a test deferred an important cleanup
   998  	// function (like removing temporary files), there was no guarantee
   999  	// it would run on a test failure. Because we send on c.signal during
  1000  	// a top-of-stack deferred function now, we know that the send
  1001  	// only happens after any other stacked defers have completed.
  1002  	c.mu.Lock()
  1003  	c.finished = true
  1004  	c.mu.Unlock()
  1005  	runtime.Goexit()
  1006  }
  1007  
  1008  // log generates the output. It's always at the same stack depth.
  1009  func (c *common) log(s string) {
  1010  	c.logDepth(s, 3) // logDepth + log + public function
  1011  }
  1012  
  1013  // logDepth generates the output at an arbitrary stack depth.
  1014  func (c *common) logDepth(s string, depth int) {
  1015  	c.mu.Lock()
  1016  	defer c.mu.Unlock()
  1017  	if c.done {
  1018  		// This test has already finished. Try and log this message
  1019  		// with our parent. If we don't have a parent, panic.
  1020  		for parent := c.parent; parent != nil; parent = parent.parent {
  1021  			parent.mu.Lock()
  1022  			defer parent.mu.Unlock()
  1023  			if !parent.done {
  1024  				parent.output = append(parent.output, parent.decorate(s, depth+1)...)
  1025  				return
  1026  			}
  1027  		}
  1028  		panic("Log in goroutine after " + c.name + " has completed: " + s)
  1029  	} else {
  1030  		if c.chatty != nil {
  1031  			if c.bench {
  1032  				// Benchmarks don't print === CONT, so we should skip the test
  1033  				// printer and just print straight to stdout.
  1034  				fmt.Print(c.decorate(s, depth+1))
  1035  			} else {
  1036  				c.chatty.Printf(c.name, "%s", c.decorate(s, depth+1))
  1037  			}
  1038  
  1039  			return
  1040  		}
  1041  		c.output = append(c.output, c.decorate(s, depth+1)...)
  1042  	}
  1043  }
  1044  
  1045  // Log formats its arguments using default formatting, analogous to Println,
  1046  // and records the text in the error log. For tests, the text will be printed only if
  1047  // the test fails or the -test.v flag is set. For benchmarks, the text is always
  1048  // printed to avoid having performance depend on the value of the -test.v flag.
  1049  func (c *common) Log(args ...any) {
  1050  	c.checkFuzzFn("Log")
  1051  	c.log(fmt.Sprintln(args...))
  1052  }
  1053  
  1054  // Logf formats its arguments according to the format, analogous to Printf, and
  1055  // records the text in the error log. A final newline is added if not provided. For
  1056  // tests, the text will be printed only if the test fails or the -test.v flag is
  1057  // set. For benchmarks, the text is always printed to avoid having performance
  1058  // depend on the value of the -test.v flag.
  1059  func (c *common) Logf(format string, args ...any) {
  1060  	c.checkFuzzFn("Logf")
  1061  	c.log(fmt.Sprintf(format, args...))
  1062  }
  1063  
  1064  // Error is equivalent to Log followed by Fail.
  1065  func (c *common) Error(args ...any) {
  1066  	c.checkFuzzFn("Error")
  1067  	c.log(fmt.Sprintln(args...))
  1068  	c.Fail()
  1069  }
  1070  
  1071  // Errorf is equivalent to Logf followed by Fail.
  1072  func (c *common) Errorf(format string, args ...any) {
  1073  	c.checkFuzzFn("Errorf")
  1074  	c.log(fmt.Sprintf(format, args...))
  1075  	c.Fail()
  1076  }
  1077  
  1078  // Fatal is equivalent to Log followed by FailNow.
  1079  func (c *common) Fatal(args ...any) {
  1080  	c.checkFuzzFn("Fatal")
  1081  	c.log(fmt.Sprintln(args...))
  1082  	c.FailNow()
  1083  }
  1084  
  1085  // Fatalf is equivalent to Logf followed by FailNow.
  1086  func (c *common) Fatalf(format string, args ...any) {
  1087  	c.checkFuzzFn("Fatalf")
  1088  	c.log(fmt.Sprintf(format, args...))
  1089  	c.FailNow()
  1090  }
  1091  
  1092  // Skip is equivalent to Log followed by SkipNow.
  1093  func (c *common) Skip(args ...any) {
  1094  	c.checkFuzzFn("Skip")
  1095  	c.log(fmt.Sprintln(args...))
  1096  	c.SkipNow()
  1097  }
  1098  
  1099  // Skipf is equivalent to Logf followed by SkipNow.
  1100  func (c *common) Skipf(format string, args ...any) {
  1101  	c.checkFuzzFn("Skipf")
  1102  	c.log(fmt.Sprintf(format, args...))
  1103  	c.SkipNow()
  1104  }
  1105  
  1106  // SkipNow marks the test as having been skipped and stops its execution
  1107  // by calling [runtime.Goexit].
  1108  // If a test fails (see Error, Errorf, Fail) and is then skipped,
  1109  // it is still considered to have failed.
  1110  // Execution will continue at the next test or benchmark. See also FailNow.
  1111  // SkipNow must be called from the goroutine running the test, not from
  1112  // other goroutines created during the test. Calling SkipNow does not stop
  1113  // those other goroutines.
  1114  func (c *common) SkipNow() {
  1115  	c.checkFuzzFn("SkipNow")
  1116  	c.mu.Lock()
  1117  	c.skipped = true
  1118  	c.finished = true
  1119  	c.mu.Unlock()
  1120  	runtime.Goexit()
  1121  }
  1122  
  1123  // Skipped reports whether the test was skipped.
  1124  func (c *common) Skipped() bool {
  1125  	c.mu.RLock()
  1126  	defer c.mu.RUnlock()
  1127  	return c.skipped
  1128  }
  1129  
  1130  // Helper marks the calling function as a test helper function.
  1131  // When printing file and line information, that function will be skipped.
  1132  // Helper may be called simultaneously from multiple goroutines.
  1133  func (c *common) Helper() {
  1134  	c.mu.Lock()
  1135  	defer c.mu.Unlock()
  1136  	if c.helperPCs == nil {
  1137  		c.helperPCs = make(map[uintptr]struct{})
  1138  	}
  1139  	// repeating code from callerName here to save walking a stack frame
  1140  	var pc [1]uintptr
  1141  	n := runtime.Callers(2, pc[:]) // skip runtime.Callers + Helper
  1142  	if n == 0 {
  1143  		panic("testing: zero callers found")
  1144  	}
  1145  	if _, found := c.helperPCs[pc[0]]; !found {
  1146  		c.helperPCs[pc[0]] = struct{}{}
  1147  		c.helperNames = nil // map will be recreated next time it is needed
  1148  	}
  1149  }
  1150  
  1151  // Cleanup registers a function to be called when the test (or subtest) and all its
  1152  // subtests complete. Cleanup functions will be called in last added,
  1153  // first called order.
  1154  func (c *common) Cleanup(f func()) {
  1155  	c.checkFuzzFn("Cleanup")
  1156  	var pc [maxStackLen]uintptr
  1157  	// Skip two extra frames to account for this function and runtime.Callers itself.
  1158  	n := runtime.Callers(2, pc[:])
  1159  	cleanupPc := pc[:n]
  1160  
  1161  	fn := func() {
  1162  		defer func() {
  1163  			c.mu.Lock()
  1164  			defer c.mu.Unlock()
  1165  			c.cleanupName = ""
  1166  			c.cleanupPc = nil
  1167  		}()
  1168  
  1169  		name := callerName(0)
  1170  		c.mu.Lock()
  1171  		c.cleanupName = name
  1172  		c.cleanupPc = cleanupPc
  1173  		c.mu.Unlock()
  1174  
  1175  		f()
  1176  	}
  1177  
  1178  	c.mu.Lock()
  1179  	defer c.mu.Unlock()
  1180  	c.cleanups = append(c.cleanups, fn)
  1181  }
  1182  
  1183  // TempDir returns a temporary directory for the test to use.
  1184  // The directory is automatically removed when the test and
  1185  // all its subtests complete.
  1186  // Each subsequent call to t.TempDir returns a unique directory;
  1187  // if the directory creation fails, TempDir terminates the test by calling Fatal.
  1188  func (c *common) TempDir() string {
  1189  	c.checkFuzzFn("TempDir")
  1190  	// Use a single parent directory for all the temporary directories
  1191  	// created by a test, each numbered sequentially.
  1192  	c.tempDirMu.Lock()
  1193  	var nonExistent bool
  1194  	if c.tempDir == "" { // Usually the case with js/wasm
  1195  		nonExistent = true
  1196  	} else {
  1197  		_, err := os.Stat(c.tempDir)
  1198  		nonExistent = os.IsNotExist(err)
  1199  		if err != nil && !nonExistent {
  1200  			c.Fatalf("TempDir: %v", err)
  1201  		}
  1202  	}
  1203  
  1204  	if nonExistent {
  1205  		c.Helper()
  1206  
  1207  		// Drop unusual characters (such as path separators or
  1208  		// characters interacting with globs) from the directory name to
  1209  		// avoid surprising os.MkdirTemp behavior.
  1210  		mapper := func(r rune) rune {
  1211  			if r < utf8.RuneSelf {
  1212  				const allowed = "!#$%&()+,-.=@^_{}~ "
  1213  				if '0' <= r && r <= '9' ||
  1214  					'a' <= r && r <= 'z' ||
  1215  					'A' <= r && r <= 'Z' {
  1216  					return r
  1217  				}
  1218  				if strings.ContainsRune(allowed, r) {
  1219  					return r
  1220  				}
  1221  			} else if unicode.IsLetter(r) || unicode.IsNumber(r) {
  1222  				return r
  1223  			}
  1224  			return -1
  1225  		}
  1226  		pattern := strings.Map(mapper, c.Name())
  1227  		c.tempDir, c.tempDirErr = os.MkdirTemp("", pattern)
  1228  		if c.tempDirErr == nil {
  1229  			c.Cleanup(func() {
  1230  				if err := removeAll(c.tempDir); err != nil {
  1231  					c.Errorf("TempDir RemoveAll cleanup: %v", err)
  1232  				}
  1233  			})
  1234  		}
  1235  	}
  1236  
  1237  	if c.tempDirErr == nil {
  1238  		c.tempDirSeq++
  1239  	}
  1240  	seq := c.tempDirSeq
  1241  	c.tempDirMu.Unlock()
  1242  
  1243  	if c.tempDirErr != nil {
  1244  		c.Fatalf("TempDir: %v", c.tempDirErr)
  1245  	}
  1246  
  1247  	dir := fmt.Sprintf("%s%c%03d", c.tempDir, os.PathSeparator, seq)
  1248  	if err := os.Mkdir(dir, 0777); err != nil {
  1249  		c.Fatalf("TempDir: %v", err)
  1250  	}
  1251  	return dir
  1252  }
  1253  
  1254  // removeAll is like os.RemoveAll, but retries Windows "Access is denied."
  1255  // errors up to an arbitrary timeout.
  1256  //
  1257  // Those errors have been known to occur spuriously on at least the
  1258  // windows-amd64-2012 builder (https://go.dev/issue/50051), and can only occur
  1259  // legitimately if the test leaves behind a temp file that either is still open
  1260  // or the test otherwise lacks permission to delete. In the case of legitimate
  1261  // failures, a failing test may take a bit longer to fail, but once the test is
  1262  // fixed the extra latency will go away.
  1263  func removeAll(path string) error {
  1264  	const arbitraryTimeout = 2 * time.Second
  1265  	var (
  1266  		start     time.Time
  1267  		nextSleep = 1 * time.Millisecond
  1268  	)
  1269  	for {
  1270  		err := os.RemoveAll(path)
  1271  		if !isWindowsRetryable(err) {
  1272  			return err
  1273  		}
  1274  		if start.IsZero() {
  1275  			start = time.Now()
  1276  		} else if d := time.Since(start) + nextSleep; d >= arbitraryTimeout {
  1277  			return err
  1278  		}
  1279  		time.Sleep(nextSleep)
  1280  		nextSleep += time.Duration(rand.Int63n(int64(nextSleep)))
  1281  	}
  1282  }
  1283  
  1284  // Setenv calls os.Setenv(key, value) and uses Cleanup to
  1285  // restore the environment variable to its original value
  1286  // after the test.
  1287  //
  1288  // Because Setenv affects the whole process, it cannot be used
  1289  // in parallel tests or tests with parallel ancestors.
  1290  func (c *common) Setenv(key, value string) {
  1291  	c.checkFuzzFn("Setenv")
  1292  	prevValue, ok := os.LookupEnv(key)
  1293  
  1294  	if err := os.Setenv(key, value); err != nil {
  1295  		c.Fatalf("cannot set environment variable: %v", err)
  1296  	}
  1297  
  1298  	if ok {
  1299  		c.Cleanup(func() {
  1300  			os.Setenv(key, prevValue)
  1301  		})
  1302  	} else {
  1303  		c.Cleanup(func() {
  1304  			os.Unsetenv(key)
  1305  		})
  1306  	}
  1307  }
  1308  
  1309  // panicHanding controls the panic handling used by runCleanup.
  1310  type panicHandling int
  1311  
  1312  const (
  1313  	normalPanic panicHandling = iota
  1314  	recoverAndReturnPanic
  1315  )
  1316  
  1317  // runCleanup is called at the end of the test.
  1318  // If ph is recoverAndReturnPanic, it will catch panics, and return the
  1319  // recovered value if any.
  1320  func (c *common) runCleanup(ph panicHandling) (panicVal any) {
  1321  	c.cleanupStarted.Store(true)
  1322  	defer c.cleanupStarted.Store(false)
  1323  
  1324  	if ph == recoverAndReturnPanic {
  1325  		defer func() {
  1326  			panicVal = recover()
  1327  		}()
  1328  	}
  1329  
  1330  	// Make sure that if a cleanup function panics,
  1331  	// we still run the remaining cleanup functions.
  1332  	defer func() {
  1333  		c.mu.Lock()
  1334  		recur := len(c.cleanups) > 0
  1335  		c.mu.Unlock()
  1336  		if recur {
  1337  			c.runCleanup(normalPanic)
  1338  		}
  1339  	}()
  1340  
  1341  	for {
  1342  		var cleanup func()
  1343  		c.mu.Lock()
  1344  		if len(c.cleanups) > 0 {
  1345  			last := len(c.cleanups) - 1
  1346  			cleanup = c.cleanups[last]
  1347  			c.cleanups = c.cleanups[:last]
  1348  		}
  1349  		c.mu.Unlock()
  1350  		if cleanup == nil {
  1351  			return nil
  1352  		}
  1353  		cleanup()
  1354  	}
  1355  }
  1356  
  1357  // resetRaces updates c.parent's count of data race errors (or the global count,
  1358  // if c has no parent), and updates c.lastRaceErrors to match.
  1359  //
  1360  // Any races that occurred prior to this call to resetRaces will
  1361  // not be attributed to c.
  1362  func (c *common) resetRaces() {
  1363  	if c.parent == nil {
  1364  		c.lastRaceErrors.Store(int64(race.Errors()))
  1365  	} else {
  1366  		c.lastRaceErrors.Store(c.parent.checkRaces())
  1367  	}
  1368  }
  1369  
  1370  // checkRaces checks whether the global count of data race errors has increased
  1371  // since c's count was last reset.
  1372  //
  1373  // If so, it marks c as having failed due to those races (logging an error for
  1374  // the first such race), and updates the race counts for the parents of c so
  1375  // that if they are currently suspended (such as in a call to T.Run) they will
  1376  // not log separate errors for the race(s).
  1377  //
  1378  // Note that multiple tests may be marked as failed due to the same race if they
  1379  // are executing in parallel.
  1380  func (c *common) checkRaces() (raceErrors int64) {
  1381  	raceErrors = int64(race.Errors())
  1382  	for {
  1383  		last := c.lastRaceErrors.Load()
  1384  		if raceErrors <= last {
  1385  			// All races have already been reported.
  1386  			return raceErrors
  1387  		}
  1388  		if c.lastRaceErrors.CompareAndSwap(last, raceErrors) {
  1389  			break
  1390  		}
  1391  	}
  1392  
  1393  	if c.raceErrorLogged.CompareAndSwap(false, true) {
  1394  		// This is the first race we've encountered for this test.
  1395  		// Mark the test as failed, and log the reason why only once.
  1396  		// (Note that the race detector itself will still write a goroutine
  1397  		// dump for any further races it detects.)
  1398  		c.Errorf("race detected during execution of test")
  1399  	}
  1400  
  1401  	// Update the parent(s) of this test so that they don't re-report the race.
  1402  	parent := c.parent
  1403  	for parent != nil {
  1404  		for {
  1405  			last := parent.lastRaceErrors.Load()
  1406  			if raceErrors <= last {
  1407  				// This race was already reported by another (likely parallel) subtest.
  1408  				return raceErrors
  1409  			}
  1410  			if parent.lastRaceErrors.CompareAndSwap(last, raceErrors) {
  1411  				break
  1412  			}
  1413  		}
  1414  		parent = parent.parent
  1415  	}
  1416  
  1417  	return raceErrors
  1418  }
  1419  
  1420  // callerName gives the function name (qualified with a package path)
  1421  // for the caller after skip frames (where 0 means the current function).
  1422  func callerName(skip int) string {
  1423  	var pc [1]uintptr
  1424  	n := runtime.Callers(skip+2, pc[:]) // skip + runtime.Callers + callerName
  1425  	if n == 0 {
  1426  		panic("testing: zero callers found")
  1427  	}
  1428  	return pcToName(pc[0])
  1429  }
  1430  
  1431  func pcToName(pc uintptr) string {
  1432  	pcs := []uintptr{pc}
  1433  	frames := runtime.CallersFrames(pcs)
  1434  	frame, _ := frames.Next()
  1435  	return frame.Function
  1436  }
  1437  
  1438  // Parallel signals that this test is to be run in parallel with (and only with)
  1439  // other parallel tests. When a test is run multiple times due to use of
  1440  // -test.count or -test.cpu, multiple instances of a single test never run in
  1441  // parallel with each other.
  1442  func (t *T) Parallel() {
  1443  	if t.isParallel {
  1444  		panic("testing: t.Parallel called multiple times")
  1445  	}
  1446  	if t.isEnvSet {
  1447  		panic("testing: t.Parallel called after t.Setenv; cannot set environment variables in parallel tests")
  1448  	}
  1449  	t.isParallel = true
  1450  	if t.parent.barrier == nil {
  1451  		// T.Parallel has no effect when fuzzing.
  1452  		// Multiple processes may run in parallel, but only one input can run at a
  1453  		// time per process so we can attribute crashes to specific inputs.
  1454  		return
  1455  	}
  1456  
  1457  	// We don't want to include the time we spend waiting for serial tests
  1458  	// in the test duration. Record the elapsed time thus far and reset the
  1459  	// timer afterwards.
  1460  	t.duration += time.Since(t.start)
  1461  
  1462  	// Add to the list of tests to be released by the parent.
  1463  	t.parent.sub = append(t.parent.sub, t)
  1464  
  1465  	// Report any races during execution of this test up to this point.
  1466  	//
  1467  	// We will assume that any races that occur between here and the point where
  1468  	// we unblock are not caused by this subtest. That assumption usually holds,
  1469  	// although it can be wrong if the test spawns a goroutine that races in the
  1470  	// background while the rest of the test is blocked on the call to Parallel.
  1471  	// If that happens, we will misattribute the background race to some other
  1472  	// test, or to no test at all — but that false-negative is so unlikely that it
  1473  	// is not worth adding race-report noise for the common case where the test is
  1474  	// completely suspended during the call to Parallel.
  1475  	t.checkRaces()
  1476  
  1477  	if t.chatty != nil {
  1478  		t.chatty.Updatef(t.name, "=== PAUSE %s\n", t.name)
  1479  	}
  1480  	running.Delete(t.name)
  1481  
  1482  	t.signal <- true   // Release calling test.
  1483  	<-t.parent.barrier // Wait for the parent test to complete.
  1484  	t.context.waitParallel()
  1485  
  1486  	if t.chatty != nil {
  1487  		t.chatty.Updatef(t.name, "=== CONT  %s\n", t.name)
  1488  	}
  1489  	running.Store(t.name, time.Now())
  1490  	t.start = time.Now()
  1491  
  1492  	// Reset the local race counter to ignore any races that happened while this
  1493  	// goroutine was blocked, such as in the parent test or in other parallel
  1494  	// subtests.
  1495  	//
  1496  	// (Note that we don't call parent.checkRaces here:
  1497  	// if other parallel subtests have already introduced races, we want to
  1498  	// let them report those races instead of attributing them to the parent.)
  1499  	t.lastRaceErrors.Store(int64(race.Errors()))
  1500  }
  1501  
  1502  // Setenv calls os.Setenv(key, value) and uses Cleanup to
  1503  // restore the environment variable to its original value
  1504  // after the test.
  1505  //
  1506  // Because Setenv affects the whole process, it cannot be used
  1507  // in parallel tests or tests with parallel ancestors.
  1508  func (t *T) Setenv(key, value string) {
  1509  	// Non-parallel subtests that have parallel ancestors may still
  1510  	// run in parallel with other tests: they are only non-parallel
  1511  	// with respect to the other subtests of the same parent.
  1512  	// Since SetEnv affects the whole process, we need to disallow it
  1513  	// if the current test or any parent is parallel.
  1514  	isParallel := false
  1515  	for c := &t.common; c != nil; c = c.parent {
  1516  		if c.isParallel {
  1517  			isParallel = true
  1518  			break
  1519  		}
  1520  	}
  1521  	if isParallel {
  1522  		panic("testing: t.Setenv called after t.Parallel; cannot set environment variables in parallel tests")
  1523  	}
  1524  
  1525  	t.isEnvSet = true
  1526  
  1527  	t.common.Setenv(key, value)
  1528  }
  1529  
  1530  // InternalTest is an internal type but exported because it is cross-package;
  1531  // it is part of the implementation of the "go test" command.
  1532  type InternalTest struct {
  1533  	Name string
  1534  	F    func(*T)
  1535  }
  1536  
  1537  var errNilPanicOrGoexit = errors.New("test executed panic(nil) or runtime.Goexit")
  1538  
  1539  func tRunner(t *T, fn func(t *T)) {
  1540  	t.runner = callerName(0)
  1541  
  1542  	// When this goroutine is done, either because fn(t)
  1543  	// returned normally or because a test failure triggered
  1544  	// a call to runtime.Goexit, record the duration and send
  1545  	// a signal saying that the test is done.
  1546  	defer func() {
  1547  		t.checkRaces()
  1548  
  1549  		// TODO(#61034): This is the wrong place for this check.
  1550  		if t.Failed() {
  1551  			numFailed.Add(1)
  1552  		}
  1553  
  1554  		// Check if the test panicked or Goexited inappropriately.
  1555  		//
  1556  		// If this happens in a normal test, print output but continue panicking.
  1557  		// tRunner is called in its own goroutine, so this terminates the process.
  1558  		//
  1559  		// If this happens while fuzzing, recover from the panic and treat it like a
  1560  		// normal failure. It's important that the process keeps running in order to
  1561  		// find short inputs that cause panics.
  1562  		err := recover()
  1563  		signal := true
  1564  
  1565  		t.mu.RLock()
  1566  		finished := t.finished
  1567  		t.mu.RUnlock()
  1568  		if !finished && err == nil {
  1569  			err = errNilPanicOrGoexit
  1570  			for p := t.parent; p != nil; p = p.parent {
  1571  				p.mu.RLock()
  1572  				finished = p.finished
  1573  				p.mu.RUnlock()
  1574  				if finished {
  1575  					if !t.isParallel {
  1576  						t.Errorf("%v: subtest may have called FailNow on a parent test", err)
  1577  						err = nil
  1578  					}
  1579  					signal = false
  1580  					break
  1581  				}
  1582  			}
  1583  		}
  1584  
  1585  		if err != nil && t.context.isFuzzing {
  1586  			prefix := "panic: "
  1587  			if err == errNilPanicOrGoexit {
  1588  				prefix = ""
  1589  			}
  1590  			t.Errorf("%s%s\n%s\n", prefix, err, string(debug.Stack()))
  1591  			t.mu.Lock()
  1592  			t.finished = true
  1593  			t.mu.Unlock()
  1594  			err = nil
  1595  		}
  1596  
  1597  		// Use a deferred call to ensure that we report that the test is
  1598  		// complete even if a cleanup function calls t.FailNow. See issue 41355.
  1599  		didPanic := false
  1600  		defer func() {
  1601  			// Only report that the test is complete if it doesn't panic,
  1602  			// as otherwise the test binary can exit before the panic is
  1603  			// reported to the user. See issue 41479.
  1604  			if didPanic {
  1605  				return
  1606  			}
  1607  			if err != nil {
  1608  				panic(err)
  1609  			}
  1610  			running.Delete(t.name)
  1611  			t.signal <- signal
  1612  		}()
  1613  
  1614  		doPanic := func(err any) {
  1615  			t.Fail()
  1616  			if r := t.runCleanup(recoverAndReturnPanic); r != nil {
  1617  				t.Logf("cleanup panicked with %v", r)
  1618  			}
  1619  			// Flush the output log up to the root before dying.
  1620  			for root := &t.common; root.parent != nil; root = root.parent {
  1621  				root.mu.Lock()
  1622  				root.duration += time.Since(root.start)
  1623  				d := root.duration
  1624  				root.mu.Unlock()
  1625  				root.flushToParent(root.name, "--- FAIL: %s (%s)\n", root.name, fmtDuration(d))
  1626  				if r := root.parent.runCleanup(recoverAndReturnPanic); r != nil {
  1627  					fmt.Fprintf(root.parent.w, "cleanup panicked with %v", r)
  1628  				}
  1629  			}
  1630  			didPanic = true
  1631  			panic(err)
  1632  		}
  1633  		if err != nil {
  1634  			doPanic(err)
  1635  		}
  1636  
  1637  		t.duration += time.Since(t.start)
  1638  
  1639  		if len(t.sub) > 0 {
  1640  			// Run parallel subtests.
  1641  
  1642  			// Decrease the running count for this test and mark it as no longer running.
  1643  			t.context.release()
  1644  			running.Delete(t.name)
  1645  
  1646  			// Release the parallel subtests.
  1647  			close(t.barrier)
  1648  			// Wait for subtests to complete.
  1649  			for _, sub := range t.sub {
  1650  				<-sub.signal
  1651  			}
  1652  
  1653  			// Run any cleanup callbacks, marking the test as running
  1654  			// in case the cleanup hangs.
  1655  			cleanupStart := time.Now()
  1656  			running.Store(t.name, cleanupStart)
  1657  			err := t.runCleanup(recoverAndReturnPanic)
  1658  			t.duration += time.Since(cleanupStart)
  1659  			if err != nil {
  1660  				doPanic(err)
  1661  			}
  1662  			t.checkRaces()
  1663  			if !t.isParallel {
  1664  				// Reacquire the count for sequential tests. See comment in Run.
  1665  				t.context.waitParallel()
  1666  			}
  1667  		} else if t.isParallel {
  1668  			// Only release the count for this test if it was run as a parallel
  1669  			// test. See comment in Run method.
  1670  			t.context.release()
  1671  		}
  1672  		t.report() // Report after all subtests have finished.
  1673  
  1674  		// Do not lock t.done to allow race detector to detect race in case
  1675  		// the user does not appropriately synchronize a goroutine.
  1676  		t.done = true
  1677  		if t.parent != nil && !t.hasSub.Load() {
  1678  			t.setRan()
  1679  		}
  1680  	}()
  1681  	defer func() {
  1682  		if len(t.sub) == 0 {
  1683  			t.runCleanup(normalPanic)
  1684  		}
  1685  	}()
  1686  
  1687  	t.start = time.Now()
  1688  	t.resetRaces()
  1689  	fn(t)
  1690  
  1691  	// code beyond here will not be executed when FailNow is invoked
  1692  	t.mu.Lock()
  1693  	t.finished = true
  1694  	t.mu.Unlock()
  1695  }
  1696  
  1697  // Run runs f as a subtest of t called name. It runs f in a separate goroutine
  1698  // and blocks until f returns or calls t.Parallel to become a parallel test.
  1699  // Run reports whether f succeeded (or at least did not fail before calling t.Parallel).
  1700  //
  1701  // Run may be called simultaneously from multiple goroutines, but all such calls
  1702  // must return before the outer test function for t returns.
  1703  func (t *T) Run(name string, f func(t *T)) bool {
  1704  	if t.cleanupStarted.Load() {
  1705  		panic("testing: t.Run called during t.Cleanup")
  1706  	}
  1707  
  1708  	t.hasSub.Store(true)
  1709  	testName, ok, _ := t.context.match.fullName(&t.common, name)
  1710  	if !ok || shouldFailFast() {
  1711  		return true
  1712  	}
  1713  	// Record the stack trace at the point of this call so that if the subtest
  1714  	// function - which runs in a separate stack - is marked as a helper, we can
  1715  	// continue walking the stack into the parent test.
  1716  	var pc [maxStackLen]uintptr
  1717  	n := runtime.Callers(2, pc[:])
  1718  	t = &T{
  1719  		common: common{
  1720  			barrier: make(chan bool),
  1721  			signal:  make(chan bool, 1),
  1722  			name:    testName,
  1723  			parent:  &t.common,
  1724  			level:   t.level + 1,
  1725  			creator: pc[:n],
  1726  			chatty:  t.chatty,
  1727  		},
  1728  		context: t.context,
  1729  	}
  1730  	t.w = indenter{&t.common}
  1731  
  1732  	if t.chatty != nil {
  1733  		t.chatty.Updatef(t.name, "=== RUN   %s\n", t.name)
  1734  	}
  1735  	running.Store(t.name, time.Now())
  1736  
  1737  	// Instead of reducing the running count of this test before calling the
  1738  	// tRunner and increasing it afterwards, we rely on tRunner keeping the
  1739  	// count correct. This ensures that a sequence of sequential tests runs
  1740  	// without being preempted, even when their parent is a parallel test. This
  1741  	// may especially reduce surprises if *parallel == 1.
  1742  	go tRunner(t, f)
  1743  
  1744  	// The parent goroutine will block until the subtest either finishes or calls
  1745  	// Parallel, but in general we don't know whether the parent goroutine is the
  1746  	// top-level test function or some other goroutine it has spawned.
  1747  	// To avoid confusing false-negatives, we leave the parent in the running map
  1748  	// even though in the typical case it is blocked.
  1749  
  1750  	if !<-t.signal {
  1751  		// At this point, it is likely that FailNow was called on one of the
  1752  		// parent tests by one of the subtests. Continue aborting up the chain.
  1753  		runtime.Goexit()
  1754  	}
  1755  
  1756  	if t.chatty != nil && t.chatty.json {
  1757  		t.chatty.Updatef(t.parent.name, "=== NAME  %s\n", t.parent.name)
  1758  	}
  1759  	return !t.failed
  1760  }
  1761  
  1762  // Deadline reports the time at which the test binary will have
  1763  // exceeded the timeout specified by the -timeout flag.
  1764  //
  1765  // The ok result is false if the -timeout flag indicates “no timeout” (0).
  1766  func (t *T) Deadline() (deadline time.Time, ok bool) {
  1767  	deadline = t.context.deadline
  1768  	return deadline, !deadline.IsZero()
  1769  }
  1770  
  1771  // testContext holds all fields that are common to all tests. This includes
  1772  // synchronization primitives to run at most *parallel tests.
  1773  type testContext struct {
  1774  	match    *matcher
  1775  	deadline time.Time
  1776  
  1777  	// isFuzzing is true in the context used when generating random inputs
  1778  	// for fuzz targets. isFuzzing is false when running normal tests and
  1779  	// when running fuzz tests as unit tests (without -fuzz or when -fuzz
  1780  	// does not match).
  1781  	isFuzzing bool
  1782  
  1783  	mu sync.Mutex
  1784  
  1785  	// Channel used to signal tests that are ready to be run in parallel.
  1786  	startParallel chan bool
  1787  
  1788  	// running is the number of tests currently running in parallel.
  1789  	// This does not include tests that are waiting for subtests to complete.
  1790  	running int
  1791  
  1792  	// numWaiting is the number tests waiting to be run in parallel.
  1793  	numWaiting int
  1794  
  1795  	// maxParallel is a copy of the parallel flag.
  1796  	maxParallel int
  1797  }
  1798  
  1799  func newTestContext(maxParallel int, m *matcher) *testContext {
  1800  	return &testContext{
  1801  		match:         m,
  1802  		startParallel: make(chan bool),
  1803  		maxParallel:   maxParallel,
  1804  		running:       1, // Set the count to 1 for the main (sequential) test.
  1805  	}
  1806  }
  1807  
  1808  func (c *testContext) waitParallel() {
  1809  	c.mu.Lock()
  1810  	if c.running < c.maxParallel {
  1811  		c.running++
  1812  		c.mu.Unlock()
  1813  		return
  1814  	}
  1815  	c.numWaiting++
  1816  	c.mu.Unlock()
  1817  	<-c.startParallel
  1818  }
  1819  
  1820  func (c *testContext) release() {
  1821  	c.mu.Lock()
  1822  	if c.numWaiting == 0 {
  1823  		c.running--
  1824  		c.mu.Unlock()
  1825  		return
  1826  	}
  1827  	c.numWaiting--
  1828  	c.mu.Unlock()
  1829  	c.startParallel <- true // Pick a waiting test to be run.
  1830  }
  1831  
  1832  // No one should be using func Main anymore.
  1833  // See the doc comment on func Main and use MainStart instead.
  1834  var errMain = errors.New("testing: unexpected use of func Main")
  1835  
  1836  type matchStringOnly func(pat, str string) (bool, error)
  1837  
  1838  func (f matchStringOnly) MatchString(pat, str string) (bool, error)   { return f(pat, str) }
  1839  func (f matchStringOnly) StartCPUProfile(w io.Writer) error           { return errMain }
  1840  func (f matchStringOnly) StopCPUProfile()                             {}
  1841  func (f matchStringOnly) WriteProfileTo(string, io.Writer, int) error { return errMain }
  1842  func (f matchStringOnly) ImportPath() string                          { return "" }
  1843  func (f matchStringOnly) StartTestLog(io.Writer)                      {}
  1844  func (f matchStringOnly) StopTestLog() error                          { return errMain }
  1845  func (f matchStringOnly) SetPanicOnExit0(bool)                        {}
  1846  func (f matchStringOnly) CoordinateFuzzing(time.Duration, int64, time.Duration, int64, int, []corpusEntry, []reflect.Type, string, string) error {
  1847  	return errMain
  1848  }
  1849  func (f matchStringOnly) RunFuzzWorker(func(corpusEntry) error) error { return errMain }
  1850  func (f matchStringOnly) ReadCorpus(string, []reflect.Type) ([]corpusEntry, error) {
  1851  	return nil, errMain
  1852  }
  1853  func (f matchStringOnly) CheckCorpus([]any, []reflect.Type) error { return nil }
  1854  func (f matchStringOnly) ResetCoverage()                          {}
  1855  func (f matchStringOnly) SnapshotCoverage()                       {}
  1856  
  1857  // Main is an internal function, part of the implementation of the "go test" command.
  1858  // It was exported because it is cross-package and predates "internal" packages.
  1859  // It is no longer used by "go test" but preserved, as much as possible, for other
  1860  // systems that simulate "go test" using Main, but Main sometimes cannot be updated as
  1861  // new functionality is added to the testing package.
  1862  // Systems simulating "go test" should be updated to use MainStart.
  1863  func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample) {
  1864  	os.Exit(MainStart(matchStringOnly(matchString), tests, benchmarks, nil, examples).Run())
  1865  }
  1866  
  1867  // M is a type passed to a TestMain function to run the actual tests.
  1868  type M struct {
  1869  	deps        testDeps
  1870  	tests       []InternalTest
  1871  	benchmarks  []InternalBenchmark
  1872  	fuzzTargets []InternalFuzzTarget
  1873  	examples    []InternalExample
  1874  
  1875  	timer     *time.Timer
  1876  	afterOnce sync.Once
  1877  
  1878  	numRun int
  1879  
  1880  	// value to pass to os.Exit, the outer test func main
  1881  	// harness calls os.Exit with this code. See #34129.
  1882  	exitCode int
  1883  }
  1884  
  1885  // testDeps is an internal interface of functionality that is
  1886  // passed into this package by a test's generated main package.
  1887  // The canonical implementation of this interface is
  1888  // testing/internal/testdeps's TestDeps.
  1889  type testDeps interface {
  1890  	ImportPath() string
  1891  	MatchString(pat, str string) (bool, error)
  1892  	SetPanicOnExit0(bool)
  1893  	StartCPUProfile(io.Writer) error
  1894  	StopCPUProfile()
  1895  	StartTestLog(io.Writer)
  1896  	StopTestLog() error
  1897  	WriteProfileTo(string, io.Writer, int) error
  1898  	CoordinateFuzzing(time.Duration, int64, time.Duration, int64, int, []corpusEntry, []reflect.Type, string, string) error
  1899  	RunFuzzWorker(func(corpusEntry) error) error
  1900  	ReadCorpus(string, []reflect.Type) ([]corpusEntry, error)
  1901  	CheckCorpus([]any, []reflect.Type) error
  1902  	ResetCoverage()
  1903  	SnapshotCoverage()
  1904  }
  1905  
  1906  // MainStart is meant for use by tests generated by 'go test'.
  1907  // It is not meant to be called directly and is not subject to the Go 1 compatibility document.
  1908  // It may change signature from release to release.
  1909  func MainStart(deps testDeps, tests []InternalTest, benchmarks []InternalBenchmark, fuzzTargets []InternalFuzzTarget, examples []InternalExample) *M {
  1910  	Init()
  1911  	return &M{
  1912  		deps:        deps,
  1913  		tests:       tests,
  1914  		benchmarks:  benchmarks,
  1915  		fuzzTargets: fuzzTargets,
  1916  		examples:    examples,
  1917  	}
  1918  }
  1919  
  1920  var testingTesting bool
  1921  var realStderr *os.File
  1922  
  1923  // Run runs the tests. It returns an exit code to pass to os.Exit.
  1924  func (m *M) Run() (code int) {
  1925  	defer func() {
  1926  		code = m.exitCode
  1927  	}()
  1928  
  1929  	// Count the number of calls to m.Run.
  1930  	// We only ever expected 1, but we didn't enforce that,
  1931  	// and now there are tests in the wild that call m.Run multiple times.
  1932  	// Sigh. go.dev/issue/23129.
  1933  	m.numRun++
  1934  
  1935  	// TestMain may have already called flag.Parse.
  1936  	if !flag.Parsed() {
  1937  		flag.Parse()
  1938  	}
  1939  
  1940  	if chatty.json {
  1941  		// With -v=json, stdout and stderr are pointing to the same pipe,
  1942  		// which is leading into test2json. In general, operating systems
  1943  		// do a good job of ensuring that writes to the same pipe through
  1944  		// different file descriptors are delivered whole, so that writing
  1945  		// AAA to stdout and BBB to stderr simultaneously produces
  1946  		// AAABBB or BBBAAA on the pipe, not something like AABBBA.
  1947  		// However, the exception to this is when the pipe fills: in that
  1948  		// case, Go's use of non-blocking I/O means that writing AAA
  1949  		// or BBB might be split across multiple system calls, making it
  1950  		// entirely possible to get output like AABBBA. The same problem
  1951  		// happens inside the operating system kernel if we switch to
  1952  		// blocking I/O on the pipe. This interleaved output can do things
  1953  		// like print unrelated messages in the middle of a TestFoo line,
  1954  		// which confuses test2json. Setting os.Stderr = os.Stdout will make
  1955  		// them share a single pfd, which will hold a lock for each program
  1956  		// write, preventing any interleaving.
  1957  		//
  1958  		// It might be nice to set Stderr = Stdout always, or perhaps if
  1959  		// we can tell they are the same file, but for now -v=json is
  1960  		// a very clear signal. Making the two files the same may cause
  1961  		// surprises if programs close os.Stdout but expect to be able
  1962  		// to continue to write to os.Stderr, but it's hard to see why a
  1963  		// test would think it could take over global state that way.
  1964  		//
  1965  		// This fix only helps programs where the output is coming directly
  1966  		// from Go code. It does not help programs in which a subprocess is
  1967  		// writing to stderr or stdout at the same time that a Go test is writing output.
  1968  		// It also does not help when the output is coming from the runtime,
  1969  		// such as when using the print/println functions, since that code writes
  1970  		// directly to fd 2 without any locking.
  1971  		// We keep realStderr around to prevent fd 2 from being closed.
  1972  		//
  1973  		// See go.dev/issue/33419.
  1974  		realStderr = os.Stderr
  1975  		os.Stderr = os.Stdout
  1976  	}
  1977  
  1978  	if *parallel < 1 {
  1979  		fmt.Fprintln(os.Stderr, "testing: -parallel can only be given a positive integer")
  1980  		flag.Usage()
  1981  		m.exitCode = 2
  1982  		return
  1983  	}
  1984  	if *matchFuzz != "" && *fuzzCacheDir == "" {
  1985  		fmt.Fprintln(os.Stderr, "testing: -test.fuzzcachedir must be set if -test.fuzz is set")
  1986  		flag.Usage()
  1987  		m.exitCode = 2
  1988  		return
  1989  	}
  1990  
  1991  	if *matchList != "" {
  1992  		listTests(m.deps.MatchString, m.tests, m.benchmarks, m.fuzzTargets, m.examples)
  1993  		m.exitCode = 0
  1994  		return
  1995  	}
  1996  
  1997  	if *shuffle != "off" {
  1998  		var n int64
  1999  		var err error
  2000  		if *shuffle == "on" {
  2001  			n = time.Now().UnixNano()
  2002  		} else {
  2003  			n, err = strconv.ParseInt(*shuffle, 10, 64)
  2004  			if err != nil {
  2005  				fmt.Fprintln(os.Stderr, `testing: -shuffle should be "off", "on", or a valid integer:`, err)
  2006  				m.exitCode = 2
  2007  				return
  2008  			}
  2009  		}
  2010  		fmt.Println("-test.shuffle", n)
  2011  		rng := rand.New(rand.NewSource(n))
  2012  		rng.Shuffle(len(m.tests), func(i, j int) { m.tests[i], m.tests[j] = m.tests[j], m.tests[i] })
  2013  		rng.Shuffle(len(m.benchmarks), func(i, j int) { m.benchmarks[i], m.benchmarks[j] = m.benchmarks[j], m.benchmarks[i] })
  2014  	}
  2015  
  2016  	parseCpuList()
  2017  
  2018  	m.before()
  2019  	defer m.after()
  2020  
  2021  	// Run tests, examples, and benchmarks unless this is a fuzz worker process.
  2022  	// Workers start after this is done by their parent process, and they should
  2023  	// not repeat this work.
  2024  	if !*isFuzzWorker {
  2025  		deadline := m.startAlarm()
  2026  		haveExamples = len(m.examples) > 0
  2027  		testRan, testOk := runTests(m.deps.MatchString, m.tests, deadline)
  2028  		fuzzTargetsRan, fuzzTargetsOk := runFuzzTests(m.deps, m.fuzzTargets, deadline)
  2029  		exampleRan, exampleOk := runExamples(m.deps.MatchString, m.examples)
  2030  		m.stopAlarm()
  2031  		if !testRan && !exampleRan && !fuzzTargetsRan && *matchBenchmarks == "" && *matchFuzz == "" {
  2032  			fmt.Fprintln(os.Stderr, "testing: warning: no tests to run")
  2033  			if testingTesting && *match != "^$" {
  2034  				// If this happens during testing of package testing it could be that
  2035  				// package testing's own logic for when to run a test is broken,
  2036  				// in which case every test will run nothing and succeed,
  2037  				// with no obvious way to detect this problem (since no tests are running).
  2038  				// So make 'no tests to run' a hard failure when testing package testing itself.
  2039  				fmt.Print(chatty.prefix(), "FAIL: package testing must run tests\n")
  2040  				testOk = false
  2041  			}
  2042  		}
  2043  		anyFailed := !testOk || !exampleOk || !fuzzTargetsOk || !runBenchmarks(m.deps.ImportPath(), m.deps.MatchString, m.benchmarks)
  2044  		if !anyFailed && race.Errors() > 0 {
  2045  			fmt.Print(chatty.prefix(), "testing: race detected outside of test execution\n")
  2046  			anyFailed = true
  2047  		}
  2048  		if anyFailed {
  2049  			fmt.Print(chatty.prefix(), "FAIL\n")
  2050  			m.exitCode = 1
  2051  			return
  2052  		}
  2053  	}
  2054  
  2055  	fuzzingOk := runFuzzing(m.deps, m.fuzzTargets)
  2056  	if !fuzzingOk {
  2057  		fmt.Print(chatty.prefix(), "FAIL\n")
  2058  		if *isFuzzWorker {
  2059  			m.exitCode = fuzzWorkerExitCode
  2060  		} else {
  2061  			m.exitCode = 1
  2062  		}
  2063  		return
  2064  	}
  2065  
  2066  	m.exitCode = 0
  2067  	if !*isFuzzWorker {
  2068  		fmt.Print(chatty.prefix(), "PASS\n")
  2069  	}
  2070  	return
  2071  }
  2072  
  2073  func (t *T) report() {
  2074  	if t.parent == nil {
  2075  		return
  2076  	}
  2077  	dstr := fmtDuration(t.duration)
  2078  	format := "--- %s: %s (%s)\n"
  2079  	if t.Failed() {
  2080  		t.flushToParent(t.name, format, "FAIL", t.name, dstr)
  2081  	} else if t.chatty != nil {
  2082  		if t.Skipped() {
  2083  			t.flushToParent(t.name, format, "SKIP", t.name, dstr)
  2084  		} else {
  2085  			t.flushToParent(t.name, format, "PASS", t.name, dstr)
  2086  		}
  2087  	}
  2088  }
  2089  
  2090  func listTests(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, fuzzTargets []InternalFuzzTarget, examples []InternalExample) {
  2091  	if _, err := matchString(*matchList, "non-empty"); err != nil {
  2092  		fmt.Fprintf(os.Stderr, "testing: invalid regexp in -test.list (%q): %s\n", *matchList, err)
  2093  		os.Exit(1)
  2094  	}
  2095  
  2096  	for _, test := range tests {
  2097  		if ok, _ := matchString(*matchList, test.Name); ok {
  2098  			fmt.Println(test.Name)
  2099  		}
  2100  	}
  2101  	for _, bench := range benchmarks {
  2102  		if ok, _ := matchString(*matchList, bench.Name); ok {
  2103  			fmt.Println(bench.Name)
  2104  		}
  2105  	}
  2106  	for _, fuzzTarget := range fuzzTargets {
  2107  		if ok, _ := matchString(*matchList, fuzzTarget.Name); ok {
  2108  			fmt.Println(fuzzTarget.Name)
  2109  		}
  2110  	}
  2111  	for _, example := range examples {
  2112  		if ok, _ := matchString(*matchList, example.Name); ok {
  2113  			fmt.Println(example.Name)
  2114  		}
  2115  	}
  2116  }
  2117  
  2118  // RunTests is an internal function but exported because it is cross-package;
  2119  // it is part of the implementation of the "go test" command.
  2120  func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool) {
  2121  	var deadline time.Time
  2122  	if *timeout > 0 {
  2123  		deadline = time.Now().Add(*timeout)
  2124  	}
  2125  	ran, ok := runTests(matchString, tests, deadline)
  2126  	if !ran && !haveExamples {
  2127  		fmt.Fprintln(os.Stderr, "testing: warning: no tests to run")
  2128  	}
  2129  	return ok
  2130  }
  2131  
  2132  func runTests(matchString func(pat, str string) (bool, error), tests []InternalTest, deadline time.Time) (ran, ok bool) {
  2133  	ok = true
  2134  	for _, procs := range cpuList {
  2135  		runtime.GOMAXPROCS(procs)
  2136  		for i := uint(0); i < *count; i++ {
  2137  			if shouldFailFast() {
  2138  				break
  2139  			}
  2140  			if i > 0 && !ran {
  2141  				// There were no tests to run on the first
  2142  				// iteration. This won't change, so no reason
  2143  				// to keep trying.
  2144  				break
  2145  			}
  2146  			ctx := newTestContext(*parallel, newMatcher(matchString, *match, "-test.run", *skip))
  2147  			ctx.deadline = deadline
  2148  			t := &T{
  2149  				common: common{
  2150  					signal:  make(chan bool, 1),
  2151  					barrier: make(chan bool),
  2152  					w:       os.Stdout,
  2153  				},
  2154  				context: ctx,
  2155  			}
  2156  			if Verbose() {
  2157  				t.chatty = newChattyPrinter(t.w)
  2158  			}
  2159  			tRunner(t, func(t *T) {
  2160  				for _, test := range tests {
  2161  					t.Run(test.Name, test.F)
  2162  				}
  2163  			})
  2164  			select {
  2165  			case <-t.signal:
  2166  			default:
  2167  				panic("internal error: tRunner exited without sending on t.signal")
  2168  			}
  2169  			ok = ok && !t.Failed()
  2170  			ran = ran || t.ran
  2171  		}
  2172  	}
  2173  	return ran, ok
  2174  }
  2175  
  2176  // before runs before all testing.
  2177  func (m *M) before() {
  2178  	if *memProfileRate > 0 {
  2179  		runtime.MemProfileRate = *memProfileRate
  2180  	}
  2181  	if *cpuProfile != "" {
  2182  		f, err := os.Create(toOutputDir(*cpuProfile))
  2183  		if err != nil {
  2184  			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
  2185  			return
  2186  		}
  2187  		if err := m.deps.StartCPUProfile(f); err != nil {
  2188  			fmt.Fprintf(os.Stderr, "testing: can't start cpu profile: %s\n", err)
  2189  			f.Close()
  2190  			return
  2191  		}
  2192  		// Could save f so after can call f.Close; not worth the effort.
  2193  	}
  2194  	if *traceFile != "" {
  2195  		f, err := os.Create(toOutputDir(*traceFile))
  2196  		if err != nil {
  2197  			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
  2198  			return
  2199  		}
  2200  		if err := trace.Start(f); err != nil {
  2201  			fmt.Fprintf(os.Stderr, "testing: can't start tracing: %s\n", err)
  2202  			f.Close()
  2203  			return
  2204  		}
  2205  		// Could save f so after can call f.Close; not worth the effort.
  2206  	}
  2207  	if *blockProfile != "" && *blockProfileRate >= 0 {
  2208  		runtime.SetBlockProfileRate(*blockProfileRate)
  2209  	}
  2210  	if *mutexProfile != "" && *mutexProfileFraction >= 0 {
  2211  		runtime.SetMutexProfileFraction(*mutexProfileFraction)
  2212  	}
  2213  	if *coverProfile != "" && CoverMode() == "" {
  2214  		fmt.Fprintf(os.Stderr, "testing: cannot use -test.coverprofile because test binary was not built with coverage enabled\n")
  2215  		os.Exit(2)
  2216  	}
  2217  	if *gocoverdir != "" && CoverMode() == "" {
  2218  		fmt.Fprintf(os.Stderr, "testing: cannot use -test.gocoverdir because test binary was not built with coverage enabled\n")
  2219  		os.Exit(2)
  2220  	}
  2221  	if *testlog != "" {
  2222  		// Note: Not using toOutputDir.
  2223  		// This file is for use by cmd/go, not users.
  2224  		var f *os.File
  2225  		var err error
  2226  		if m.numRun == 1 {
  2227  			f, err = os.Create(*testlog)
  2228  		} else {
  2229  			f, err = os.OpenFile(*testlog, os.O_WRONLY, 0)
  2230  			if err == nil {
  2231  				f.Seek(0, io.SeekEnd)
  2232  			}
  2233  		}
  2234  		if err != nil {
  2235  			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
  2236  			os.Exit(2)
  2237  		}
  2238  		m.deps.StartTestLog(f)
  2239  		testlogFile = f
  2240  	}
  2241  	if *panicOnExit0 {
  2242  		m.deps.SetPanicOnExit0(true)
  2243  	}
  2244  }
  2245  
  2246  // after runs after all testing.
  2247  func (m *M) after() {
  2248  	m.afterOnce.Do(func() {
  2249  		m.writeProfiles()
  2250  	})
  2251  
  2252  	// Restore PanicOnExit0 after every run, because we set it to true before
  2253  	// every run. Otherwise, if m.Run is called multiple times the behavior of
  2254  	// os.Exit(0) will not be restored after the second run.
  2255  	if *panicOnExit0 {
  2256  		m.deps.SetPanicOnExit0(false)
  2257  	}
  2258  }
  2259  
  2260  func (m *M) writeProfiles() {
  2261  	if *testlog != "" {
  2262  		if err := m.deps.StopTestLog(); err != nil {
  2263  			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *testlog, err)
  2264  			os.Exit(2)
  2265  		}
  2266  		if err := testlogFile.Close(); err != nil {
  2267  			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *testlog, err)
  2268  			os.Exit(2)
  2269  		}
  2270  	}
  2271  	if *cpuProfile != "" {
  2272  		m.deps.StopCPUProfile() // flushes profile to disk
  2273  	}
  2274  	if *traceFile != "" {
  2275  		trace.Stop() // flushes trace to disk
  2276  	}
  2277  	if *memProfile != "" {
  2278  		f, err := os.Create(toOutputDir(*memProfile))
  2279  		if err != nil {
  2280  			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
  2281  			os.Exit(2)
  2282  		}
  2283  		runtime.GC() // materialize all statistics
  2284  		if err = m.deps.WriteProfileTo("allocs", f, 0); err != nil {
  2285  			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *memProfile, err)
  2286  			os.Exit(2)
  2287  		}
  2288  		f.Close()
  2289  	}
  2290  	if *blockProfile != "" && *blockProfileRate >= 0 {
  2291  		f, err := os.Create(toOutputDir(*blockProfile))
  2292  		if err != nil {
  2293  			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
  2294  			os.Exit(2)
  2295  		}
  2296  		if err = m.deps.WriteProfileTo("block", f, 0); err != nil {
  2297  			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *blockProfile, err)
  2298  			os.Exit(2)
  2299  		}
  2300  		f.Close()
  2301  	}
  2302  	if *mutexProfile != "" && *mutexProfileFraction >= 0 {
  2303  		f, err := os.Create(toOutputDir(*mutexProfile))
  2304  		if err != nil {
  2305  			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
  2306  			os.Exit(2)
  2307  		}
  2308  		if err = m.deps.WriteProfileTo("mutex", f, 0); err != nil {
  2309  			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *mutexProfile, err)
  2310  			os.Exit(2)
  2311  		}
  2312  		f.Close()
  2313  	}
  2314  	if CoverMode() != "" {
  2315  		coverReport()
  2316  	}
  2317  }
  2318  
  2319  // toOutputDir returns the file name relocated, if required, to outputDir.
  2320  // Simple implementation to avoid pulling in path/filepath.
  2321  func toOutputDir(path string) string {
  2322  	if *outputDir == "" || path == "" {
  2323  		return path
  2324  	}
  2325  	// On Windows, it's clumsy, but we can be almost always correct
  2326  	// by just looking for a drive letter and a colon.
  2327  	// Absolute paths always have a drive letter (ignoring UNC).
  2328  	// Problem: if path == "C:A" and outputdir == "C:\Go" it's unclear
  2329  	// what to do, but even then path/filepath doesn't help.
  2330  	// TODO: Worth doing better? Probably not, because we're here only
  2331  	// under the management of go test.
  2332  	if runtime.GOOS == "windows" && len(path) >= 2 {
  2333  		letter, colon := path[0], path[1]
  2334  		if ('a' <= letter && letter <= 'z' || 'A' <= letter && letter <= 'Z') && colon == ':' {
  2335  			// If path starts with a drive letter we're stuck with it regardless.
  2336  			return path
  2337  		}
  2338  	}
  2339  	if os.IsPathSeparator(path[0]) {
  2340  		return path
  2341  	}
  2342  	return fmt.Sprintf("%s%c%s", *outputDir, os.PathSeparator, path)
  2343  }
  2344  
  2345  // startAlarm starts an alarm if requested.
  2346  func (m *M) startAlarm() time.Time {
  2347  	if *timeout <= 0 {
  2348  		return time.Time{}
  2349  	}
  2350  
  2351  	deadline := time.Now().Add(*timeout)
  2352  	m.timer = time.AfterFunc(*timeout, func() {
  2353  		m.after()
  2354  		debug.SetTraceback("all")
  2355  		extra := ""
  2356  
  2357  		if list := runningList(); len(list) > 0 {
  2358  			var b strings.Builder
  2359  			b.WriteString("\nrunning tests:")
  2360  			for _, name := range list {
  2361  				b.WriteString("\n\t")
  2362  				b.WriteString(name)
  2363  			}
  2364  			extra = b.String()
  2365  		}
  2366  		panic(fmt.Sprintf("test timed out after %v%s", *timeout, extra))
  2367  	})
  2368  	return deadline
  2369  }
  2370  
  2371  // runningList returns the list of running tests.
  2372  func runningList() []string {
  2373  	var list []string
  2374  	running.Range(func(k, v any) bool {
  2375  		list = append(list, fmt.Sprintf("%s (%v)", k.(string), time.Since(v.(time.Time)).Round(time.Second)))
  2376  		return true
  2377  	})
  2378  	sort.Strings(list)
  2379  	return list
  2380  }
  2381  
  2382  // stopAlarm turns off the alarm.
  2383  func (m *M) stopAlarm() {
  2384  	if *timeout > 0 {
  2385  		m.timer.Stop()
  2386  	}
  2387  }
  2388  
  2389  func parseCpuList() {
  2390  	for _, val := range strings.Split(*cpuListStr, ",") {
  2391  		val = strings.TrimSpace(val)
  2392  		if val == "" {
  2393  			continue
  2394  		}
  2395  		cpu, err := strconv.Atoi(val)
  2396  		if err != nil || cpu <= 0 {
  2397  			fmt.Fprintf(os.Stderr, "testing: invalid value %q for -test.cpu\n", val)
  2398  			os.Exit(1)
  2399  		}
  2400  		cpuList = append(cpuList, cpu)
  2401  	}
  2402  	if cpuList == nil {
  2403  		cpuList = append(cpuList, runtime.GOMAXPROCS(-1))
  2404  	}
  2405  }
  2406  
  2407  func shouldFailFast() bool {
  2408  	return *failFast && numFailed.Load() > 0
  2409  }
  2410  

View as plain text