# We're testing cache behavior, so start with a clean GOCACHE.
env GOCACHE=$WORK/cache

# Build a helper binary to invoke os.Chtimes.
go build -o mkold$GOEXE mkold.go

# Make test input files appear to be a minute old.
exec ./mkold$GOEXE 1m testcache/file.txt
exec ./mkold$GOEXE 1m testcache/script.sh

# If the test reads an environment variable, changes to that variable
# should invalidate cached test results.
env TESTKEY=x

go build run_go.go

# Apply identity function to GOPATH
exec ./run_go$GOEXE $GOPATH/src/my.pkg/main $GOPATH IDENTITY build -o $WORK/tmp/a.exe -ldflags -X=my.pkg.Text=linkXworked
exec $WORK/tmp/a.exe
stderr 'linkXworked'
rm $WORK/tmp/a.exe

[!GOOS:windows] stop 'rest of the tests only apply to Windows'

# Replace '\' with '/' in GOPATH

go get example.com/printversion@v0.1.0
go install example.com/printversion

go run example.com/printversion
cmp stdout out.txt

go version -m $GOPATH/bin/printversion$GOEXE
stdout '^.*[/\\]bin[/\\]printversion'$GOEXE': .*$'
stdout '^	path	example.com/printversion$'
stdout '^	mod	example.com/printversion	v0.1.0$'
stdout '^	=>	example.com/printversion	v1.0.0	h1:.*$'
stdout '^	dep	example.com/version	v1.0.0$'

stderr '^go: example.com/cmd@v1.1.0-doesnotexist: missing go.sum entry for go.mod file; to add it:\n\tgo mod download example.com/cmd$'
go install example.com/cmd/a@latest
cmp go.mod go.mod.orig
exists $GOPATH/bin/a$GOEXE
go version -m $GOPATH/bin/a$GOEXE
stdout '^\tmod\texample.com/cmd\tv1.0.0\t' # "latest", not from go.mod
rm $GOPATH/bin/a
cd ..


# 'go install -modfile=x.mod pkg@version' reports an error, but only if

[short] skip

# Ensure that the target of 'go build -o' can be an existing, empty file so that
# its name can be reserved using os.CreateTemp or the 'mktemp` command.

go build -o empty-file$GOEXE main.go

-- main.go --
package main
func main() {}

[compiler:gccgo] skip 'gccgo does not support -ldflags -X'

go build -o linkx$GOEXE -ldflags -X=my.pkg.Text=linkXworked my.pkg/main
exec ./linkx$GOEXE
stderr '^linkXworked$'

-- go.mod --
module my.pkg

go 1.16
-- main/main.go --
package main

import "my.pkg"

func main() {
	println(pkg.Text)
}
-- pkg.go --
package pkg

	}
	return false, nil
}

func hasGoexperiment(s *script.State, value string) (bool, error) {
	GOOS, _ := s.LookupEnv("GOOS")
	GOARCH, _ := s.LookupEnv("GOARCH")
	goexp, _ := s.LookupEnv("GOEXPERIMENT")
	flags, err := buildcfg.ParseGOEXPERIMENT(GOOS, GOARCH, goexp)
	if err != nil {
		return false, err
	}
	for _, exp := range flags.All() {
		if value == exp {
			return true, nil
		}

go mod tidy # populate go.sum

# Build a binary and ensure that it can output its own debug info.
# The debug info should be accessible before main starts (golang.org/issue/29628).
go build
exec ./x$GOEXE
stderr 'mod\s+x\s+\(devel\)'
stderr 'dep\s+rsc.io/quote\s+v1.5.2\s+'
stderr '=>\s+rsc.io/quote\s+v1.0.0\s+h1:'
stderr 'Hello, world.'

[short] skip

# with vendored files.
# See issue #46400
[short] skip 'builds and links a binary twice'
go mod tidy
go mod vendor

go build -mod=vendor
go version -m example$GOEXE
cp stdout version-m.txt

env GOMODCACHE=$WORK${/}modcache
go build -mod=vendor
go version -m example$GOEXE
cmp stdout version-m.txt

-- go.mod --
module example
go 1.22
require rsc.io/sampler v1.3.0

-- main.go --
package main

import (

go build -o $devnull -x main.go
! stderr '(compile|gccgo)( |\.exe).*main\.go'
stderr '(link|gccgo)( |\.exe)'

# ... but the output binary can serve as a cache.
go build -o main$GOEXE -x main.go
stderr '(link|gccgo)( |\.exe)'
go build -o main$GOEXE -x main.go
! stderr '(link|gccgo)( |\.exe)'

-- main.go --
package main