symlink $GOROOT -> $TESTGO_GOROOT

# Set up fresh GOCACHE
env GOCACHE=$WORK/gocache1
mkdir $GOCACHE

# Build a simple binary
go build -o binary1 -trimpath -x main.go

# Now repeat the same process with the compiler at a different local path
env GOROOT=$WORK/goroot2
symlink $GOROOT -> $TESTGO_GOROOT

env GOCACHE=$WORK/gocache2
mkdir $GOCACHE

go build -o binary2 -trimpath -x main.go

env GOCACHE=$WORK/cache

# Build something so that the cache gets populates
go build main.go

# Check that cache contains directories before running
exists $GOCACHE/00

# Run go clean -cache -n and ensure that directories weren't deleted
go clean -cache -n
exists $GOCACHE/00

# Re-run go clean cache without the -n flag go ensure that directories were properly removed
go clean -cache

[!fuzz-instrumented] skip

[short] skip
env GOCACHE=$WORK/cache

# Fuzz cache should not exist after a regular test run.
go test .
exists $GOCACHE
! exists $GOCACHE/fuzz

# Fuzzing should write interesting values to the cache.
go test -fuzz=FuzzY -fuzztime=100x .
go run ./contains_files $GOCACHE/fuzz/example.com/y/FuzzY

# 'go clean -cache' should not delete the fuzz cache.
go clean -cache
exists $GOCACHE/fuzz

# With all three set, we should prefer GOCACHE.
go env GOCACHE
stdout $WORK'/gocache$'

# Without GOCACHE, we should prefer XDG_CACHE_HOME over HOME.
env GOCACHE=
go env GOCACHE
stdout $WORK'/xdg/go-build$$'

# With only HOME set, we should use $HOME/.cache.
env XDG_CACHE_HOME=
go env GOCACHE
stdout $WORK'/home/.cache/go-build$'

# With no guidance from the environment, we must disable the cache, but that

env GOCACHE=test
! go build -o triv triv.go
stderr 'build cache is required, but could not be located: GOCACHE is not an absolute path'

# An explicit GOCACHE=off also disables builds.
env GOCACHE=off
! go build -o triv triv.go
stderr 'build cache is disabled by GOCACHE=off'

# If GOCACHE is set to an unwritable directory, we should diagnose it as such.
[GOOS:windows] stop # Does not support unwritable directories.

[short] skip

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

# Building trivial non-main package should run preprofile the first time.
go build -x -pgo=default.pgo lib.go
stderr 'preprofile.*default\.pgo'

# ... but not again ...
go build -x -pgo=default.pgo lib.go
! stderr 'preprofile.*default\.pgo'

# ... unless we use -a.
go build -a -x -pgo=default.pgo lib.go
stderr 'preprofile.*default\.pgo'

env GO111MODULE=off
[short] skip

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

# Building trivial non-main package should run compiler the first time.
go build -x lib.go
stderr '(compile|gccgo)( |\.exe).*lib\.go'

# ... but not again ...
go build -x lib.go
! stderr '(compile|gccgo)( |\.exe).*lib\.go'

# ... unless we use -a.
go build -a -x lib.go
stderr '(compile|gccgo)( |\.exe)'

-- lib.go --

env GO111MODULE=off
env GODEBUG=gocachetest=1

[!compiler:gc] skip
[short] skip # clears cache, rebuilds too much

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

# Building a trivial non-main package should run compiler the first time.
go build -x -gcflags=-m lib.go
stderr 'compile( |\.exe"?)'
stderr 'lib.go:2.* can inline f'

# ... but not the second, even though it still prints the compiler output.

# Test go build -pgo flag.
# Specifically, the build cache handles profile content correctly.

[short] skip 'compiles and links executables'

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

# build without PGO
go build triv.go

# build with PGO, should trigger rebuild
# starting with an empty profile (the compiler accepts it)
go build -x -pgo=prof -o triv.exe triv.go
stderr 'preprofile.*-i.*prof'

env GO111MODULE=off
[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