! stderr 'compile|cp|gccgo .*language\.a$'

# go get should skip build with no Go files in root
go get golang.org/x/text@14c0d48

# dropping -d, we should see a build.
[short] skip

env GOCACHE=$WORK/gocache  # Looking for compile commands, so need a clean cache.

go build -x golang.org/x/text/language
stderr 'compile|cp|gccgo .*language\.a$'

go list -f '{{.Stale}}' golang.org/x/text/language
stdout ^false

		c1 := make(chan bool, 1)
		t.Run("sub", func(t *testing.T) {
			t.Run("subsub1", func(t *testing.T) {
				t.Parallel()
				doRace()
				c1 <- true
			})
			t.Run("subsub2", func(t *testing.T) {
				t.Parallel()
				doRace()
				<-c1
			})
		})
		doRace()
		return
	}

	out := runTest(t, "TestRaceSubReports")

[short] skip

env GOCACHE=$WORK/tmp
go test -v multimain
stdout -count=2 notwithstanding # check tests ran twice

-- go.mod --
module multimain

go 1.16
-- multimain_test.go --
package multimain_test

import "testing"

func TestMain(m *testing.M) {
	// Some users run m.Run multiple times, changing
	// some kind of global state between runs.
	// This used to work so I guess now it has to keep working.

# if we change the way caching works, we want the test to fail
# instead of accidentally reusing the cached information from a
# previous test run.
env GOCACHE=$WORK${/}.cache
mkdir $GOCACHE

go build -x runtime/cgo

	# Tell our fake clang to stop working.
	# Previously, 'go build -x runtime/cgo' would continue to
	# succeed because both the broken clang and the non-broken one

	Pull             *bool             `json:"pull,omitempty" hcl:"pull,optional"`
	NoCache          *bool             `json:"no-cache,omitempty" hcl:"no-cache,optional"`
}

type Args struct {
	Push              bool
	Save              bool
	Builder           string
	SupportsEmulation bool
	NoClobber         bool
	NoCache           bool
	Targets           []string
	Variants          []string
	Architectures     []string

# concurrently accessing the cache while this test is running, it can
# lead to cache lookup failures, which manifest as test failures here.
# To avoid such flakes, use a separate isolated GOCACHE for this test.
env GOCACHE=$WORK/cache

# Initial run with simple coverage.
go test -cover ./pkg1 ./pkg2 ./pkg3 ./pkg4
[!GOEXPERIMENT:coverageredesign] stdout 'pkg1	\[no test files\]'

[short] skip

env GOCACHE=$WORK/cache
go list -f '{{.Stale}}' .
stdout true
go install .
go list -f '{{.Stale}}' .
stdout false

-- go.mod --
module example.com/mod

go 1.20
-- m.go --

        });
        String roCache = System.getenv(READONLY_CACHE_ENV_VAR);
        if (StringUtils.isNotEmpty(roCache)) {
            IncubationLogger.incubatingFeatureUsed("Shared read-only dependency cache");
            File baseDir = validateReadOnlyCache(documentationRegistry, new File(roCache).getAbsoluteFile());
            if (baseDir != null) {

# "preferlinkext" token to the linker to request external linking.

#-----------------------

# Use a fresh GOCACHE for these next steps, so as to have the real
# actions for the runtime/cgo package appear in the "-n -x" output.
env GOCACHE=$WORK/gocache
mkdir $GOCACHE

# First build: there is no CGO in use, so no token should be present regardless
# of weird CGO flags.
go build -x -n -o dummy.exe ./noUseOfCgo

[!fuzz] skip
[short] skip
env GOCACHE=$WORK/cache

go test -fuzz=FuzzA -fuzztime=100x fuzz_setenv_test.go

-- fuzz_setenv_test.go --
package fuzz

import (
  "flag"
  "os"
  "testing"
)

func FuzzA(f *testing.F) {
  if s := os.Getenv("TEST_FUZZ_SETENV_A"); isWorker() && s == "" {
    f.Fatal("environment variable not set")
  } else if !isWorker() && s != "" {
    f.Fatal("environment variable already set")
  }