[short] skip
[!cgo] skip

env GOCACHE=$WORK/gocache  # Looking for compile flags, so need a clean cache.
go build -x -n main.go
stderr '"-I[^"]+c flags"' # find quoted c flags
! stderr '"-I[^"]+c flags".*"-I[^"]+c flags"' # don't find too many quoted c flags per line
stderr '"-L[^"]+ld flags"' # find quoted ld flags
! stderr '"-L[^"]+c flags".*"-L[^"]+c flags"' # don't find too many quoted ld flags per line

-- main.go --
package main

        expect:
        cache.get(String, function) == a
        cache.get(Long, function) == b
        cache.getIfPresent(String) == a
        cache.getIfPresent(Long) == b

        cache.put(String, c)
        cache.getIfPresent(String) == c

        cache.clear()
        cache.getIfPresent(String) == null
    }

    def "creates a map whose keys are classes"() {
        def a = new Object()
        def b = new Object()

# functions called by testing or internal/fuzz in the background.

go test -c -fuzz=.  # Build using shared build cache for speed.
env GOCACHE=$WORK/gocache
exec ./fuzz.test$GOEXE -test.fuzzcachedir=$GOCACHE/fuzz -test.fuzz=FuzzMinCache -test.fuzztime=1000x
go run check_cache/check_cache.go $GOCACHE/fuzz/FuzzMinCache

# Test that minimization occurs for a crash that appears while minimizing a

# Test go build -pgo=auto flag.

[short] skip 'compiles and links executables'

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

# use default.pgo for a single main package
go build -n -pgo=auto -o a1.exe ./a/a1
stderr 'preprofile.*-i.*default\.pgo'
stderr 'compile.*-pgoprofile=.*a1.go'

# check that pgo applied to dependencies
stderr 'compile.*-p test/dep.*-pgoprofile=.*'

# check that pgo appears in build info

    }

    @Override
    public <V> FileContentCache<V> newCache(String name, int normalizedCacheSize, Calculator<? extends V> calculator, Serializer<V> serializer) {
        FileContentCache<V> globalCache = globalFactory.newCache(name, normalizedCacheSize, calculator, serializer);
        FileContentCache<V> localCache = localFactory.newCache(name, normalizedCacheSize, calculator, serializer);

[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 --
package main

import "C"

import org.gradle.cache.CacheCleanupStrategy;
import org.gradle.cache.CacheOpenException;
import org.gradle.cache.CleanupAction;
import org.gradle.cache.CleanupProgressMonitor;
import org.gradle.cache.IndexedCache;
import org.gradle.cache.IndexedCacheParameters;
import org.gradle.cache.LockOptions;
import org.gradle.cache.PersistentCache;
import org.gradle.cache.internal.CacheFactory;

    -e TZ="${TIMEZONE:-$TZ}" \
    --mount "type=bind,source=${MOUNT_SOURCE},destination=/work" \
    --mount "type=volume,source=go,destination=/go" \
    --mount "type=volume,source=gocache,destination=/gocache" \
    --mount "type=volume,source=cache,destination=/home/.cache" \
    --mount "type=volume,source=crates,destination=/home/.cargo/registry" \
    --mount "type=volume,source=git-crates,destination=/home/.cargo/git" \
    ${CONDITIONAL_HOST_MOUNTS} \

# Normally, the default is gcc or clang, but if CC was set during make.bash,
# that becomes the default.
[!cc:clang] [!cc:gcc] skip 'C compiler is not gcc or clang'

env GOCACHE=$WORK/gocache  # Looking for compile flags, so need a clean cache.
[!GOOS:windows] env PATH=.:$PATH
[!GOOS:windows] chmod 0755 p/gcc p/clang
[!GOOS:windows] exists -exec p/gcc p/clang
[GOOS:windows] exists -exec p/gcc.bat p/clang.bat
! exists p/bug.txt

[short] skip
[!fuzz-instrumented] skip

env GOCACHE=$WORK/cache
! go test -fuzz=FuzzDead -v
# This is a somewhat inexact check, but since we don't prefix the error with anything
# and as the error suffix is platform dependent, this is the best we can do. In the
# deadlock failure case, the test will just deadlock and timeout anyway, so it should
# be clear that that failure mode is different.
stdout 'open'

-- go.mod --
module test