env GO111MODULE=off
[short] skip

# This test tests that we can link in-package syso files that provides symbols
# for cgo. See issue 29253.
[!cgo] stop
[!compiler:gc] stop
cc -c -o pkg/o.syso ext.c
go build main.go

-- ext.c --
// +build ignore

int f() { return 42; }
-- pkg/pkg.go --
package pkg

// extern int f(void);
import "C"

func init() {
	if v := C.f(); v != 42 {
		panic(v)
	}
}
-- main.go --

	flagSet.BoolVar(&unexported, "u", false, "show unexported symbols as well as exported")
	flagSet.BoolVar(&matchCase, "c", false, "symbol matching honors case (paths not affected)")
	flagSet.BoolVar(&showAll, "all", false, "show all documentation for package")
	flagSet.BoolVar(&showCmd, "cmd", false, "show symbols with package docs even if package is a command")
	flagSet.BoolVar(&showSrc, "src", false, "show source code for symbol")

package main

/*
#include <stdlib.h>
#include <stdio.h>

void test(int *a) {
	// Access Go pointer out of bounds.
	int c = a[5];        // BOOM
	// We shouldn't get here; asan should stop us first.
	printf("a[5]=%d\n", c);
}
*/
import "C"

func main() {
	cIntSlice := []C.int{200, 201, 203, 203, 204}
	C.test(&cIntSlice[0])

[trimpath] env GOROOT=
[trimpath] ! go env GOROOT
[trimpath] stderr '^go: cannot find GOROOT directory: ''go'' binary is trimmed and GOROOT is not set$'
[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 .

! stderr '[^0-9]0\.0%'
! stdout '[^0-9]0\.0%'

grep -count=1 '^mode: set$' $WORK/cover.out
grep 'errors\.go' $WORK/cover.out
grep 'binary\.go' $WORK/cover.out

[!race] stop

go test -short -race -cover encoding/binary errors -coverprofile=$WORK/cover.out
! stderr '[^0-9]0\.0%'
! stdout '[^0-9]0\.0%'

grep -count=1 '^mode: atomic$' $WORK/cover.out
grep 'errors\.go' $WORK/cover.out

  int32_t * volatile q = (int32_t *)malloc(sizeof(int32_t) * n);
  memcpy(p, q, n * sizeof(*p));
  free(q);
}

void g(int32_t *p, int n) {
  if (p[4] != 1) {
    // We shouldn't get here; msan should stop us first.
    exit(0);
  }
}
*/
import "C"

import (
	"unsafe"
)

func main() {
	a := make([]int32, 10)
	C.f((*C.int32_t)(unsafe.Pointer(&a[0])), C.int(len(a)))
	a[3] = 1

	go func() {
		f()
		close(done)
	}()

	timer := time.NewTimer(quiescent)
	defer timer.Stop()
	select {
	case <-done:
		t.Fatalf("%s unexpectedly did not block", desc)
	case <-timer.C:
	}

	return func(t *testing.T) {
		logTimer := time.NewTimer(quiescent)
		defer logTimer.Stop()

		select {
		case <-logTimer.C:
			// We expect the operation to have unblocked by now,

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
exec ./run_go$GOEXE $GOPATH/src/my.pkg/main $GOPATH REPLACE_SLASH build -o $WORK/tmp/a.exe -ldflags -X=my.pkg.Text=linkXworked
exec $WORK/tmp/a.exe

go build -x -overlay overlay.json ./test_cache
stderr '(compile|gccgo)( |\.exe).*test_cache.go'  # not cached
env CACHE=$OLD_GOCACHE

# Run same tests but with gccgo.
env GO111MODULE=off
[!exec:gccgo] stop
[cross] stop  # gccgo can't necessarily cross-compile

! go build -compiler=gccgo .
go build -compiler=gccgo -overlay overlay.json -o main_gccgo$GOEXE .
exec ./main_gccgo$goexe
stdout '^hello$'

# GOBIN set, since individual source files aren't part of the containing GOPATH.
! go install testdata/local/easy.go
stderr '^go: no install location for \.go files listed on command line \(GOBIN not set\)$'

[GOOS:windows] stop  # Windows does not allow the ridiculous directory name we're about to use.

env BAD_DIR_NAME='#$%:, &()*;<=>?\^{}'

mkdir -p testdata/$BAD_DIR_NAME/easysub
mkdir -p testdata/$BAD_DIR_NAME/sub/sub