# Issue 28549: go test -c -o /dev/null should not overwrite /dev/null when run as root.
cd x
cmp $devnull $WORK/empty.txt
go test -o=$devnull -c
! exists x.test$GOEXE
cmp $devnull $WORK/empty.txt

# Issue 12407: go build -o /dev/null should succeed.
cd ..
go build -o $devnull y
cmp $devnull $WORK/empty.txt

-- x/x_test.go --
package x_test
import (
    "testing"
)
func TestNUL(t *testing.T) {
}

# not update the go.mod file.

go list -test -deps example.com/a
stdout example.com/b
! stdout example.com/c

[!short] go test -c -o $devnull example.com/a
[!short] cmp go.mod go.mod.old

go list -test -deps example.com/b
stdout example.com/c

[!short] go test -c -o $devnull example.com/b
[!short] cmp go.mod go.mod.old

go mod edit -go=1.17 a/go.mod
go mod edit -go=1.17 b1/go.mod
go mod edit -go=1.17 b2/go.mod

! go build -o $devnull cmd/buildid
stderr 'android/amd64 requires external \(cgo\) linking, but cgo is not enabled'
! stderr 'cannot find runtime/cgo'

! go test -c -o $devnull os
stderr '# os\nandroid/amd64 requires external \(cgo\) linking, but cgo is not enabled'
! stderr 'cannot find runtime/cgo'

env GOOS=ios GOARCH=arm64 CGO_ENABLED=0

! go build -o $devnull cmd/buildid

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

# Building a main package should run the compiler and linker ...
go build -o $devnull -x main.go
stderr '(compile|gccgo)( |\.exe).*main\.go'
stderr '(link|gccgo)( |\.exe)'

# ... and then the linker again ...
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.

)

func TestRemoveDevNull(t *testing.T) {
	fi, err := os.Lstat(os.DevNull)
	if err != nil {
		t.Skip(err)
	}
	if fi.Mode().IsRegular() {
		t.Errorf("Lstat(%s).Mode().IsRegular() = true; expected false", os.DevNull)
	}
	mayberemovefile(os.DevNull)
	_, err = os.Lstat(os.DevNull)
	if err != nil {
		t.Errorf("mayberemovefile(%s) did remove it; oops", os.DevNull)
	}
}

func TestSplitPkgConfigOutput(t *testing.T) {

! go test -o $WORK/bin/filename.exe ./pkg/...
stderr '^with multiple packages, -o must refer to a directory or '$devnull

! go test -o $WORK/bin/ ./...
stderr '^cannot write test binary pkg1.test for multiple packages:\nexample/anotherpkg/pkg1\nexample/pkg/pkg1'

go test -c -o $devnull ./...

rm pkg1.test$GOEXE
rm pkg2.test$GOEXE
go test -o . ./pkg/...
exists -exec pkg1.test$GOEXE
exists -exec pkg2.test$GOEXE

package vcweb_test

import (
	"cmd/go/internal/vcweb"
	"io"
	"log"
	"net/http"
	"net/http/httptest"
	"os"
	"testing"
)

func TestHelp(t *testing.T) {
	s, err := vcweb.NewServer(os.DevNull, t.TempDir(), log.Default())
	if err != nil {
		t.Fatal(err)
	}
	srv := httptest.NewServer(s)
	defer srv.Close()

	resp, err := http.Get(srv.URL + "/help")
	if err != nil {
		t.Fatal(err)
	}

exec pwd
cp $WORK/go.mod ./go.mod
cp $WORK/main.go ./main.go
cp $WORK/main_nocgo.go ./main_nocgo.go
cp $WORK/main_test.go ./main_test.go

! go build -o $devnull .
stderr 'package example: invalid package directory .*uh-oh'

[cgo] ! go build -o $devnull main.go
[!cgo] ! go build -o $devnull main_nocgo.go
stderr 'package command-line-arguments: invalid package directory .*uh-oh'

! go run .

mkdir tmp1
mkdir tmp2
mkdir tmp3
mkdir tmp4
mkdir tmp5

# First build: no external linking expected
go build -ldflags=-tmpdir=tmp1 -o $devnull ./noUseOfCgo &

# Second build: using only "runtime/cgo", expect internal linking.
go build -ldflags=-tmpdir=tmp2 -o $devnull ./usesInternalCgo &

# Third build: program uses only "runtime/cgo", so we would normally

# Tests Issue #54468

[short] skip 'links a test binary'
[!race] skip

go mod tidy
go test -c -o=$devnull -race .

! stderr 'cannot find package'

-- go.mod --
module testrace

go 1.18

require rsc.io/sampler v1.0.0
-- race_test.go --
//go:build race

package testrace

import (
        "testing"

        _ "rsc.io/sampler"
)

func TestRaceTag(t *testing.T) {