env GO111MODULE=off

env ORIG_GOPATH=$GOPATH

# The literal path '.' in GOPATH should be rejected.
env GOPATH=.
! go build go-cmd-test/helloworld.go
stderr 'GOPATH entry is relative'

# It should still be rejected if the requested package can be
# found using another entry.
env GOPATH=${:}$ORIG_GOPATH${:}.
! go build go-cmd-test
stderr 'GOPATH entry is relative'

# GOPATH cannot be a relative subdirectory of the working directory.

[compiler:gccgo] skip 'gccgo does not support -ldflags -X'
env GO111MODULE=off
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

[trimpath] env GOROOT=$TESTGO_GOROOT

[short] stop

# With GOROOT still set, 'go build' and 'go test -c'
# should cause runtime.GOROOT() to report either the correct GOROOT
# (without -trimpath) or no GOROOT at all (with -trimpath).

go build -o example.exe .
go build -trimpath -o example-trimpath.exe .
go test -c -o example.test.exe .
go test -trimpath -c -o example.test-trimpath.exe .

	checkPkg := func(t *testing.T, m *Module, pkg string, data []byte) {
		p := m.Package(pkg)
		bp, err := p.Import(build.Default, build.ImportComment)
		if err != nil {
			t.Fatal(err)
		}
		bp1, err := build.Default.Import(".", filepath.Join(src, pkg), build.ImportComment)
		if err != nil {
			t.Fatal(err)
		}

		if !reflect.DeepEqual(bp, bp1) {
			t.Errorf("mismatch")

		}
	}

	goFile := filepath.Join(dir, "main.go")
	if err := os.WriteFile(goFile, []byte(goSource), 0444); err != nil {
		t.Fatal(err)
	}

	cmd := testenv.Command(t, goTool, "build")
	cmd.Dir = dir
	cmd.Env = env
	t.Logf("%s build", goTool)
	if out, err := cmd.CombinedOutput(); err != nil {
		t.Logf("%s", out)
		t.Fatal(err)
	}
}

var cSources35779 = []string{`
static int blah() { return 42; }

! stdout '^[^{]'
! stdout '[^}]\n$'

	# Since the only test we requested failed to build, we should
	# not see any "pass" actions in the JSON stream.
! stdout '\{.*"Action":"pass".*\}'

	# TODO(#62067): emit this as a build event instead of a test event.
stdout '\{.*"Action":"output","Package":"example","Output":"FAIL\\texample \[build failed\]\\n"\}'
stdout '\{.*"Action":"fail","Package":"example",.*\}'

-- go.mod --

# go list all should work with GOOS=linux because all packages build on Linux
env GOOS=linux
env GOARCH=amd64
go list all

# go list all should work with GOOS=darwin, but it used to fail because
# in the absence of //go:build support, p looked like it needed q
# (p_test.go was not properly excluded), and q was Linux-only.
#
# Also testing with r and s that +build lines keep working.
env GOOS=darwin
go list all

-- go.mod --
go 1.17
module m

! stdout .
cd ..

[short] skip

# Test that an unparsable .s file is completely ignored when its name
# has build tags that cause it to be filtered out, but produces an error
# when it is included

env GOARCH=arm64
env GOOS=linux
go build ./baz

env GOARCH=amd64
env GOOS=linux
! go build ./baz

-- go.mod --
module example.com/foo

go 1.20
-- bar/bar.s --
;/
-- baz/baz.go --
package bar

package m

import _ "a/foo/bar/b"
import _ "a/foo/bar/c"
-- v1.go --
package m

import _ "x"
-- v2.go --
// +build abc

package mMmMmMm

import _ "y"
-- v3.go --
// +build !abc

package m

import _ "z"
-- v4.go --
// +build notmytag

package m

import _ "x/x1"
-- w/go.mod --
module w
-- w/w.go --
package w
-- x/go.mod --
module x

	if err != nil {
		t.Fatalf("can't write output: %v\n", err)
	}

	// Build and run with internal linking.
	cmd := testenv.Command(t, testenv.GoToolPath(t), "build", "-o", "bigtext")
	cmd.Dir = tmpdir
	out, err := cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("Build failed for big text program with internal linking: %v, output: %s", err, out)
	}
	cmd = testenv.Command(t, "./bigtext")