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 } 530