src/runtime/crash_test.go - go - Git at Google

 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package runtime_test

 import (
 	"fmt"
 	"internal/testenv"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"regexp"
 	"runtime"
 	"strings"
 	"sync"
 	"testing"
 )

 var toRemove []string

 func TestMain(m *testing.M) {
 	status := m.Run()
 	for _, file := range toRemove {
 		os.RemoveAll(file)
 	}
 	os.Exit(status)
 }

 func testEnv(cmd *exec.Cmd) *exec.Cmd {
 	if cmd.Env != nil {
 		panic("environment already set")
 	}
 	for _, env := range os.Environ() {
 		// Exclude GODEBUG from the environment to prevent its output
 		// from breaking tests that are trying to parse other command output.
 		if strings.HasPrefix(env, "GODEBUG=") {
 			continue
 		}
 		// Exclude GOTRACEBACK for the same reason.
 		if strings.HasPrefix(env, "GOTRACEBACK=") {
 			continue
 		}
 		cmd.Env = append(cmd.Env, env)
 	}
 	return cmd
 }

 var testprog struct {
 	sync.Mutex
 	dir    string
 	target map[string]buildexe
 }

 type buildexe struct {
 	exe string
 	err error
 }

 func runTestProg(t *testing.T, binary, name string) string {
 	testenv.MustHaveGoBuild(t)

 	exe, err := buildTestProg(t, binary)
 	if err != nil {
 		t.Fatal(err)
 	}
 	got, _ := testEnv(exec.Command(exe, name)).CombinedOutput()
 	return string(got)
 }

 func buildTestProg(t *testing.T, binary string) (string, error) {
 	checkStaleRuntime(t)

 	testprog.Lock()
 	defer testprog.Unlock()
 	if testprog.dir == "" {
 		dir, err := ioutil.TempDir("", "go-build")
 		if err != nil {
 			t.Fatalf("failed to create temp directory: %v", err)
 		}
 		testprog.dir = dir
 		toRemove = append(toRemove, dir)
 	}

 	if testprog.target == nil {
 		testprog.target = make(map[string]buildexe)
 	}
 	target, ok := testprog.target[binary]
 	if ok {
 		return target.exe, target.err
 	}

 	exe := filepath.Join(testprog.dir, binary+".exe")
 	cmd := exec.Command("go", "build", "-o", exe)
 	cmd.Dir = "testdata/" + binary
 	out, err := testEnv(cmd).CombinedOutput()
 	if err != nil {
 		exe = ""
 		target.err = fmt.Errorf("building %s: %v\n%s", binary, err, out)
 		testprog.target[binary] = target
 		return "", err
 	}
 	target.exe = exe
 	testprog.target[binary] = target
 	return exe, nil
 }

 var (
 	staleRuntimeOnce sync.Once // guards init of staleRuntimeErr
 	staleRuntimeErr  error
 )

 func checkStaleRuntime(t *testing.T) {
 	staleRuntimeOnce.Do(func() {
 		// 'go run' uses the installed copy of runtime.a, which may be out of date.
 		out, err := testEnv(exec.Command("go", "list", "-f", "{{.Stale}}", "runtime")).CombinedOutput()
 		if err != nil {
 			staleRuntimeErr = fmt.Errorf("failed to execute 'go list': %v\n%v", err, string(out))
 			return
 		}
 		if string(out) != "false\n" {
 			staleRuntimeErr = fmt.Errorf("Stale runtime.a. Run 'go install runtime'.")
 		}
 	})
 	if staleRuntimeErr != nil {
 		t.Fatal(staleRuntimeErr)
 	}
 }

 func testCrashHandler(t *testing.T, cgo bool) {
 	type crashTest struct {
 		Cgo bool
 	}
 	var output string
 	if cgo {
 		output = runTestProg(t, "testprogcgo", "Crash")
 	} else {
 		output = runTestProg(t, "testprog", "Crash")
 	}
 	want := "main: recovered done\nnew-thread: recovered done\nsecond-new-thread: recovered done\nmain-again: recovered done\n"
 	if output != want {
 		t.Fatalf("output:\n%s\n\nwanted:\n%s", output, want)
 	}
 }

 func TestCrashHandler(t *testing.T) {
 	testCrashHandler(t, false)
 }

 func testDeadlock(t *testing.T, name string) {
 	output := runTestProg(t, "testprog", name)
 	want := "fatal error: all goroutines are asleep - deadlock!\n"
 	if !strings.HasPrefix(output, want) {
 		t.Fatalf("output does not start with %q:\n%s", want, output)
 	}
 }

 func TestSimpleDeadlock(t *testing.T) {
 	testDeadlock(t, "SimpleDeadlock")
 }

 func TestInitDeadlock(t *testing.T) {
 	testDeadlock(t, "InitDeadlock")
 }

 func TestLockedDeadlock(t *testing.T) {
 	testDeadlock(t, "LockedDeadlock")
 }

 func TestLockedDeadlock2(t *testing.T) {
 	testDeadlock(t, "LockedDeadlock2")
 }

 func TestGoexitDeadlock(t *testing.T) {
 	output := runTestProg(t, "testprog", "GoexitDeadlock")
 	want := "no goroutines (main called runtime.Goexit) - deadlock!"
 	if !strings.Contains(output, want) {
 		t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
 	}
 }

 func TestStackOverflow(t *testing.T) {
 	output := runTestProg(t, "testprog", "StackOverflow")
 	want := "runtime: goroutine stack exceeds 1474560-byte limit\nfatal error: stack overflow"
 	if !strings.HasPrefix(output, want) {
 		t.Fatalf("output does not start with %q:\n%s", want, output)
 	}
 }

 func TestThreadExhaustion(t *testing.T) {
 	output := runTestProg(t, "testprog", "ThreadExhaustion")
 	want := "runtime: program exceeds 10-thread limit\nfatal error: thread exhaustion"
 	if !strings.HasPrefix(output, want) {
 		t.Fatalf("output does not start with %q:\n%s", want, output)
 	}
 }

 func TestRecursivePanic(t *testing.T) {
 	output := runTestProg(t, "testprog", "RecursivePanic")
 	want := `wrap: bad
 panic: again

 `
 	if !strings.HasPrefix(output, want) {
 		t.Fatalf("output does not start with %q:\n%s", want, output)
 	}

 }

 func TestGoexitCrash(t *testing.T) {
 	output := runTestProg(t, "testprog", "GoexitExit")
 	want := "no goroutines (main called runtime.Goexit) - deadlock!"
 	if !strings.Contains(output, want) {
 		t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
 	}
 }

 func TestGoexitDefer(t *testing.T) {
 	c := make(chan struct{})
 	go func() {
 		defer func() {
 			r := recover()
 			if r != nil {
 				t.Errorf("non-nil recover during Goexit")
 			}
 			c <- struct{}{}
 		}()
 		runtime.Goexit()
 	}()
 	// Note: if the defer fails to run, we will get a deadlock here
 	<-c
 }

 func TestGoNil(t *testing.T) {
 	output := runTestProg(t, "testprog", "GoNil")
 	want := "go of nil func value"
 	if !strings.Contains(output, want) {
 		t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
 	}
 }

 func TestMainGoroutineID(t *testing.T) {
 	output := runTestProg(t, "testprog", "MainGoroutineID")
 	want := "panic: test\n\ngoroutine 1 [running]:\n"
 	if !strings.HasPrefix(output, want) {
 		t.Fatalf("output does not start with %q:\n%s", want, output)
 	}
 }

 func TestNoHelperGoroutines(t *testing.T) {
 	output := runTestProg(t, "testprog", "NoHelperGoroutines")
 	matches := regexp.MustCompile(`goroutine [0-9]+ \[`).FindAllStringSubmatch(output, -1)
 	if len(matches) != 1 || matches[0][0] != "goroutine 1 [" {
 		t.Fatalf("want to see only goroutine 1, see:\n%s", output)
 	}
 }

 func TestBreakpoint(t *testing.T) {
 	output := runTestProg(t, "testprog", "Breakpoint")
 	want := "runtime.Breakpoint()"
 	if !strings.Contains(output, want) {
 		t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
 	}
 }

 func TestGoexitInPanic(t *testing.T) {
 	// see issue 8774: this code used to trigger an infinite recursion
 	output := runTestProg(t, "testprog", "GoexitInPanic")
 	want := "fatal error: no goroutines (main called runtime.Goexit) - deadlock!"
 	if !strings.HasPrefix(output, want) {
 		t.Fatalf("output does not start with %q:\n%s", want, output)
 	}
 }

 func TestPanicAfterGoexit(t *testing.T) {
 	// an uncaught panic should still work after goexit
 	output := runTestProg(t, "testprog", "PanicAfterGoexit")
 	want := "panic: hello"
 	if !strings.HasPrefix(output, want) {
 		t.Fatalf("output does not start with %q:\n%s", want, output)
 	}
 }

 func TestRecoveredPanicAfterGoexit(t *testing.T) {
 	output := runTestProg(t, "testprog", "RecoveredPanicAfterGoexit")
 	want := "fatal error: no goroutines (main called runtime.Goexit) - deadlock!"
 	if !strings.HasPrefix(output, want) {
 		t.Fatalf("output does not start with %q:\n%s", want, output)
 	}
 }

 func TestRecoverBeforePanicAfterGoexit(t *testing.T) {
 	// 1. defer a function that recovers
 	// 2. defer a function that panics
 	// 3. call goexit
 	// Goexit should run the #2 defer.  Its panic
 	// should be caught by the #1 defer, and execution
 	// should resume in the caller.  Like the Goexit
 	// never happened!
 	defer func() {
 		r := recover()
 		if r == nil {
 			panic("bad recover")
 		}
 	}()
 	defer func() {
 		panic("hello")
 	}()
 	runtime.Goexit()
 }

 func TestNetpollDeadlock(t *testing.T) {
 	output := runTestProg(t, "testprognet", "NetpollDeadlock")
 	want := "done\n"
 	if !strings.HasSuffix(output, want) {
 		t.Fatalf("output does not start with %q:\n%s", want, output)
 	}
 }
	// Copyright 2012 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package runtime_test

	import (
	"fmt"
	"internal/testenv"
	"io/ioutil"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"runtime"
	"strings"
	"sync"
	"testing"
	)

	var toRemove []string

	func TestMain(m *testing.M) {
	status := m.Run()
	for _, file := range toRemove {
	os.RemoveAll(file)
	}
	os.Exit(status)
	}

	func testEnv(cmd exec.Cmd) exec.Cmd {
	if cmd.Env != nil {
	panic("environment already set")
	}
	for _, env := range os.Environ() {
	// Exclude GODEBUG from the environment to prevent its output
	// from breaking tests that are trying to parse other command output.
	if strings.HasPrefix(env, "GODEBUG=") {
	continue
	}
	// Exclude GOTRACEBACK for the same reason.
	if strings.HasPrefix(env, "GOTRACEBACK=") {
	continue
	}
	cmd.Env = append(cmd.Env, env)
	}
	return cmd
	}

	var testprog struct {
	sync.Mutex
	dir string
	target map[string]buildexe
	}

	type buildexe struct {
	exe string
	err error
	}

	func runTestProg(t *testing.T, binary, name string) string {
	testenv.MustHaveGoBuild(t)

	exe, err := buildTestProg(t, binary)
	if err != nil {
	t.Fatal(err)
	}
	got, _ := testEnv(exec.Command(exe, name)).CombinedOutput()
	return string(got)
	}

	func buildTestProg(t *testing.T, binary string) (string, error) {
	checkStaleRuntime(t)

	testprog.Lock()
	defer testprog.Unlock()
	if testprog.dir == "" {
	dir, err := ioutil.TempDir("", "go-build")
	if err != nil {
	t.Fatalf("failed to create temp directory: %v", err)
	}
	testprog.dir = dir
	toRemove = append(toRemove, dir)
	}

	if testprog.target == nil {
	testprog.target = make(map[string]buildexe)
	}
	target, ok := testprog.target[binary]
	if ok {
	return target.exe, target.err
	}

	exe := filepath.Join(testprog.dir, binary+".exe")
	cmd := exec.Command("go", "build", "-o", exe)
	cmd.Dir = "testdata/" + binary
	out, err := testEnv(cmd).CombinedOutput()
	if err != nil {
	exe = ""
	target.err = fmt.Errorf("building %s: %v\n%s", binary, err, out)
	testprog.target[binary] = target
	return "", err
	}
	target.exe = exe
	testprog.target[binary] = target
	return exe, nil
	}

	var (
	staleRuntimeOnce sync.Once // guards init of staleRuntimeErr
	staleRuntimeErr error
	)

	func checkStaleRuntime(t *testing.T) {
	staleRuntimeOnce.Do(func() {
	// 'go run' uses the installed copy of runtime.a, which may be out of date.
	out, err := testEnv(exec.Command("go", "list", "-f", "{{.Stale}}", "runtime")).CombinedOutput()
	if err != nil {
	staleRuntimeErr = fmt.Errorf("failed to execute 'go list': %v\n%v", err, string(out))
	return
	}
	if string(out) != "false\n" {
	staleRuntimeErr = fmt.Errorf("Stale runtime.a. Run 'go install runtime'.")
	}
	})
	if staleRuntimeErr != nil {
	t.Fatal(staleRuntimeErr)
	}
	}

	func testCrashHandler(t *testing.T, cgo bool) {
	type crashTest struct {
	Cgo bool
	}
	var output string
	if cgo {
	output = runTestProg(t, "testprogcgo", "Crash")
	} else {
	output = runTestProg(t, "testprog", "Crash")
	}
	want := "main: recovered done\nnew-thread: recovered done\nsecond-new-thread: recovered done\nmain-again: recovered done\n"
	if output != want {
	t.Fatalf("output:\n%s\n\nwanted:\n%s", output, want)
	}
	}

	func TestCrashHandler(t *testing.T) {
	testCrashHandler(t, false)
	}

	func testDeadlock(t *testing.T, name string) {
	output := runTestProg(t, "testprog", name)
	want := "fatal error: all goroutines are asleep - deadlock!\n"
	if !strings.HasPrefix(output, want) {
	t.Fatalf("output does not start with %q:\n%s", want, output)
	}
	}

	func TestSimpleDeadlock(t *testing.T) {
	testDeadlock(t, "SimpleDeadlock")
	}

	func TestInitDeadlock(t *testing.T) {
	testDeadlock(t, "InitDeadlock")
	}

	func TestLockedDeadlock(t *testing.T) {
	testDeadlock(t, "LockedDeadlock")
	}

	func TestLockedDeadlock2(t *testing.T) {
	testDeadlock(t, "LockedDeadlock2")
	}

	func TestGoexitDeadlock(t *testing.T) {
	output := runTestProg(t, "testprog", "GoexitDeadlock")
	want := "no goroutines (main called runtime.Goexit) - deadlock!"
	if !strings.Contains(output, want) {
	t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
	}
	}

	func TestStackOverflow(t *testing.T) {
	output := runTestProg(t, "testprog", "StackOverflow")
	want := "runtime: goroutine stack exceeds 1474560-byte limit\nfatal error: stack overflow"
	if !strings.HasPrefix(output, want) {
	t.Fatalf("output does not start with %q:\n%s", want, output)
	}
	}

	func TestThreadExhaustion(t *testing.T) {
	output := runTestProg(t, "testprog", "ThreadExhaustion")
	want := "runtime: program exceeds 10-thread limit\nfatal error: thread exhaustion"
	if !strings.HasPrefix(output, want) {
	t.Fatalf("output does not start with %q:\n%s", want, output)
	}
	}

	func TestRecursivePanic(t *testing.T) {
	output := runTestProg(t, "testprog", "RecursivePanic")
	want := `wrap: bad
	panic: again

	`
	if !strings.HasPrefix(output, want) {
	t.Fatalf("output does not start with %q:\n%s", want, output)
	}

	}

	func TestGoexitCrash(t *testing.T) {
	output := runTestProg(t, "testprog", "GoexitExit")
	want := "no goroutines (main called runtime.Goexit) - deadlock!"
	if !strings.Contains(output, want) {
	t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
	}
	}

	func TestGoexitDefer(t *testing.T) {
	c := make(chan struct{})
	go func() {
	defer func() {
	r := recover()
	if r != nil {
	t.Errorf("non-nil recover during Goexit")
	}
	c <- struct{}{}
	}()
	runtime.Goexit()
	}()
	// Note: if the defer fails to run, we will get a deadlock here
	<-c
	}

	func TestGoNil(t *testing.T) {
	output := runTestProg(t, "testprog", "GoNil")
	want := "go of nil func value"
	if !strings.Contains(output, want) {
	t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
	}
	}

	func TestMainGoroutineID(t *testing.T) {
	output := runTestProg(t, "testprog", "MainGoroutineID")
	want := "panic: test\n\ngoroutine 1 [running]:\n"
	if !strings.HasPrefix(output, want) {
	t.Fatalf("output does not start with %q:\n%s", want, output)
	}
	}

	func TestNoHelperGoroutines(t *testing.T) {
	output := runTestProg(t, "testprog", "NoHelperGoroutines")
	matches := regexp.MustCompile(`goroutine [0-9]+ \[`).FindAllStringSubmatch(output, -1)
	if len(matches) != 1 \|\| matches[0][0] != "goroutine 1 [" {
	t.Fatalf("want to see only goroutine 1, see:\n%s", output)
	}
	}

	func TestBreakpoint(t *testing.T) {
	output := runTestProg(t, "testprog", "Breakpoint")
	want := "runtime.Breakpoint()"
	if !strings.Contains(output, want) {
	t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
	}
	}

	func TestGoexitInPanic(t *testing.T) {
	// see issue 8774: this code used to trigger an infinite recursion
	output := runTestProg(t, "testprog", "GoexitInPanic")
	want := "fatal error: no goroutines (main called runtime.Goexit) - deadlock!"
	if !strings.HasPrefix(output, want) {
	t.Fatalf("output does not start with %q:\n%s", want, output)
	}
	}

	func TestPanicAfterGoexit(t *testing.T) {
	// an uncaught panic should still work after goexit
	output := runTestProg(t, "testprog", "PanicAfterGoexit")
	want := "panic: hello"
	if !strings.HasPrefix(output, want) {
	t.Fatalf("output does not start with %q:\n%s", want, output)
	}
	}

	func TestRecoveredPanicAfterGoexit(t *testing.T) {
	output := runTestProg(t, "testprog", "RecoveredPanicAfterGoexit")
	want := "fatal error: no goroutines (main called runtime.Goexit) - deadlock!"
	if !strings.HasPrefix(output, want) {
	t.Fatalf("output does not start with %q:\n%s", want, output)
	}
	}

	func TestRecoverBeforePanicAfterGoexit(t *testing.T) {
	// 1. defer a function that recovers
	// 2. defer a function that panics
	// 3. call goexit
	// Goexit should run the #2 defer. Its panic
	// should be caught by the #1 defer, and execution
	// should resume in the caller. Like the Goexit
	// never happened!
	defer func() {
	r := recover()
	if r == nil {
	panic("bad recover")
	}
	}()
	defer func() {
	panic("hello")
	}()
	runtime.Goexit()
	}

	func TestNetpollDeadlock(t *testing.T) {
	output := runTestProg(t, "testprognet", "NetpollDeadlock")
	want := "done\n"
	if !strings.HasSuffix(output, want) {
	t.Fatalf("output does not start with %q:\n%s", want, output)
	}
	}