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

# if the cache directory doesn't exist at all.
# It should not write a testexpire.txt file, since there are no
# test results that need to be invalidated in the first place.
env GOCACHE=$WORK/nonexistent
go clean -testcache
! exists $WORK/nonexistent

-- x/x_test.go --
package x_test
import (
    "testing"
)
func TestMain(t *testing.T) {

 * 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

class StaticVersionsDynamicListingReadOnlyCacheDependencyResolutionTest extends StaticVersionsReadOnlyCacheDependencyResolutionTest {

    @Override
    boolean isResolveDynamic() {
        true
    }

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

# FuzzA attempts to cause the mutator to create duplicate inputs that generate
# new coverage. Previously this would trigger a corner case when the fuzzer
# had an execution limit, causing it to deadlock and sit in the coordinator
# loop indefinitely, failing to exit once the limit had been exhausted.

go test -fuzz=FuzzA -fuzztime=100x -parallel=1

-- go.mod --
module m

go 1.16

[short] skip
[GODEBUG:gocacheverify=1] skip
[compiler:gccgo] skip  # gccgo has no standard packages

# Start with a clean build cache:
# test failures may be masked if the cache has just the right entries already.
env GOCACHE=$WORK/cache

# Run 'go vet os/user' once to warm up the cache.
go vet os/user

# Check that second vet reuses cgo-derived inputs.
# The first command could be build instead of vet,

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

go build ./cmd/mytool

# Use an ephemeral build cache so that our toolexec output is not cached
# for any stale standard-library dependencies.
#
# TODO(#27628): This should not be necessary.
env GOCACHE=$WORK/gocache

# Build the main package with our toolexec program. For each action, it will
# print the tool's name and the TOOLEXEC_IMPORTPATH value. We expect to compile
# each package once, and link the main package once.

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.
# It has no install target, and thus is never stale.

env GOCACHE=$WORK/cache  # Use a fresh cache to avoid interference between runs.

go build -x .
stderr '[/\\]cgo'$GOEXE'["]? .* -importpath runtime/cgo'
! stale runtime/cgo