:: CGO_ENABLED: Controls cgo usage...

# Explicitly rebuild it to ensure that it is cached.
# (See https://go.dev/issue/50892.)
#
# If running in non-short mode, explicitly vary CGO_CFLAGS
# as a control case (to ensure that our regexps do catch rebuilds).

[!short] env GOCACHE=$WORK/cache
[!short] env CGO_CFLAGS=-DTestScript_cgo_stale_precompiled=true
go build -x runtime/cgo
[!short] stderr '[/\\]cgo'$GOEXE'["]? .* -importpath runtime/cgo'

# golang.org/issue/46347: a stale runtime/cgo should only force a single rebuild

[!cgo] skip
[short] skip


# If we set a unique CGO_CFLAGS, the installed copy of runtime/cgo
# should be reported as stale.

env CGO_CFLAGS=-DTestScript_cgo_stale=true
stale runtime/cgo


# If we then build a package that uses cgo, runtime/cgo should be rebuilt and
# cached with the new flag, but not installed to GOROOT.

[short] skip

go install -gcflags=-m .
stderr 'can inline main'
go list -gcflags=-m -f '{{.Stale}}' .
stdout 'false'
! stderr 'can inline main'

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

go 1.20
-- main.go --
package main

				}
				if err != nil {
					return err
				}
				cmd := testenv.Command(t, gotool, "build", "-buildmode=archive", "-o", cgoarchive, "-gcflags=all="+os.Getenv("GO_GCFLAGS"), "mycgo")
				cmd.Dir = filepath.Join(gopath, "src", "mycgo")
				cmd.Env = append(os.Environ(), "GOPATH="+gopath)
				out, err = cmd.CombinedOutput()
				if err != nil {

testargs=()
eval "testargs=(${KUBE_TEST_ARGS:-})"

# Used to filter verbose test output.
go_test_grep_pattern=".*"

goflags=()
# The junit report tool needs full test case information to produce a
# meaningful report.
if [[ -n "${KUBE_JUNIT_REPORT_DIR}" ]] ; then
  goflags+=(-v)
  goflags+=(-json)
  # Show only summary lines by matching lines like "status package/test"

[short] skip # rebuilds all of std

# Set up fresh GOCACHE.
env GOCACHE=$WORK/gocache
mkdir $GOCACHE

# Verify the standard library (specifically internal/runtime/atomic) can be
# built with -gcflags when -n is given. See golang.org/issue/29346.
go build -n -gcflags=all='-l' std

# Recursive go commands started with 'go generate' should not get an explicitly
# passed -modfile, but they should see arguments from GOFLAGS.
cp go.alt.mod go.gen.mod
env OLD_GOFLAGS=$GOFLAGS
env GOFLAGS=-modfile=go.gen.mod
go generate -modfile=go.alt.mod .
env GOFLAGS=$OLD_GOFLAGS
grep example.com/exclude go.gen.mod
! grep example.com/exclude go.alt.mod


# The original files should not have been modified.

# Test that the user can override default code generation flags.

[compiler:gccgo] skip  # gccgo does not use -gcflags
[!cgo] skip
[!GOOS:linux] skip  # test only works if c-archive implies -shared
[short] skip

env GOCACHE=$WORK/gocache  # Looking for compile commands, so need a clean cache.
go build -x -n -buildmode=c-archive -gcflags=all=-shared=false ./override.go
stderr '^.*/compile (.* )?-shared (.* )?-shared=false'

-- override.go --

		}
		args = append(args, strings.Fields(string(out))...)
	}
	args = append(args, "-I", tmpdir)
	args = append(args, strings.Fields(os.Getenv("CGO_CFLAGS"))...)
	args = append(args, bp.CgoCFLAGS...)
	args = append(args, bp.CgoFiles...)

	cmd := exec.Command(args[0], args[1:]...)
	cmd.Dir = bp.Dir
	if err := cmd.Run(); err != nil {
		return nil, fmt.Errorf("go tool cgo: %w", err)