! 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

)

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

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

		EBADF   = 0x09
		O_RDWR  = 0x02
	)

	devNull := []byte("/dev/null\x00")
	for i := 0; i < 3; i++ {
		ret, errno := fcntl(int32(i), F_GETFD, 0)
		if ret >= 0 {
			continue
		}

		if errno != EBADF {
			print("runtime: unexpected error while checking standard file descriptor ", i, ", errno=", errno, "\n")
			throw("cannot open standard fds")
		}

		if ret := open(&devNull[0], O_RDWR, 0); ret < 0 {

}

func podAndNetns() (*v1.Pod, *fakeNs) {
	devNull, err := os.Open(os.DevNull)
	if err != nil {
		panic(err)
	}
	// we can't close this now, because we need to pass it from the ztunnel server to the client
	// it would leak, but this is a test, so we don't care
	//	defer devNull.Close()

	id := ztunnelTestCounter.Add(1)
	pod := &v1.Pod{
		ObjectMeta: metav1.ObjectMeta{

[!fuzz] skip
[short] skip
env GOCACHE=$WORK/cache

# Warm up the build cache with GOMAXPROCS unrestricted.
go test -c -o $devnull

# For the fuzzing phase, we reduce GOMAXPROCS to avoid consuming too many
# resources during the test. Ideally this would just free up resources to run
# other parallel tests more quickly, but unfortunately it is actually necessary
# in some 32-bit environments to prevent the fuzzing engine from running out of

	peerRESTMethodDownloadProfilingData = "/downloadprofilingdata"
	peerRESTMethodSpeedTest             = "/speedtest"
	peerRESTMethodDriveSpeedTest        = "/drivespeedtest"
	peerRESTMethodDevNull               = "/devnull"
	peerRESTMethodNetperf               = "/netperf"
	peerRESTMethodGetReplicationMRF     = "/getreplicationmrf"
)

const (
	peerRESTBucket          = "bucket"
	peerRESTBuckets         = "buckets"

	GOROOT=<actual GOROOT>
	TESTGO_GOROOT=<GOROOT used to build cmd/go, for use in tests that may change GOROOT>
	HOME=/no-home
	PATH=<actual PATH>
	TMPDIR=$WORK/tmp
	GODEBUG=<actual GODEBUG>
	devnull=<value of os.DevNull>
	goversion=<current Go version; for example, 1.12>

On Plan 9, the variables $path and $home are set instead of $PATH and $HOME.
On Windows, the variables $USERPROFILE and $TMP are set instead of

	adminAPIVersionPrefix          = SlashSeparator + adminAPIVersion
	adminAPISiteReplicationDevNull = "/site-replication/devnull"
	adminAPISiteReplicationNetPerf = "/site-replication/netperf"
	adminAPIClientDevNull          = "/speedtest/client/devnull"
	adminAPIClientDevExtraTime     = "/speedtest/client/devnull/extratime"
)

var gzipHandler = func() func(http.Handler) http.HandlerFunc {