libgo/go/runtime/crash_test.go

   1 // Copyright 2012 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package runtime_test
   6
   7 import (
   8         "bytes"
   9         "flag"
  10         "fmt"
  11         "internal/testenv"
  12         "io/ioutil"
  13         "os"
  14         "os/exec"
  15         "path/filepath"
  16         "regexp"
  17         "runtime"
  18         "strconv"
  19         "strings"
  20         "sync"
  21         "testing"
  22         "time"
  23 )
  24
  25 var toRemove []string
  26
  27 func TestMain(m *testing.M) {
  28         status := m.Run()
  29         for _, file := range toRemove {
  30                 os.RemoveAll(file)
  31         }
  32         os.Exit(status)
  33 }
  34
  35 func testEnv(cmd *exec.Cmd) *exec.Cmd {
  36         if cmd.Env != nil {
  37                 panic("environment already set")
  38         }
  39         for _, env := range os.Environ() {
  40                 // Exclude GODEBUG from the environment to prevent its output
  41                 // from breaking tests that are trying to parse other command output.
  42                 if strings.HasPrefix(env, "GODEBUG=") {
  43                         continue
  44                 }
  45                 // Exclude GOTRACEBACK for the same reason.
  46                 if strings.HasPrefix(env, "GOTRACEBACK=") {
  47                         continue
  48                 }
  49                 cmd.Env = append(cmd.Env, env)
  50         }
  51         return cmd
  52 }
  53
  54 var testprog struct {
  55         sync.Mutex
  56         dir    string
  57         target map[string]buildexe
  58 }
  59
  60 type buildexe struct {
  61         exe string
  62         err error
  63 }
  64
  65 func runTestProg(t *testing.T, binary, name string) string {
  66         testenv.MustHaveGoBuild(t)
  67
  68         exe, err := buildTestProg(t, binary)
  69         if err != nil {
  70                 t.Fatal(err)
  71         }
  72
  73         cmd := testEnv(exec.Command(exe, name))
  74         var b bytes.Buffer
  75         cmd.Stdout = &b
  76         cmd.Stderr = &b
  77         if err := cmd.Start(); err != nil {
  78                 t.Fatalf("starting %s %s: %v", binary, name, err)
  79         }
  80
  81         // If the process doesn't complete within 1 minute,
  82         // assume it is hanging and kill it to get a stack trace.
  83         p := cmd.Process
  84         done := make(chan bool)
  85         go func() {
  86                 scale := 1
  87                 // This GOARCH/GOOS test is copied from cmd/dist/test.go.
  88                 // TODO(iant): Have cmd/dist update the environment variable.
  89                 if runtime.GOARCH == "arm" || runtime.GOOS == "windows" {
  90                         scale = 2
  91                 }
  92                 if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" {
  93                         if sc, err := strconv.Atoi(s); err == nil {
  94                                 scale = sc
  95                         }
  96                 }
  97
  98                 select {
  99                 case <-done:
 100                 case <-time.After(time.Duration(scale) * time.Minute):
 101                         p.Signal(sigquit)
 102                 }
 103         }()
 104
 105         if err := cmd.Wait(); err != nil {
 106                 t.Logf("%s %s exit status: %v", binary, name, err)
 107         }
 108         close(done)
 109
 110         return b.String()
 111 }
 112
 113 func buildTestProg(t *testing.T, binary string, flags ...string) (string, error) {
 114         checkStaleRuntime(t)
 115
 116         testprog.Lock()
 117         defer testprog.Unlock()
 118         if testprog.dir == "" {
 119                 dir, err := ioutil.TempDir("", "go-build")
 120                 if err != nil {
 121                         t.Fatalf("failed to create temp directory: %v", err)
 122                 }
 123                 testprog.dir = dir
 124                 toRemove = append(toRemove, dir)
 125         }
 126
 127         if testprog.target == nil {
 128                 testprog.target = make(map[string]buildexe)
 129         }
 130         name := binary
 131         if len(flags) > 0 {
 132                 name += "_" + strings.Join(flags, "_")
 133         }
 134         target, ok := testprog.target[name]
 135         if ok {
 136                 return target.exe, target.err
 137         }
 138
 139         exe := filepath.Join(testprog.dir, name+".exe")
 140         cmd := exec.Command(testenv.GoToolPath(t), append([]string{"build", "-o", exe}, flags...)...)
 141         cmd.Dir = "testdata/" + binary
 142         out, err := testEnv(cmd).CombinedOutput()
 143         if err != nil {
 144                 target.err = fmt.Errorf("building %s %v: %v\n%s", binary, flags, err, out)
 145                 testprog.target[name] = target
 146                 return "", target.err
 147         }
 148         target.exe = exe
 149         testprog.target[name] = target
 150         return exe, nil
 151 }
 152
 153 var (
 154         staleRuntimeOnce sync.Once // guards init of staleRuntimeErr
 155         staleRuntimeErr  error
 156 )
 157
 158 func checkStaleRuntime(t *testing.T) {
 159         staleRuntimeOnce.Do(func() {
 160                 // 'go run' uses the installed copy of runtime.a, which may be out of date.
 161                 out, err := testEnv(exec.Command(testenv.GoToolPath(t), "list", "-f", "{{.Stale}}", "runtime")).CombinedOutput()
 162                 if err != nil {
 163                         staleRuntimeErr = fmt.Errorf("failed to execute 'go list': %v\n%v", err, string(out))
 164                         return
 165                 }
 166                 if string(out) != "false\n" {
 167                         staleRuntimeErr = fmt.Errorf("Stale runtime.a. Run 'go install runtime'.")
 168                 }
 169         })
 170         if staleRuntimeErr != nil {
 171                 t.Fatal(staleRuntimeErr)
 172         }
 173 }
 174
 175 func testCrashHandler(t *testing.T, cgo bool) {
 176         type crashTest struct {
 177                 Cgo bool
 178         }
 179         var output string
 180         if cgo {
 181                 output = runTestProg(t, "testprogcgo", "Crash")
 182         } else {
 183                 output = runTestProg(t, "testprog", "Crash")
 184         }
 185         want := "main: recovered done\nnew-thread: recovered done\nsecond-new-thread: recovered done\nmain-again: recovered done\n"
 186         if output != want {
 187                 t.Fatalf("output:\n%s\n\nwanted:\n%s", output, want)
 188         }
 189 }
 190
 191 func TestCrashHandler(t *testing.T) {
 192         testCrashHandler(t, false)
 193 }
 194
 195 func testDeadlock(t *testing.T, name string) {
 196         output := runTestProg(t, "testprog", name)
 197         want := "fatal error: all goroutines are asleep - deadlock!\n"
 198         if !strings.HasPrefix(output, want) {
 199                 t.Fatalf("output does not start with %q:\n%s", want, output)
 200         }
 201 }
 202
 203 func TestSimpleDeadlock(t *testing.T) {
 204         testDeadlock(t, "SimpleDeadlock")
 205 }
 206
 207 func TestInitDeadlock(t *testing.T) {
 208         testDeadlock(t, "InitDeadlock")
 209 }
 210
 211 func TestLockedDeadlock(t *testing.T) {
 212         testDeadlock(t, "LockedDeadlock")
 213 }
 214
 215 func TestLockedDeadlock2(t *testing.T) {
 216         testDeadlock(t, "LockedDeadlock2")
 217 }
 218
 219 func TestGoexitDeadlock(t *testing.T) {
 220         output := runTestProg(t, "testprog", "GoexitDeadlock")
 221         want := "no goroutines (main called runtime.Goexit) - deadlock!"
 222         if !strings.Contains(output, want) {
 223                 t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
 224         }
 225 }
 226
 227 func TestStackOverflow(t *testing.T) {
 228         output := runTestProg(t, "testprog", "StackOverflow")
 229         want := "runtime: goroutine stack exceeds 1474560-byte limit\nfatal error: stack overflow"
 230         if !strings.HasPrefix(output, want) {
 231                 t.Fatalf("output does not start with %q:\n%s", want, output)
 232         }
 233 }
 234
 235 func TestThreadExhaustion(t *testing.T) {
 236         output := runTestProg(t, "testprog", "ThreadExhaustion")
 237         want := "runtime: program exceeds 10-thread limit\nfatal error: thread exhaustion"
 238         if !strings.HasPrefix(output, want) {
 239                 t.Fatalf("output does not start with %q:\n%s", want, output)
 240         }
 241 }
 242
 243 func TestRecursivePanic(t *testing.T) {
 244         output := runTestProg(t, "testprog", "RecursivePanic")
 245         want := `wrap: bad
 246 panic: again
 247
 248 `
 249         if !strings.HasPrefix(output, want) {
 250                 t.Fatalf("output does not start with %q:\n%s", want, output)
 251         }
 252
 253 }
 254
 255 func TestGoexitCrash(t *testing.T) {
 256         output := runTestProg(t, "testprog", "GoexitExit")
 257         want := "no goroutines (main called runtime.Goexit) - deadlock!"
 258         if !strings.Contains(output, want) {
 259                 t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
 260         }
 261 }
 262
 263 func TestGoexitDefer(t *testing.T) {
 264         c := make(chan struct{})
 265         go func() {
 266                 defer func() {
 267                         r := recover()
 268                         if r != nil {
 269                                 t.Errorf("non-nil recover during Goexit")
 270                         }
 271                         c <- struct{}{}
 272                 }()
 273                 runtime.Goexit()
 274         }()
 275         // Note: if the defer fails to run, we will get a deadlock here
 276         <-c
 277 }
 278
 279 func TestGoNil(t *testing.T) {
 280         output := runTestProg(t, "testprog", "GoNil")
 281         want := "go of nil func value"
 282         if !strings.Contains(output, want) {
 283                 t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
 284         }
 285 }
 286
 287 func TestMainGoroutineID(t *testing.T) {
 288         output := runTestProg(t, "testprog", "MainGoroutineID")
 289         want := "panic: test\n\ngoroutine 1 [running]:\n"
 290         if !strings.HasPrefix(output, want) {
 291                 t.Fatalf("output does not start with %q:\n%s", want, output)
 292         }
 293 }
 294
 295 func TestNoHelperGoroutines(t *testing.T) {
 296         output := runTestProg(t, "testprog", "NoHelperGoroutines")
 297         matches := regexp.MustCompile(`goroutine [0-9]+ \[`).FindAllStringSubmatch(output, -1)
 298         if len(matches) != 1 || matches[0][0] != "goroutine 1 [" {
 299                 t.Fatalf("want to see only goroutine 1, see:\n%s", output)
 300         }
 301 }
 302
 303 func TestBreakpoint(t *testing.T) {
 304         output := runTestProg(t, "testprog", "Breakpoint")
 305         want := "runtime.Breakpoint()"
 306         if !strings.Contains(output, want) {
 307                 t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
 308         }
 309 }
 310
 311 func TestGoexitInPanic(t *testing.T) {
 312         // see issue 8774: this code used to trigger an infinite recursion
 313         output := runTestProg(t, "testprog", "GoexitInPanic")
 314         want := "fatal error: no goroutines (main called runtime.Goexit) - deadlock!"
 315         if !strings.HasPrefix(output, want) {
 316                 t.Fatalf("output does not start with %q:\n%s", want, output)
 317         }
 318 }
 319
 320 // Issue 14965: Runtime panics should be of type runtime.Error
 321 func TestRuntimePanicWithRuntimeError(t *testing.T) {
 322         testCases := [...]func(){
 323                 0: func() {
 324                         var m map[uint64]bool
 325                         m[1234] = true
 326                 },
 327                 1: func() {
 328                         ch := make(chan struct{})
 329                         close(ch)
 330                         close(ch)
 331                 },
 332                 2: func() {
 333                         var ch = make(chan struct{})
 334                         close(ch)
 335                         ch <- struct{}{}
 336                 },
 337                 3: func() {
 338                         var s = make([]int, 2)
 339                         _ = s[2]
 340                 },
 341                 4: func() {
 342                         n := -1
 343                         _ = make(chan bool, n)
 344                 },
 345                 5: func() {
 346                         close((chan bool)(nil))
 347                 },
 348         }
 349
 350         for i, fn := range testCases {
 351                 got := panicValue(fn)
 352                 if _, ok := got.(runtime.Error); !ok {
 353                         t.Errorf("test #%d: recovered value %v(type %T) does not implement runtime.Error", i, got, got)
 354                 }
 355         }
 356 }
 357
 358 func panicValue(fn func()) (recovered interface{}) {
 359         defer func() {
 360                 recovered = recover()
 361         }()
 362         fn()
 363         return
 364 }
 365
 366 func TestPanicAfterGoexit(t *testing.T) {
 367         // an uncaught panic should still work after goexit
 368         output := runTestProg(t, "testprog", "PanicAfterGoexit")
 369         want := "panic: hello"
 370         if !strings.HasPrefix(output, want) {
 371                 t.Fatalf("output does not start with %q:\n%s", want, output)
 372         }
 373 }
 374
 375 func TestRecoveredPanicAfterGoexit(t *testing.T) {
 376         output := runTestProg(t, "testprog", "RecoveredPanicAfterGoexit")
 377         want := "fatal error: no goroutines (main called runtime.Goexit) - deadlock!"
 378         if !strings.HasPrefix(output, want) {
 379                 t.Fatalf("output does not start with %q:\n%s", want, output)
 380         }
 381 }
 382
 383 func TestRecoverBeforePanicAfterGoexit(t *testing.T) {
 384         // 1. defer a function that recovers
 385         // 2. defer a function that panics
 386         // 3. call goexit
 387         // Goexit should run the #2 defer. Its panic
 388         // should be caught by the #1 defer, and execution
 389         // should resume in the caller. Like the Goexit
 390         // never happened!
 391         defer func() {
 392                 r := recover()
 393                 if r == nil {
 394                         panic("bad recover")
 395                 }
 396         }()
 397         defer func() {
 398                 panic("hello")
 399         }()
 400         runtime.Goexit()
 401 }
 402
 403 func TestNetpollDeadlock(t *testing.T) {
 404         t.Parallel()
 405         output := runTestProg(t, "testprognet", "NetpollDeadlock")
 406         want := "done\n"
 407         if !strings.HasSuffix(output, want) {
 408                 t.Fatalf("output does not start with %q:\n%s", want, output)
 409         }
 410 }
 411
 412 func TestPanicTraceback(t *testing.T) {
 413         t.Parallel()
 414         output := runTestProg(t, "testprog", "PanicTraceback")
 415         want := "panic: hello"
 416         if !strings.HasPrefix(output, want) {
 417                 t.Fatalf("output does not start with %q:\n%s", want, output)
 418         }
 419
 420         // Check functions in the traceback.
 421         fns := []string{"main.pt1.func1", "panic", "main.pt2.func1", "panic", "main.pt2", "main.pt1"}
 422         for _, fn := range fns {
 423                 re := regexp.MustCompile(`(?m)^` + regexp.QuoteMeta(fn) + `\(.*\n`)
 424                 idx := re.FindStringIndex(output)
 425                 if idx == nil {
 426                         t.Fatalf("expected %q function in traceback:\n%s", fn, output)
 427                 }
 428                 output = output[idx[1]:]
 429         }
 430 }
 431
 432 func testPanicDeadlock(t *testing.T, name string, want string) {
 433         // test issue 14432
 434         output := runTestProg(t, "testprog", name)
 435         if !strings.HasPrefix(output, want) {
 436                 t.Fatalf("output does not start with %q:\n%s", want, output)
 437         }
 438 }
 439
 440 func TestPanicDeadlockGosched(t *testing.T) {
 441         testPanicDeadlock(t, "GoschedInPanic", "panic: errorThatGosched\n\n")
 442 }
 443
 444 func TestPanicDeadlockSyscall(t *testing.T) {
 445         testPanicDeadlock(t, "SyscallInPanic", "1\n2\npanic: 3\n\n")
 446 }
 447
 448 func TestPanicLoop(t *testing.T) {
 449         output := runTestProg(t, "testprog", "PanicLoop")
 450         if want := "panic while printing panic value"; !strings.Contains(output, want) {
 451                 t.Errorf("output does not contain %q:\n%s", want, output)
 452         }
 453 }
 454
 455 func TestMemPprof(t *testing.T) {
 456         testenv.MustHaveGoRun(t)
 457
 458         exe, err := buildTestProg(t, "testprog")
 459         if err != nil {
 460                 t.Fatal(err)
 461         }
 462
 463         got, err := testEnv(exec.Command(exe, "MemProf")).CombinedOutput()
 464         if err != nil {
 465                 t.Fatal(err)
 466         }
 467         fn := strings.TrimSpace(string(got))
 468         defer os.Remove(fn)
 469
 470         cmd := testEnv(exec.Command(testenv.GoToolPath(t), "tool", "pprof", "-alloc_space", "-top", exe, fn))
 471
 472         found := false
 473         for i, e := range cmd.Env {
 474                 if strings.HasPrefix(e, "PPROF_TMPDIR=") {
 475                         cmd.Env[i] = "PPROF_TMPDIR=" + os.TempDir()
 476                         found = true
 477                         break
 478                 }
 479         }
 480         if !found {
 481                 cmd.Env = append(cmd.Env, "PPROF_TMPDIR="+os.TempDir())
 482         }
 483
 484         top, err := cmd.CombinedOutput()
 485         t.Logf("%s", top)
 486         if err != nil {
 487                 t.Fatal(err)
 488         }
 489
 490         if !bytes.Contains(top, []byte("MemProf")) {
 491                 t.Error("missing MemProf in pprof output")
 492         }
 493 }
 494
 495 var concurrentMapTest = flag.Bool("run_concurrent_map_tests", false, "also run flaky concurrent map tests")
 496
 497 func TestConcurrentMapWrites(t *testing.T) {
 498         if !*concurrentMapTest {
 499                 t.Skip("skipping without -run_concurrent_map_tests")
 500         }
 501         testenv.MustHaveGoRun(t)
 502         output := runTestProg(t, "testprog", "concurrentMapWrites")
 503         want := "fatal error: concurrent map writes"
 504         if !strings.HasPrefix(output, want) {
 505                 t.Fatalf("output does not start with %q:\n%s", want, output)
 506         }
 507 }
 508 func TestConcurrentMapReadWrite(t *testing.T) {
 509         if !*concurrentMapTest {
 510                 t.Skip("skipping without -run_concurrent_map_tests")
 511         }
 512         testenv.MustHaveGoRun(t)
 513         output := runTestProg(t, "testprog", "concurrentMapReadWrite")
 514         want := "fatal error: concurrent map read and map write"
 515         if !strings.HasPrefix(output, want) {
 516                 t.Fatalf("output does not start with %q:\n%s", want, output)
 517         }
 518 }
 519 func TestConcurrentMapIterateWrite(t *testing.T) {
 520         if !*concurrentMapTest {
 521                 t.Skip("skipping without -run_concurrent_map_tests")
 522         }
 523         testenv.MustHaveGoRun(t)
 524         output := runTestProg(t, "testprog", "concurrentMapIterateWrite")
 525         want := "fatal error: concurrent map iteration and map write"
 526         if !strings.HasPrefix(output, want) {
 527                 t.Fatalf("output does not start with %q:\n%s", want, output)
 528         }
 529 }