! go test badtest/badexec
! stdout ^ok
stdout ^FAIL\tbadtest/badexec

! go test badtest/badsyntax
! stdout ^ok
stdout ^FAIL\tbadtest/badsyntax

! go test badtest/badvar
! stdout ^ok
stdout ^FAIL\tbadtest/badvar

! go test notest
! stdout ^ok
stderr '^notest.hello.go:6:1: syntax error: non-declaration statement outside function body' # Exercise issue #7108

-- badtest/badexec/x_test.go --
package badexec

func init() {

go tool covdata percent -i=data/goodexit
stdout  'coverage:.*[1-9][0-9.]+%'

# Program makes a direct call to os.Exit(1).
env GOCOVERDIR=data/badexit
! exec ./example.exe badexit
! stderr '^warning: GOCOVERDIR not set, no coverage data emitted'
go tool covdata percent -i=data/badexit
stdout  'coverage:.*[1-9][0-9.]+%'

# Program invokes panic.
env GOCOVERDIR=data/panic
! exec ./example.exe panic

	}

	t.Logf("HasGoBuild is true; checking consistency with other functions")

	hasExec := false
	hasExecGo := false
	t.Run("MustHaveExec", func(t *testing.T) {
		testenv.MustHaveExec(t)
		hasExec = true
	})
	t.Run("MustHaveExecPath", func(t *testing.T) {
		testenv.MustHaveExecPath(t, "go")
		hasExecGo = true
	})
	if !hasExec {
		t.Errorf(`MustHaveExec(t) skipped unexpectedly`)
	}
	if !hasExecGo {

package callbacks

import (
	"gorm.io/gorm"
)

func RawExec(db *gorm.DB) {
	if db.Error == nil && !db.DryRun {
		result, err := db.Statement.ConnPool.ExecContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...)
		if err != nil {
			db.AddError(err)
			return
		}

		db.RowsAffected, _ = result.RowsAffected()
	}

			return cmd.Process.Signal(interrupt)
		}
	}

	cmdExec := script.Exec(cancel, waitDelay)
	cmds["exec"] = cmdExec

	add := func(name string, cmd script.Cmd) {
		if _, ok := cmds[name]; ok {
			panic(fmt.Sprintf("command %q is already registered", name))
		}
		cmds[name] = cmd
	}

	add("cc", scriptCC(cmdExec))
	cmdGo := scriptGo(cancel, waitDelay)
	add("go", cmdGo)

	if dryRun {
		return fmt.Sprintf("Dry run: would be running podExec %s/%s/%s:%s", pod, namespace, container, cmdStr), nil
	}
	task := fmt.Sprintf("PodExec %s/%s/%s:%s", namespace, pod, container, cmdStr)
	r.addRunningTask(task)
	defer r.removeRunningTask(task)
	stdout, stderr, err := r.Client.PodExec(pod, namespace, container, cmdStr)
	if err != nil {
		return "", fmt.Errorf("podExec error: %s\n\nstderr:\n%s\n\nstdout:\n%s",

# Test that we can unset variables, even if initially invalid,
# as long as resulting config is valid.

env GOENV=badenv
env GOOS=
env GOARCH=
env GOEXPERIMENT=

! go env
stderr '^go(\.exe)?: unknown GOEXPERIMENT badexp$'

go env -u GOEXPERIMENT

! go env
stderr '^go: unsupported GOOS/GOARCH pair bados/badarch$'

! go env -u GOOS
stderr '^go: unsupported GOOS/GOARCH pair \w+/badarch$'

! go env -u GOARCH

		// TODO determine a better range for BadExpr below
		par.List = []*ast.Field{{Type: &ast.BadExpr{pos, pos}}}
		return par
	}

	// recv type must be of the form ["*"] identifier
	recv := par.List[0]
	base := deref(recv.Type)
	if _, isIdent := base.(*ast.Ident); !isIdent {
		p.errorExpected(base.Pos(), "(unqualified) identifier")
		par.List = []*ast.Field{{Type: &ast.BadExpr{recv.Pos(), recv.End()}}}
	}

			expected string
			musthave []string
		}{
			{
				mode:     "simple",
				expected: "bar foo",
			},
			{
				mode:     "goodexit",
				expected: "orange apple",
			},
			{
				mode:     "badexit",
				expected: "blub blix",
			},
			{
				mode: "panics",
				musthave: []string{
					"fatal error: exit hook invoked panic",
					"main.testPanics",
				},
			},
			{
				mode: "callsexit",

	_ "unsafe"
)

var modeflag = flag.String("mode", "", "mode to run in")

func main() {
	flag.Parse()
	switch *modeflag {
	case "simple":
		testSimple()
	case "goodexit":
		testGoodExit()
	case "badexit":
		testBadExit()
	case "panics":
		testPanics()
	case "callsexit":
		testHookCallsExit()
	case "exit2":
		testExit2()
	default:
		panic("unknown mode")
	}
}

func testSimple() {