});
        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) {

        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) {})

# (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'

	CGO_FFLAGS
	CGO_FFLAGS_ALLOW
	CGO_FFLAGS_DISALLOW
	CGO_LDFLAGS
	CGO_LDFLAGS_ALLOW
	CGO_LDFLAGS_DISALLOW
	CXX
	FC
	GCCGO
	GO111MODULE
	GO386
	GOAMD64
	GOARCH
	GOARM
	GOARM64
	GOBIN
	GOCACHE
	GOCACHEPROG
	GOENV
	GOEXE
	GOEXPERIMENT
	GOFLAGS
	GOGCCFLAGS
	GOHOSTARCH
	GOHOSTOS
	GOINSECURE
	GOMIPS
	GOMIPS64
	GOMODCACHE
	GONOPROXY
	GONOSUMDB
	GOOS
	GOPATH
	GOPPC64

Each script runs in a fresh temporary work directory tree, available to scripts as $WORK.
Scripts also have access to other environment variables, including:

	GOARCH=<target GOARCH>
	GOCACHE=<actual GOCACHE being used outside the test>
	GOEXE=<executable file suffix: .exe on Windows, empty on other systems>
	GOOS=<target GOOS>
	GOPATH=$WORK/gopath
	GOPROXY=<local module proxy serving from cmd/go/testdata/mod>

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

# Warm up the build cache with GOMAXPROCS unrestricted.
go test -c -o $devnull

# For the fuzzing phase, we reduce GOMAXPROCS to avoid consuming too many
# resources during the test. Ideally this would just free up resources to run
# other parallel tests more quickly, but unfortunately it is actually necessary
# in some 32-bit environments to prevent the fuzzing engine from running out of

# Go tools really don't like it if you have a symlink in `pwd`.
cd "$(pwd -P)"

KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/..
source "${KUBE_ROOT}/hack/lib/init.sh"

# This sets up the environment, like GOCACHE, which keeps the worktree cleaner.
kube::golang::setup_env

cd "${KUBE_ROOT}"

# Ensure all modules are included in go.work
go work edit -use .
git ls-files -z ':(glob)./staging/src/k8s.io/*/go.mod' \

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.integtests.resolve.rocache

import org.gradle.api.internal.artifacts.ivyservice.CacheLayout
import org.gradle.test.fixtures.server.http.MavenHttpModule
import org.gradle.test.fixtures.server.http.MavenHttpRepository
import spock.lang.Issue

source "${KUBE_ROOT}/hack/lib/init.sh"
source "${KUBE_ROOT}/hack/lib/util.sh"

# make sure everything is committed
kube::util::ensure_clean_working_dir

# This sets up the environment, like GOCACHE, which keeps the worktree cleaner.
kube::golang::setup_env

go install golang.org/x/vuln/cmd/govulncheck@v1.0.1

# KUBE_VERIFY_GIT_BRANCH is populated in verify CI jobs
BRANCH="${KUBE_VERIFY_GIT_BRANCH:-master}"