src/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         "os"
  13         "os/exec"
  14         "path/filepath"
  15         "regexp"
  16         "runtime"
  17         "strconv"
  18         "strings"
  19         "sync"
  20         "testing"
  21         "time"
  22 )
  23
  24 var toRemove []string
  25
  26 func TestMain(m *testing.M) {
  27         status := m.Run()
  28         for _, file := range toRemove {
  29                 os.RemoveAll(file)
  30         }
  31         os.Exit(status)
  32 }
  33
  34 var testprog struct {
  35         sync.Mutex
  36         dir    string
  37         target map[string]buildexe
  38 }
  39
  40 type buildexe struct {
  41         exe string
  42         err error
  43 }
  44
  45 func runTestProg(t *testing.T, binary, name string, env ...string) string {
  46         if *flagQuick {
  47                 t.Skip("-quick")
  48         }
  49
  50         testenv.MustHaveGoBuild(t)
  51
  52         exe, err := buildTestProg(t, binary)
  53         if err != nil {
  54                 t.Fatal(err)
  55         }
  56
  57         return runBuiltTestProg(t, exe, name, env...)
  58 }
  59
  60 func runBuiltTestProg(t *testing.T, exe, name string, env ...string) string {
  61         if *flagQuick {
  62                 t.Skip("-quick")
  63         }
  64
  65         testenv.MustHaveGoBuild(t)
  66
  67         cmd := testenv.CleanCmdEnv(exec.Command(exe, name))
  68         cmd.Env = append(cmd.Env, env...)
  69         if testing.Short() {
  70                 cmd.Env = append(cmd.Env, "RUNTIME_TEST_SHORT=1")
  71         }
  72         var b bytes.Buffer
  73         cmd.Stdout = &b
  74         cmd.Stderr = &b
  75         if err := cmd.Start(); err != nil {
  76                 t.Fatalf("starting %s %s: %v", exe, name, err)
  77         }
  78
  79         // If the process doesn't complete within 1 minute,
  80         // assume it is hanging and kill it to get a stack trace.
  81         p := cmd.Process
  82         done := make(chan bool)
  83         go func() {
  84                 scale := 1
  85                 // This GOARCH/GOOS test is copied from cmd/dist/test.go.
  86                 // TODO(iant): Have cmd/dist update the environment variable.
  87                 if runtime.GOARCH == "arm" || runtime.GOOS == "windows" {
  88                         scale = 2
  89                 }
  90                 if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" {
  91                         if sc, err := strconv.Atoi(s); err == nil {
  92                                 scale = sc
  93                         }
  94                 }
  95
  96                 select {
  97                 case <-done:
  98                 case <-time.After(time.Duration(scale) * time.Minute):
  99                         p.Signal(sigquit)
 100                 }
 101         }()
 102
 103         if err := cmd.Wait(); err != nil {
 104                 t.Logf("%s %s exit status: %v", exe, name, err)
 105         }
 106         close(done)
 107
 108         return b.String()
 109 }
 110
 111 func buildTestProg(t *testing.T, binary string, flags ...string) (string, error) {
 112         if *flagQuick {
 113                 t.Skip("-quick")
 114         }
 115
 116         testprog.Lock()
 117         defer testprog.Unlock()
 118         if testprog.dir == "" {
 119                 dir, err := os.MkdirTemp("", "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.CleanCmdEnv(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 func TestVDSO(t *testing.T) {
 154         t.Parallel()
 155         output := runTestProg(t, "testprog", "SignalInVDSO")
 156         want := "success\n"
 157         if output != want {
 158                 t.Fatalf("output:\n%s\n\nwanted:\n%s", output, want)
 159         }
 160 }
 161
 162 func testCrashHandler(t *testing.T, cgo bool) {
 163         type crashTest struct {
 164                 Cgo bool
 165         }
 166         var output string
 167         if cgo {
 168                 output = runTestProg(t, "testprogcgo", "Crash")
 169         } else {
 170                 output = runTestProg(t, "testprog", "Crash")
 171         }
 172         want := "main: recovered done\nnew-thread: recovered done\nsecond-new-thread: recovered done\nmain-again: recovered done\n"
 173         if output != want {
 174                 t.Fatalf("output:\n%s\n\nwanted:\n%s", output, want)
 175         }
 176 }
 177
 178 func TestCrashHandler(t *testing.T) {
 179         testCrashHandler(t, false)
 180 }
 181
 182 func testDeadlock(t *testing.T, name string) {
 183         // External linking brings in cgo, causing deadlock detection not working.
 184         testenv.MustInternalLink(t)
 185
 186         output := runTestProg(t, "testprog", name)
 187         want := "fatal error: all goroutines are asleep - deadlock!\n"
 188         if !strings.HasPrefix(output, want) {
 189                 t.Fatalf("output does not start with %q:\n%s", want, output)
 190         }
 191 }
 192
 193 func TestSimpleDeadlock(t *testing.T) {
 194         testDeadlock(t, "SimpleDeadlock")
 195 }
 196
 197 func TestInitDeadlock(t *testing.T) {
 198         testDeadlock(t, "InitDeadlock")
 199 }
 200
 201 func TestLockedDeadlock(t *testing.T) {
 202         testDeadlock(t, "LockedDeadlock")
 203 }
 204
 205 func TestLockedDeadlock2(t *testing.T) {
 206         testDeadlock(t, "LockedDeadlock2")
 207 }
 208
 209 func TestGoexitDeadlock(t *testing.T) {
 210         // External linking brings in cgo, causing deadlock detection not working.
 211         testenv.MustInternalLink(t)
 212
 213         output := runTestProg(t, "testprog", "GoexitDeadlock")
 214         want := "no goroutines (main called runtime.Goexit) - deadlock!"
 215         if !strings.Contains(output, want) {
 216                 t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
 217         }
 218 }
 219
 220 func TestStackOverflow(t *testing.T) {
 221         output := runTestProg(t, "testprog", "StackOverflow")
 222         want := []string{
 223                 "runtime: goroutine stack exceeds 1474560-byte limit\n",
 224                 "fatal error: stack overflow",
 225                 // information about the current SP and stack bounds
 226                 "runtime: sp=",
 227                 "stack=[",
 228         }
 229         if !strings.HasPrefix(output, want[0]) {
 230                 t.Errorf("output does not start with %q", want[0])
 231         }
 232         for _, s := range want[1:] {
 233                 if !strings.Contains(output, s) {
 234                         t.Errorf("output does not contain %q", s)
 235                 }
 236         }
 237         if t.Failed() {
 238                 t.Logf("output:\n%s", output)
 239         }
 240 }
 241
 242 func TestThreadExhaustion(t *testing.T) {
 243         output := runTestProg(t, "testprog", "ThreadExhaustion")
 244         want := "runtime: program exceeds 10-thread limit\nfatal error: thread exhaustion"
 245         if !strings.HasPrefix(output, want) {
 246                 t.Fatalf("output does not start with %q:\n%s", want, output)
 247         }
 248 }
 249
 250 func TestRecursivePanic(t *testing.T) {
 251         output := runTestProg(t, "testprog", "RecursivePanic")
 252         want := `wrap: bad
 253 panic: again
 254
 255 `
 256         if !strings.HasPrefix(output, want) {
 257                 t.Fatalf("output does not start with %q:\n%s", want, output)
 258         }
 259
 260 }
 261
 262 func TestRecursivePanic2(t *testing.T) {
 263         output := runTestProg(t, "testprog", "RecursivePanic2")
 264         want := `first panic
 265 second panic
 266 panic: third panic
 267
 268 `
 269         if !strings.HasPrefix(output, want) {
 270                 t.Fatalf("output does not start with %q:\n%s", want, output)
 271         }
 272
 273 }
 274
 275 func TestRecursivePanic3(t *testing.T) {
 276         output := runTestProg(t, "testprog", "RecursivePanic3")
 277         want := `panic: first panic
 278
 279 `
 280         if !strings.HasPrefix(output, want) {
 281                 t.Fatalf("output does not start with %q:\n%s", want, output)
 282         }
 283
 284 }
 285
 286 func TestRecursivePanic4(t *testing.T) {
 287         output := runTestProg(t, "testprog", "RecursivePanic4")
 288         want := `panic: first panic [recovered]
 289         panic: second panic
 290 `
 291         if !strings.HasPrefix(output, want) {
 292                 t.Fatalf("output does not start with %q:\n%s", want, output)
 293         }
 294
 295 }
 296
 297 func TestRecursivePanic5(t *testing.T) {
 298         output := runTestProg(t, "testprog", "RecursivePanic5")
 299         want := `first panic
 300 second panic
 301 panic: third panic
 302 `
 303         if !strings.HasPrefix(output, want) {
 304                 t.Fatalf("output does not start with %q:\n%s", want, output)
 305         }
 306
 307 }
 308
 309 func TestGoexitCrash(t *testing.T) {
 310         // External linking brings in cgo, causing deadlock detection not working.
 311         testenv.MustInternalLink(t)
 312
 313         output := runTestProg(t, "testprog", "GoexitExit")
 314         want := "no goroutines (main called runtime.Goexit) - deadlock!"
 315         if !strings.Contains(output, want) {
 316                 t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
 317         }
 318 }
 319
 320 func TestGoexitDefer(t *testing.T) {
 321         c := make(chan struct{})
 322         go func() {
 323                 defer func() {
 324                         r := recover()
 325                         if r != nil {
 326                                 t.Errorf("non-nil recover during Goexit")
 327                         }
 328                         c <- struct{}{}
 329                 }()
 330                 runtime.Goexit()
 331         }()
 332         // Note: if the defer fails to run, we will get a deadlock here
 333         <-c
 334 }
 335
 336 func TestGoNil(t *testing.T) {
 337         output := runTestProg(t, "testprog", "GoNil")
 338         want := "go of nil func value"
 339         if !strings.Contains(output, want) {
 340                 t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
 341         }
 342 }
 343
 344 func TestMainGoroutineID(t *testing.T) {
 345         output := runTestProg(t, "testprog", "MainGoroutineID")
 346         want := "panic: test\n\ngoroutine 1 [running]:\n"
 347         if !strings.HasPrefix(output, want) {
 348                 t.Fatalf("output does not start with %q:\n%s", want, output)
 349         }
 350 }
 351
 352 func TestNoHelperGoroutines(t *testing.T) {
 353         output := runTestProg(t, "testprog", "NoHelperGoroutines")
 354         matches := regexp.MustCompile(`goroutine [0-9]+ \[`).FindAllStringSubmatch(output, -1)
 355         if len(matches) != 1 || matches[0][0] != "goroutine 1 [" {
 356                 t.Fatalf("want to see only goroutine 1, see:\n%s", output)
 357         }
 358 }
 359
 360 func TestBreakpoint(t *testing.T) {
 361         output := runTestProg(t, "testprog", "Breakpoint")
 362         // If runtime.Breakpoint() is inlined, then the stack trace prints
 363         // "runtime.Breakpoint(...)" instead of "runtime.Breakpoint()".
 364         want := "runtime.Breakpoint("
 365         if !strings.Contains(output, want) {
 366                 t.Fatalf("output:\n%s\n\nwant output containing: %s", output, want)
 367         }
 368 }
 369
 370 func TestGoexitInPanic(t *testing.T) {
 371         // External linking brings in cgo, causing deadlock detection not working.
 372         testenv.MustInternalLink(t)
 373
 374         // see issue 8774: this code used to trigger an infinite recursion
 375         output := runTestProg(t, "testprog", "GoexitInPanic")
 376         want := "fatal error: no goroutines (main called runtime.Goexit) - deadlock!"
 377         if !strings.HasPrefix(output, want) {
 378                 t.Fatalf("output does not start with %q:\n%s", want, output)
 379         }
 380 }
 381
 382 // Issue 14965: Runtime panics should be of type runtime.Error
 383 func TestRuntimePanicWithRuntimeError(t *testing.T) {
 384         testCases := [...]func(){
 385                 0: func() {
 386                         var m map[uint64]bool
 387                         m[1234] = true
 388                 },
 389                 1: func() {
 390                         ch := make(chan struct{})
 391                         close(ch)
 392                         close(ch)
 393                 },
 394                 2: func() {
 395                         var ch = make(chan struct{})
 396                         close(ch)
 397                         ch <- struct{}{}
 398                 },
 399                 3: func() {
 400                         var s = make([]int, 2)
 401                         _ = s[2]
 402                 },
 403                 4: func() {
 404                         n := -1
 405                         _ = make(chan bool, n)
 406                 },
 407                 5: func() {
 408                         close((chan bool)(nil))
 409                 },
 410         }
 411
 412         for i, fn := range testCases {
 413                 got := panicValue(fn)
 414                 if _, ok := got.(runtime.Error); !ok {
 415                         t.Errorf("test #%d: recovered value %v(type %T) does not implement runtime.Error", i, got, got)
 416                 }
 417         }
 418 }
 419
 420 func panicValue(fn func()) (recovered interface{}) {
 421         defer func() {
 422                 recovered = recover()
 423         }()
 424         fn()
 425         return
 426 }
 427
 428 func TestPanicAfterGoexit(t *testing.T) {
 429         // an uncaught panic should still work after goexit
 430         output := runTestProg(t, "testprog", "PanicAfterGoexit")
 431         want := "panic: hello"
 432         if !strings.HasPrefix(output, want) {
 433                 t.Fatalf("output does not start with %q:\n%s", want, output)
 434         }
 435 }
 436
 437 func TestRecoveredPanicAfterGoexit(t *testing.T) {
 438         // External linking brings in cgo, causing deadlock detection not working.
 439         testenv.MustInternalLink(t)
 440
 441         output := runTestProg(t, "testprog", "RecoveredPanicAfterGoexit")
 442         want := "fatal error: no goroutines (main called runtime.Goexit) - deadlock!"
 443         if !strings.HasPrefix(output, want) {
 444                 t.Fatalf("output does not start with %q:\n%s", want, output)
 445         }
 446 }
 447
 448 func TestRecoverBeforePanicAfterGoexit(t *testing.T) {
 449         // External linking brings in cgo, causing deadlock detection not working.
 450         testenv.MustInternalLink(t)
 451
 452         t.Parallel()
 453         output := runTestProg(t, "testprog", "RecoverBeforePanicAfterGoexit")
 454         want := "fatal error: no goroutines (main called runtime.Goexit) - deadlock!"
 455         if !strings.HasPrefix(output, want) {
 456                 t.Fatalf("output does not start with %q:\n%s", want, output)
 457         }
 458 }
 459
 460 func TestRecoverBeforePanicAfterGoexit2(t *testing.T) {
 461         // External linking brings in cgo, causing deadlock detection not working.
 462         testenv.MustInternalLink(t)
 463
 464         t.Parallel()
 465         output := runTestProg(t, "testprog", "RecoverBeforePanicAfterGoexit2")
 466         want := "fatal error: no goroutines (main called runtime.Goexit) - deadlock!"
 467         if !strings.HasPrefix(output, want) {
 468                 t.Fatalf("output does not start with %q:\n%s", want, output)
 469         }
 470 }
 471
 472 func TestNetpollDeadlock(t *testing.T) {
 473         if os.Getenv("GO_BUILDER_NAME") == "darwin-amd64-10_12" {
 474                 // A suspected kernel bug in macOS 10.12 occasionally results in
 475                 // an apparent deadlock when dialing localhost. The errors have not
 476                 // been observed on newer versions of the OS, so we don't plan to work
 477                 // around them. See https://golang.org/issue/22019.
 478                 testenv.SkipFlaky(t, 22019)
 479         }
 480
 481         t.Parallel()
 482         output := runTestProg(t, "testprognet", "NetpollDeadlock")
 483         want := "done\n"
 484         if !strings.HasSuffix(output, want) {
 485                 t.Fatalf("output does not start with %q:\n%s", want, output)
 486         }
 487 }
 488
 489 func TestPanicTraceback(t *testing.T) {
 490         t.Parallel()
 491         output := runTestProg(t, "testprog", "PanicTraceback")
 492         want := "panic: hello\n\tpanic: panic pt2\n\tpanic: panic pt1\n"
 493         if !strings.HasPrefix(output, want) {
 494                 t.Fatalf("output does not start with %q:\n%s", want, output)
 495         }
 496
 497         // Check functions in the traceback.
 498         fns := []string{"main.pt1.func1", "panic", "main.pt2.func1", "panic", "main.pt2", "main.pt1"}
 499         for _, fn := range fns {
 500                 re := regexp.MustCompile(`(?m)^` + regexp.QuoteMeta(fn) + `\(.*\n`)
 501                 idx := re.FindStringIndex(output)
 502                 if idx == nil {
 503                         t.Fatalf("expected %q function in traceback:\n%s", fn, output)
 504                 }
 505                 output = output[idx[1]:]
 506         }
 507 }
 508
 509 func testPanicDeadlock(t *testing.T, name string, want string) {
 510         // test issue 14432
 511         output := runTestProg(t, "testprog", name)
 512         if !strings.HasPrefix(output, want) {
 513                 t.Fatalf("output does not start with %q:\n%s", want, output)
 514         }
 515 }
 516
 517 func TestPanicDeadlockGosched(t *testing.T) {
 518         testPanicDeadlock(t, "GoschedInPanic", "panic: errorThatGosched\n\n")
 519 }
 520
 521 func TestPanicDeadlockSyscall(t *testing.T) {
 522         testPanicDeadlock(t, "SyscallInPanic", "1\n2\npanic: 3\n\n")
 523 }
 524
 525 func TestPanicLoop(t *testing.T) {
 526         output := runTestProg(t, "testprog", "PanicLoop")
 527         if want := "panic while printing panic value"; !strings.Contains(output, want) {
 528                 t.Errorf("output does not contain %q:\n%s", want, output)
 529         }
 530 }
 531
 532 func TestMemPprof(t *testing.T) {
 533         testenv.MustHaveGoRun(t)
 534
 535         exe, err := buildTestProg(t, "testprog")
 536         if err != nil {
 537                 t.Fatal(err)
 538         }
 539
 540         got, err := testenv.CleanCmdEnv(exec.Command(exe, "MemProf")).CombinedOutput()
 541         if err != nil {
 542                 t.Fatal(err)
 543         }
 544         fn := strings.TrimSpace(string(got))
 545         defer os.Remove(fn)
 546
 547         for try := 0; try < 2; try++ {
 548                 cmd := testenv.CleanCmdEnv(exec.Command(testenv.GoToolPath(t), "tool", "pprof", "-alloc_space", "-top"))
 549                 // Check that pprof works both with and without explicit executable on command line.
 550                 if try == 0 {
 551                         cmd.Args = append(cmd.Args, exe, fn)
 552                 } else {
 553                         cmd.Args = append(cmd.Args, fn)
 554                 }
 555                 found := false
 556                 for i, e := range cmd.Env {
 557                         if strings.HasPrefix(e, "PPROF_TMPDIR=") {
 558                                 cmd.Env[i] = "PPROF_TMPDIR=" + os.TempDir()
 559                                 found = true
 560                                 break
 561                         }
 562                 }
 563                 if !found {
 564                         cmd.Env = append(cmd.Env, "PPROF_TMPDIR="+os.TempDir())
 565                 }
 566
 567                 top, err := cmd.CombinedOutput()
 568                 t.Logf("%s:\n%s", cmd.Args, top)
 569                 if err != nil {
 570                         t.Error(err)
 571                 } else if !bytes.Contains(top, []byte("MemProf")) {
 572                         t.Error("missing MemProf in pprof output")
 573                 }
 574         }
 575 }
 576
 577 var concurrentMapTest = flag.Bool("run_concurrent_map_tests", false, "also run flaky concurrent map tests")
 578
 579 func TestConcurrentMapWrites(t *testing.T) {
 580         if !*concurrentMapTest {
 581                 t.Skip("skipping without -run_concurrent_map_tests")
 582         }
 583         testenv.MustHaveGoRun(t)
 584         output := runTestProg(t, "testprog", "concurrentMapWrites")
 585         want := "fatal error: concurrent map writes"
 586         if !strings.HasPrefix(output, want) {
 587                 t.Fatalf("output does not start with %q:\n%s", want, output)
 588         }
 589 }
 590 func TestConcurrentMapReadWrite(t *testing.T) {
 591         if !*concurrentMapTest {
 592                 t.Skip("skipping without -run_concurrent_map_tests")
 593         }
 594         testenv.MustHaveGoRun(t)
 595         output := runTestProg(t, "testprog", "concurrentMapReadWrite")
 596         want := "fatal error: concurrent map read and map write"
 597         if !strings.HasPrefix(output, want) {
 598                 t.Fatalf("output does not start with %q:\n%s", want, output)
 599         }
 600 }
 601 func TestConcurrentMapIterateWrite(t *testing.T) {
 602         if !*concurrentMapTest {
 603                 t.Skip("skipping without -run_concurrent_map_tests")
 604         }
 605         testenv.MustHaveGoRun(t)
 606         output := runTestProg(t, "testprog", "concurrentMapIterateWrite")
 607         want := "fatal error: concurrent map iteration and map write"
 608         if !strings.HasPrefix(output, want) {
 609                 t.Fatalf("output does not start with %q:\n%s", want, output)
 610         }
 611 }
 612
 613 type point struct {
 614         x, y *int
 615 }
 616
 617 func (p *point) negate() {
 618         *p.x = *p.x * -1
 619         *p.y = *p.y * -1
 620 }
 621
 622 // Test for issue #10152.
 623 func TestPanicInlined(t *testing.T) {
 624         defer func() {
 625                 r := recover()
 626                 if r == nil {
 627                         t.Fatalf("recover failed")
 628                 }
 629                 buf := make([]byte, 2048)
 630                 n := runtime.Stack(buf, false)
 631                 buf = buf[:n]
 632                 if !bytes.Contains(buf, []byte("(*point).negate(")) {
 633                         t.Fatalf("expecting stack trace to contain call to (*point).negate()")
 634                 }
 635         }()
 636
 637         pt := new(point)
 638         pt.negate()
 639 }
 640
 641 // Test for issues #3934 and #20018.
 642 // We want to delay exiting until a panic print is complete.
 643 func TestPanicRace(t *testing.T) {
 644         testenv.MustHaveGoRun(t)
 645
 646         exe, err := buildTestProg(t, "testprog")
 647         if err != nil {
 648                 t.Fatal(err)
 649         }
 650
 651         // The test is intentionally racy, and in my testing does not
 652         // produce the expected output about 0.05% of the time.
 653         // So run the program in a loop and only fail the test if we
 654         // get the wrong output ten times in a row.
 655         const tries = 10
 656 retry:
 657         for i := 0; i < tries; i++ {
 658                 got, err := testenv.CleanCmdEnv(exec.Command(exe, "PanicRace")).CombinedOutput()
 659                 if err == nil {
 660                         t.Logf("try %d: program exited successfully, should have failed", i+1)
 661                         continue
 662                 }
 663
 664                 if i > 0 {
 665                         t.Logf("try %d:\n", i+1)
 666                 }
 667                 t.Logf("%s\n", got)
 668
 669                 wants := []string{
 670                         "panic: crash",
 671                         "PanicRace",
 672                         "created by ",
 673                 }
 674                 for _, want := range wants {
 675                         if !bytes.Contains(got, []byte(want)) {
 676                                 t.Logf("did not find expected string %q", want)
 677                                 continue retry
 678                         }
 679                 }
 680
 681                 // Test generated expected output.
 682                 return
 683         }
 684         t.Errorf("test ran %d times without producing expected output", tries)
 685 }
 686
 687 func TestBadTraceback(t *testing.T) {
 688         output := runTestProg(t, "testprog", "BadTraceback")
 689         for _, want := range []string{
 690                 "runtime: unexpected return pc",
 691                 "called from 0xbad",
 692                 "00000bad",    // Smashed LR in hex dump
 693                 "<main.badLR", // Symbolization in hex dump (badLR1 or badLR2)
 694         } {
 695                 if !strings.Contains(output, want) {
 696                         t.Errorf("output does not contain %q:\n%s", want, output)
 697                 }
 698         }
 699 }
 700
 701 func TestTimePprof(t *testing.T) {
 702         // Pass GOTRACEBACK for issue #41120 to try to get more
 703         // information on timeout.
 704         fn := runTestProg(t, "testprog", "TimeProf", "GOTRACEBACK=crash")
 705         fn = strings.TrimSpace(fn)
 706         defer os.Remove(fn)
 707
 708         cmd := testenv.CleanCmdEnv(exec.Command(testenv.GoToolPath(t), "tool", "pprof", "-top", "-nodecount=1", fn))
 709         cmd.Env = append(cmd.Env, "PPROF_TMPDIR="+os.TempDir())
 710         top, err := cmd.CombinedOutput()
 711         t.Logf("%s", top)
 712         if err != nil {
 713                 t.Error(err)
 714         } else if bytes.Contains(top, []byte("ExternalCode")) {
 715                 t.Error("profiler refers to ExternalCode")
 716         }
 717 }
 718
 719 // Test that runtime.abort does so.
 720 func TestAbort(t *testing.T) {
 721         // Pass GOTRACEBACK to ensure we get runtime frames.
 722         output := runTestProg(t, "testprog", "Abort", "GOTRACEBACK=system")
 723         if want := "runtime.abort"; !strings.Contains(output, want) {
 724                 t.Errorf("output does not contain %q:\n%s", want, output)
 725         }
 726         if strings.Contains(output, "BAD") {
 727                 t.Errorf("output contains BAD:\n%s", output)
 728         }
 729         // Check that it's a signal traceback.
 730         want := "PC="
 731         // For systems that use a breakpoint, check specifically for that.
 732         switch runtime.GOARCH {
 733         case "386", "amd64":
 734                 switch runtime.GOOS {
 735                 case "plan9":
 736                         want = "sys: breakpoint"
 737                 case "windows":
 738                         want = "Exception 0x80000003"
 739                 default:
 740                         want = "SIGTRAP"
 741                 }
 742         }
 743         if !strings.Contains(output, want) {
 744                 t.Errorf("output does not contain %q:\n%s", want, output)
 745         }
 746 }
 747
 748 // For TestRuntimePanic: test a panic in the runtime package without
 749 // involving the testing harness.
 750 func init() {
 751         if os.Getenv("GO_TEST_RUNTIME_PANIC") == "1" {
 752                 defer func() {
 753                         if r := recover(); r != nil {
 754                                 // We expect to crash, so exit 0
 755                                 // to indicate failure.
 756                                 os.Exit(0)
 757                         }
 758                 }()
 759                 runtime.PanicForTesting(nil, 1)
 760                 // We expect to crash, so exit 0 to indicate failure.
 761                 os.Exit(0)
 762         }
 763 }
 764
 765 func TestRuntimePanic(t *testing.T) {
 766         testenv.MustHaveExec(t)
 767         cmd := testenv.CleanCmdEnv(exec.Command(os.Args[0], "-test.run=TestRuntimePanic"))
 768         cmd.Env = append(cmd.Env, "GO_TEST_RUNTIME_PANIC=1")
 769         out, err := cmd.CombinedOutput()
 770         t.Logf("%s", out)
 771         if err == nil {
 772                 t.Error("child process did not fail")
 773         } else if want := "runtime.unexportedPanicForTesting"; !bytes.Contains(out, []byte(want)) {
 774                 t.Errorf("output did not contain expected string %q", want)
 775         }
 776 }
 777
 778 // Test that g0 stack overflows are handled gracefully.
 779 func TestG0StackOverflow(t *testing.T) {
 780         testenv.MustHaveExec(t)
 781
 782         switch runtime.GOOS {
 783         case "darwin", "dragonfly", "freebsd", "linux", "netbsd", "openbsd", "android":
 784                 t.Skipf("g0 stack is wrong on pthread platforms (see golang.org/issue/26061)")
 785         }
 786
 787         if os.Getenv("TEST_G0_STACK_OVERFLOW") != "1" {
 788                 cmd := testenv.CleanCmdEnv(exec.Command(os.Args[0], "-test.run=TestG0StackOverflow", "-test.v"))
 789                 cmd.Env = append(cmd.Env, "TEST_G0_STACK_OVERFLOW=1")
 790                 out, err := cmd.CombinedOutput()
 791                 // Don't check err since it's expected to crash.
 792                 if n := strings.Count(string(out), "morestack on g0\n"); n != 1 {
 793                         t.Fatalf("%s\n(exit status %v)", out, err)
 794                 }
 795                 // Check that it's a signal-style traceback.
 796                 if runtime.GOOS != "windows" {
 797                         if want := "PC="; !strings.Contains(string(out), want) {
 798                                 t.Errorf("output does not contain %q:\n%s", want, out)
 799                         }
 800                 }
 801                 return
 802         }
 803
 804         runtime.G0StackOverflow()
 805 }
 806
 807 // Test that panic message is not clobbered.
 808 // See issue 30150.
 809 func TestDoublePanic(t *testing.T) {
 810         output := runTestProg(t, "testprog", "DoublePanic", "GODEBUG=clobberfree=1")
 811         wants := []string{"panic: XXX", "panic: YYY"}
 812         for _, want := range wants {
 813                 if !strings.Contains(output, want) {
 814                         t.Errorf("output:\n%s\n\nwant output containing: %s", output, want)
 815                 }
 816         }
 817 }