[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

# 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")
  }

        println(format("    GRADLE_OPTS: %s", environment.get("GRADLE_OPTS")));
        String roCache = environment.get(ArtifactCachesProvider.READONLY_CACHE_ENV_VAR);
        if (roCache != null) {
            println(format("    %s: %s", ArtifactCachesProvider.READONLY_CACHE_ENV_VAR, roCache));
        }
    }

    private static void println(String s) {
        System.out.println(s);
    }

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

# Test that fuzzing works with cgo (issue 65169)

go test -fuzz=. -fuzztime=1x
stdout ok
! stdout FAIL

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

go 1.20
-- c.go --
package p

import "C"
-- c_test.go --
package p

import "testing"

func Fuzz(f *testing.F) {
	f.Add(0)
	f.Fuzz(func(t *testing.T, x int) {})

env OLDGOROOT=$GOROOT
env GOROOT=$WORK${/}gopath${/}src${/}new
go env GOROOT
stdout $WORK[\\/]gopath[\\/]src[\\/]new
cd new
! stale net

# Add a control case to check that std is
# stale with an empty cache
env GOCACHE=$WORK${/}gopath${/}cache