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

# This test checks that cached corpus loading properly handles duplicate entries (this can
# happen when a f.Add value has a duplicate entry in the cached corpus.) Duplicate entries
# should be discarded, and the rest of the cache should be loaded as normal.

env GOCACHE=$WORK/cache
env GODEBUG=fuzzdebug=1

mkdir -p $GOCACHE/fuzz/fuzztest/FuzzTarget
go run ./populate $GOCACHE/fuzz/fuzztest/FuzzTarget

	defaultDirErr     error
)

// DefaultDir returns the effective GOCACHE setting.
// It returns "off" if the cache is disabled,
// and reports whether the effective value differs from GOCACHE.
func DefaultDir() (string, bool) {
	// Save the result of the first call to DefaultDir for later use in
	// initDefaultCache. cmd/go/main.go explicitly sets GOCACHE so that

env GO111MODULE=on

[short] skip
[!cgo] skip

# Regression test for golang.org/issue/29667:
# spurious 'failed to cache compiled Go files' errors.

env GOCACHE=$WORK/gocache
mkdir $GOCACHE

go list -json -compiled -test=false -export=false -deps=true -- . &
go list -json -compiled -test=false -export=false -deps=true -- . &
wait

-- go.mod --
module sandbox/bar
-- bar.go --
package bar

            return cache.useCache(() -> indexedCache.getIfPresent(key));
        }

        @Override
        public V get(final K key, final Function<? super K, ? extends V> producer) {
            return cache.useCache(() -> indexedCache.get(key, producer));
        }

        @Override
        public void put(final K key, final V value) {
            cache.useCache(() -> indexedCache.put(key, value));

import org.gradle.api.internal.cache.CacheConfigurationsInternal;
import org.gradle.api.internal.filestore.DefaultArtifactIdentifierFileStore;
import org.gradle.cache.CacheCleanupStrategy;
import org.gradle.cache.CleanupAction;
import org.gradle.cache.DefaultCacheCleanupStrategy;
import org.gradle.cache.FileLockManager;
import org.gradle.cache.IndexedCache;
import org.gradle.cache.IndexedCacheParameters;

// license that can be found in the LICENSE file.

package p

type policy[K, V any] interface{}
type LRU[K, V any] struct{}

func NewCache[K, V any](p policy[K, V]) {}

func _() {
	var lru LRU[int, string]
	NewCache[int, string](&lru)
	NewCache /* ERROR "cannot infer K" */ (&lru)

#  _cgo_gotypes.go
#  a.cgo1.go
#
# These names we see here, other than a.go, will be from the build cache,
# so we just count them.

go list -f '{{.CompiledGoFiles}}' -compiled=true example/swig

stdout a\.go
[compiler:gc] stdout -count=3 $GOCACHE
[compiler:gccgo] stdout -count=2 $GOCACHE

-- go.mod --
module example

go 1.16

-- swig/a.go --
package swig

env GO111MODULE=off

# Regression test for golang.org/issue/21309: accept relative -pkgdir argument.

[short] skip

mkdir $WORK/gocache
env GOCACHE=$WORK/gocache

# Set GOCACHE to a clean directory to ensure that 'go build' has work to report.
[!GOOS:windows] env GOCACHE=$WORK/gocache
[GOOS:windows] env GOCACHE=$WORK\gocache

# 'go build' should use GOTMPDIR if set.
[!GOOS:windows] env GOTMPDIR=$WORK/my-favorite-tmpdir
[GOOS:windows] env GOTMPDIR=$WORK\my-favorite-tmpdir
mkdir $GOTMPDIR
go build -x hello.go
stderr ^WORK=.*my-favorite-tmpdir

[short] skip
env GO111MODULE=on

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

cd $WORK
go build -o a.out

# Varying -trimpath should cause a rebuild.
go build -x -o a.out -trimpath
stderr '(compile|gccgo)( |\.exe)'
stderr 'link( |\.exe)'

# Two distinct versions of the same module with identical content should
# still be cached separately.
# Verifies golang.org/issue/35412.
go get example.com/stack@v1.0.0