Source file src/runtime/crash_cgo_test.go

Documentation: runtime

		 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  //go:build cgo
		 6  // +build cgo
		 7  
		 8  package runtime_test
		 9  
		10  import (
		11  	"bytes"
		12  	"fmt"
		13  	"internal/testenv"
		14  	"os"
		15  	"os/exec"
		16  	"runtime"
		17  	"strconv"
		18  	"strings"
		19  	"testing"
		20  	"time"
		21  )
		22  
		23  func TestCgoCrashHandler(t *testing.T) {
		24  	t.Parallel()
		25  	testCrashHandler(t, true)
		26  }
		27  
		28  func TestCgoSignalDeadlock(t *testing.T) {
		29  	// Don't call t.Parallel, since too much work going on at the
		30  	// same time can cause the testprogcgo code to overrun its
		31  	// timeouts (issue #18598).
		32  
		33  	if testing.Short() && runtime.GOOS == "windows" {
		34  		t.Skip("Skipping in short mode") // takes up to 64 seconds
		35  	}
		36  	got := runTestProg(t, "testprogcgo", "CgoSignalDeadlock")
		37  	want := "OK\n"
		38  	if got != want {
		39  		t.Fatalf("expected %q, but got:\n%s", want, got)
		40  	}
		41  }
		42  
		43  func TestCgoTraceback(t *testing.T) {
		44  	t.Parallel()
		45  	got := runTestProg(t, "testprogcgo", "CgoTraceback")
		46  	want := "OK\n"
		47  	if got != want {
		48  		t.Fatalf("expected %q, but got:\n%s", want, got)
		49  	}
		50  }
		51  
		52  func TestCgoCallbackGC(t *testing.T) {
		53  	t.Parallel()
		54  	switch runtime.GOOS {
		55  	case "plan9", "windows":
		56  		t.Skipf("no pthreads on %s", runtime.GOOS)
		57  	}
		58  	if testing.Short() {
		59  		switch {
		60  		case runtime.GOOS == "dragonfly":
		61  			t.Skip("see golang.org/issue/11990")
		62  		case runtime.GOOS == "linux" && runtime.GOARCH == "arm":
		63  			t.Skip("too slow for arm builders")
		64  		case runtime.GOOS == "linux" && (runtime.GOARCH == "mips64" || runtime.GOARCH == "mips64le"):
		65  			t.Skip("too slow for mips64x builders")
		66  		}
		67  	}
		68  	got := runTestProg(t, "testprogcgo", "CgoCallbackGC")
		69  	want := "OK\n"
		70  	if got != want {
		71  		t.Fatalf("expected %q, but got:\n%s", want, got)
		72  	}
		73  }
		74  
		75  func TestCgoExternalThreadPanic(t *testing.T) {
		76  	t.Parallel()
		77  	if runtime.GOOS == "plan9" {
		78  		t.Skipf("no pthreads on %s", runtime.GOOS)
		79  	}
		80  	got := runTestProg(t, "testprogcgo", "CgoExternalThreadPanic")
		81  	want := "panic: BOOM"
		82  	if !strings.Contains(got, want) {
		83  		t.Fatalf("want failure containing %q. output:\n%s\n", want, got)
		84  	}
		85  }
		86  
		87  func TestCgoExternalThreadSIGPROF(t *testing.T) {
		88  	t.Parallel()
		89  	// issue 9456.
		90  	switch runtime.GOOS {
		91  	case "plan9", "windows":
		92  		t.Skipf("no pthreads on %s", runtime.GOOS)
		93  	}
		94  	if runtime.GOARCH == "ppc64" && runtime.GOOS == "linux" {
		95  		// TODO(austin) External linking not implemented on
		96  		// linux/ppc64 (issue #8912)
		97  		t.Skipf("no external linking on ppc64")
		98  	}
		99  
	 100  	exe, err := buildTestProg(t, "testprogcgo", "-tags=threadprof")
	 101  	if err != nil {
	 102  		t.Fatal(err)
	 103  	}
	 104  
	 105  	got, err := testenv.CleanCmdEnv(exec.Command(exe, "CgoExternalThreadSIGPROF")).CombinedOutput()
	 106  	if err != nil {
	 107  		t.Fatalf("exit status: %v\n%s", err, got)
	 108  	}
	 109  
	 110  	if want := "OK\n"; string(got) != want {
	 111  		t.Fatalf("expected %q, but got:\n%s", want, got)
	 112  	}
	 113  }
	 114  
	 115  func TestCgoExternalThreadSignal(t *testing.T) {
	 116  	t.Parallel()
	 117  	// issue 10139
	 118  	switch runtime.GOOS {
	 119  	case "plan9", "windows":
	 120  		t.Skipf("no pthreads on %s", runtime.GOOS)
	 121  	}
	 122  
	 123  	exe, err := buildTestProg(t, "testprogcgo", "-tags=threadprof")
	 124  	if err != nil {
	 125  		t.Fatal(err)
	 126  	}
	 127  
	 128  	got, err := testenv.CleanCmdEnv(exec.Command(exe, "CgoExternalThreadSIGPROF")).CombinedOutput()
	 129  	if err != nil {
	 130  		t.Fatalf("exit status: %v\n%s", err, got)
	 131  	}
	 132  
	 133  	want := []byte("OK\n")
	 134  	if !bytes.Equal(got, want) {
	 135  		t.Fatalf("expected %q, but got:\n%s", want, got)
	 136  	}
	 137  }
	 138  
	 139  func TestCgoDLLImports(t *testing.T) {
	 140  	// test issue 9356
	 141  	if runtime.GOOS != "windows" {
	 142  		t.Skip("skipping windows specific test")
	 143  	}
	 144  	got := runTestProg(t, "testprogcgo", "CgoDLLImportsMain")
	 145  	want := "OK\n"
	 146  	if got != want {
	 147  		t.Fatalf("expected %q, but got %v", want, got)
	 148  	}
	 149  }
	 150  
	 151  func TestCgoExecSignalMask(t *testing.T) {
	 152  	t.Parallel()
	 153  	// Test issue 13164.
	 154  	switch runtime.GOOS {
	 155  	case "windows", "plan9":
	 156  		t.Skipf("skipping signal mask test on %s", runtime.GOOS)
	 157  	}
	 158  	got := runTestProg(t, "testprogcgo", "CgoExecSignalMask", "GOTRACEBACK=system")
	 159  	want := "OK\n"
	 160  	if got != want {
	 161  		t.Errorf("expected %q, got %v", want, got)
	 162  	}
	 163  }
	 164  
	 165  func TestEnsureDropM(t *testing.T) {
	 166  	t.Parallel()
	 167  	// Test for issue 13881.
	 168  	switch runtime.GOOS {
	 169  	case "windows", "plan9":
	 170  		t.Skipf("skipping dropm test on %s", runtime.GOOS)
	 171  	}
	 172  	got := runTestProg(t, "testprogcgo", "EnsureDropM")
	 173  	want := "OK\n"
	 174  	if got != want {
	 175  		t.Errorf("expected %q, got %v", want, got)
	 176  	}
	 177  }
	 178  
	 179  // Test for issue 14387.
	 180  // Test that the program that doesn't need any cgo pointer checking
	 181  // takes about the same amount of time with it as without it.
	 182  func TestCgoCheckBytes(t *testing.T) {
	 183  	t.Parallel()
	 184  	// Make sure we don't count the build time as part of the run time.
	 185  	testenv.MustHaveGoBuild(t)
	 186  	exe, err := buildTestProg(t, "testprogcgo")
	 187  	if err != nil {
	 188  		t.Fatal(err)
	 189  	}
	 190  
	 191  	// Try it 10 times to avoid flakiness.
	 192  	const tries = 10
	 193  	var tot1, tot2 time.Duration
	 194  	for i := 0; i < tries; i++ {
	 195  		cmd := testenv.CleanCmdEnv(exec.Command(exe, "CgoCheckBytes"))
	 196  		cmd.Env = append(cmd.Env, "GODEBUG=cgocheck=0", fmt.Sprintf("GO_CGOCHECKBYTES_TRY=%d", i))
	 197  
	 198  		start := time.Now()
	 199  		cmd.Run()
	 200  		d1 := time.Since(start)
	 201  
	 202  		cmd = testenv.CleanCmdEnv(exec.Command(exe, "CgoCheckBytes"))
	 203  		cmd.Env = append(cmd.Env, fmt.Sprintf("GO_CGOCHECKBYTES_TRY=%d", i))
	 204  
	 205  		start = time.Now()
	 206  		cmd.Run()
	 207  		d2 := time.Since(start)
	 208  
	 209  		if d1*20 > d2 {
	 210  			// The slow version (d2) was less than 20 times
	 211  			// slower than the fast version (d1), so OK.
	 212  			return
	 213  		}
	 214  
	 215  		tot1 += d1
	 216  		tot2 += d2
	 217  	}
	 218  
	 219  	t.Errorf("cgo check too slow: got %v, expected at most %v", tot2/tries, (tot1/tries)*20)
	 220  }
	 221  
	 222  func TestCgoPanicDeadlock(t *testing.T) {
	 223  	t.Parallel()
	 224  	// test issue 14432
	 225  	got := runTestProg(t, "testprogcgo", "CgoPanicDeadlock")
	 226  	want := "panic: cgo error\n\n"
	 227  	if !strings.HasPrefix(got, want) {
	 228  		t.Fatalf("output does not start with %q:\n%s", want, got)
	 229  	}
	 230  }
	 231  
	 232  func TestCgoCCodeSIGPROF(t *testing.T) {
	 233  	t.Parallel()
	 234  	got := runTestProg(t, "testprogcgo", "CgoCCodeSIGPROF")
	 235  	want := "OK\n"
	 236  	if got != want {
	 237  		t.Errorf("expected %q got %v", want, got)
	 238  	}
	 239  }
	 240  
	 241  func TestCgoCrashTraceback(t *testing.T) {
	 242  	t.Parallel()
	 243  	switch platform := runtime.GOOS + "/" + runtime.GOARCH; platform {
	 244  	case "darwin/amd64":
	 245  	case "linux/amd64":
	 246  	case "linux/ppc64le":
	 247  	default:
	 248  		t.Skipf("not yet supported on %s", platform)
	 249  	}
	 250  	got := runTestProg(t, "testprogcgo", "CrashTraceback")
	 251  	for i := 1; i <= 3; i++ {
	 252  		if !strings.Contains(got, fmt.Sprintf("cgo symbolizer:%d", i)) {
	 253  			t.Errorf("missing cgo symbolizer:%d", i)
	 254  		}
	 255  	}
	 256  }
	 257  
	 258  func TestCgoCrashTracebackGo(t *testing.T) {
	 259  	t.Parallel()
	 260  	switch platform := runtime.GOOS + "/" + runtime.GOARCH; platform {
	 261  	case "darwin/amd64":
	 262  	case "linux/amd64":
	 263  	case "linux/ppc64le":
	 264  	default:
	 265  		t.Skipf("not yet supported on %s", platform)
	 266  	}
	 267  	got := runTestProg(t, "testprogcgo", "CrashTracebackGo")
	 268  	for i := 1; i <= 3; i++ {
	 269  		want := fmt.Sprintf("main.h%d", i)
	 270  		if !strings.Contains(got, want) {
	 271  			t.Errorf("missing %s", want)
	 272  		}
	 273  	}
	 274  }
	 275  
	 276  func TestCgoTracebackContext(t *testing.T) {
	 277  	t.Parallel()
	 278  	got := runTestProg(t, "testprogcgo", "TracebackContext")
	 279  	want := "OK\n"
	 280  	if got != want {
	 281  		t.Errorf("expected %q got %v", want, got)
	 282  	}
	 283  }
	 284  
	 285  func TestCgoTracebackContextPreemption(t *testing.T) {
	 286  	t.Parallel()
	 287  	got := runTestProg(t, "testprogcgo", "TracebackContextPreemption")
	 288  	want := "OK\n"
	 289  	if got != want {
	 290  		t.Errorf("expected %q got %v", want, got)
	 291  	}
	 292  }
	 293  
	 294  func testCgoPprof(t *testing.T, buildArg, runArg, top, bottom string) {
	 295  	t.Parallel()
	 296  	if runtime.GOOS != "linux" || (runtime.GOARCH != "amd64" && runtime.GOARCH != "ppc64le") {
	 297  		t.Skipf("not yet supported on %s/%s", runtime.GOOS, runtime.GOARCH)
	 298  	}
	 299  	testenv.MustHaveGoRun(t)
	 300  
	 301  	exe, err := buildTestProg(t, "testprogcgo", buildArg)
	 302  	if err != nil {
	 303  		t.Fatal(err)
	 304  	}
	 305  
	 306  	// pprofCgoTraceback is called whenever CGO code is executing and a signal
	 307  	// is received. Disable signal preemption to increase the likelihood at
	 308  	// least one SIGPROF signal fired to capture a sample. See issue #37201.
	 309  	cmd := testenv.CleanCmdEnv(exec.Command(exe, runArg))
	 310  	cmd.Env = append(cmd.Env, "GODEBUG=asyncpreemptoff=1")
	 311  
	 312  	got, err := cmd.CombinedOutput()
	 313  	if err != nil {
	 314  		if testenv.Builder() == "linux-amd64-alpine" {
	 315  			// See Issue 18243 and Issue 19938.
	 316  			t.Skipf("Skipping failing test on Alpine (golang.org/issue/18243). Ignoring error: %v", err)
	 317  		}
	 318  		t.Fatalf("%s\n\n%v", got, err)
	 319  	}
	 320  	fn := strings.TrimSpace(string(got))
	 321  	defer os.Remove(fn)
	 322  
	 323  	for try := 0; try < 2; try++ {
	 324  		cmd := testenv.CleanCmdEnv(exec.Command(testenv.GoToolPath(t), "tool", "pprof", "-traces"))
	 325  		// Check that pprof works both with and without explicit executable on command line.
	 326  		if try == 0 {
	 327  			cmd.Args = append(cmd.Args, exe, fn)
	 328  		} else {
	 329  			cmd.Args = append(cmd.Args, fn)
	 330  		}
	 331  
	 332  		found := false
	 333  		for i, e := range cmd.Env {
	 334  			if strings.HasPrefix(e, "PPROF_TMPDIR=") {
	 335  				cmd.Env[i] = "PPROF_TMPDIR=" + os.TempDir()
	 336  				found = true
	 337  				break
	 338  			}
	 339  		}
	 340  		if !found {
	 341  			cmd.Env = append(cmd.Env, "PPROF_TMPDIR="+os.TempDir())
	 342  		}
	 343  
	 344  		out, err := cmd.CombinedOutput()
	 345  		t.Logf("%s:\n%s", cmd.Args, out)
	 346  		if err != nil {
	 347  			t.Error(err)
	 348  			continue
	 349  		}
	 350  
	 351  		trace := findTrace(string(out), top)
	 352  		if len(trace) == 0 {
	 353  			t.Errorf("%s traceback missing.", top)
	 354  			continue
	 355  		}
	 356  		if trace[len(trace)-1] != bottom {
	 357  			t.Errorf("invalid traceback origin: got=%v; want=[%s ... %s]", trace, top, bottom)
	 358  		}
	 359  	}
	 360  }
	 361  
	 362  func TestCgoPprof(t *testing.T) {
	 363  	testCgoPprof(t, "", "CgoPprof", "cpuHog", "runtime.main")
	 364  }
	 365  
	 366  func TestCgoPprofPIE(t *testing.T) {
	 367  	testCgoPprof(t, "-buildmode=pie", "CgoPprof", "cpuHog", "runtime.main")
	 368  }
	 369  
	 370  func TestCgoPprofThread(t *testing.T) {
	 371  	testCgoPprof(t, "", "CgoPprofThread", "cpuHogThread", "cpuHogThread2")
	 372  }
	 373  
	 374  func TestCgoPprofThreadNoTraceback(t *testing.T) {
	 375  	testCgoPprof(t, "", "CgoPprofThreadNoTraceback", "cpuHogThread", "runtime._ExternalCode")
	 376  }
	 377  
	 378  func TestRaceProf(t *testing.T) {
	 379  	if (runtime.GOOS != "linux" && runtime.GOOS != "freebsd") || runtime.GOARCH != "amd64" {
	 380  		t.Skipf("not yet supported on %s/%s", runtime.GOOS, runtime.GOARCH)
	 381  	}
	 382  
	 383  	testenv.MustHaveGoRun(t)
	 384  
	 385  	// This test requires building various packages with -race, so
	 386  	// it's somewhat slow.
	 387  	if testing.Short() {
	 388  		t.Skip("skipping test in -short mode")
	 389  	}
	 390  
	 391  	exe, err := buildTestProg(t, "testprogcgo", "-race")
	 392  	if err != nil {
	 393  		t.Fatal(err)
	 394  	}
	 395  
	 396  	got, err := testenv.CleanCmdEnv(exec.Command(exe, "CgoRaceprof")).CombinedOutput()
	 397  	if err != nil {
	 398  		t.Fatal(err)
	 399  	}
	 400  	want := "OK\n"
	 401  	if string(got) != want {
	 402  		t.Errorf("expected %q got %s", want, got)
	 403  	}
	 404  }
	 405  
	 406  func TestRaceSignal(t *testing.T) {
	 407  	t.Parallel()
	 408  	if (runtime.GOOS != "linux" && runtime.GOOS != "freebsd") || runtime.GOARCH != "amd64" {
	 409  		t.Skipf("not yet supported on %s/%s", runtime.GOOS, runtime.GOARCH)
	 410  	}
	 411  
	 412  	testenv.MustHaveGoRun(t)
	 413  
	 414  	// This test requires building various packages with -race, so
	 415  	// it's somewhat slow.
	 416  	if testing.Short() {
	 417  		t.Skip("skipping test in -short mode")
	 418  	}
	 419  
	 420  	exe, err := buildTestProg(t, "testprogcgo", "-race")
	 421  	if err != nil {
	 422  		t.Fatal(err)
	 423  	}
	 424  
	 425  	got, err := testenv.CleanCmdEnv(exec.Command(exe, "CgoRaceSignal")).CombinedOutput()
	 426  	if err != nil {
	 427  		t.Logf("%s\n", got)
	 428  		t.Fatal(err)
	 429  	}
	 430  	want := "OK\n"
	 431  	if string(got) != want {
	 432  		t.Errorf("expected %q got %s", want, got)
	 433  	}
	 434  }
	 435  
	 436  func TestCgoNumGoroutine(t *testing.T) {
	 437  	switch runtime.GOOS {
	 438  	case "windows", "plan9":
	 439  		t.Skipf("skipping numgoroutine test on %s", runtime.GOOS)
	 440  	}
	 441  	t.Parallel()
	 442  	got := runTestProg(t, "testprogcgo", "NumGoroutine")
	 443  	want := "OK\n"
	 444  	if got != want {
	 445  		t.Errorf("expected %q got %v", want, got)
	 446  	}
	 447  }
	 448  
	 449  func TestCatchPanic(t *testing.T) {
	 450  	t.Parallel()
	 451  	switch runtime.GOOS {
	 452  	case "plan9", "windows":
	 453  		t.Skipf("no signals on %s", runtime.GOOS)
	 454  	case "darwin":
	 455  		if runtime.GOARCH == "amd64" {
	 456  			t.Skipf("crash() on darwin/amd64 doesn't raise SIGABRT")
	 457  		}
	 458  	}
	 459  
	 460  	testenv.MustHaveGoRun(t)
	 461  
	 462  	exe, err := buildTestProg(t, "testprogcgo")
	 463  	if err != nil {
	 464  		t.Fatal(err)
	 465  	}
	 466  
	 467  	for _, early := range []bool{true, false} {
	 468  		cmd := testenv.CleanCmdEnv(exec.Command(exe, "CgoCatchPanic"))
	 469  		// Make sure a panic results in a crash.
	 470  		cmd.Env = append(cmd.Env, "GOTRACEBACK=crash")
	 471  		if early {
	 472  			// Tell testprogcgo to install an early signal handler for SIGABRT
	 473  			cmd.Env = append(cmd.Env, "CGOCATCHPANIC_EARLY_HANDLER=1")
	 474  		}
	 475  		if out, err := cmd.CombinedOutput(); err != nil {
	 476  			t.Errorf("testprogcgo CgoCatchPanic failed: %v\n%s", err, out)
	 477  		}
	 478  	}
	 479  }
	 480  
	 481  func TestCgoLockOSThreadExit(t *testing.T) {
	 482  	switch runtime.GOOS {
	 483  	case "plan9", "windows":
	 484  		t.Skipf("no pthreads on %s", runtime.GOOS)
	 485  	}
	 486  	t.Parallel()
	 487  	testLockOSThreadExit(t, "testprogcgo")
	 488  }
	 489  
	 490  func TestWindowsStackMemoryCgo(t *testing.T) {
	 491  	if runtime.GOOS != "windows" {
	 492  		t.Skip("skipping windows specific test")
	 493  	}
	 494  	testenv.SkipFlaky(t, 22575)
	 495  	o := runTestProg(t, "testprogcgo", "StackMemory")
	 496  	stackUsage, err := strconv.Atoi(o)
	 497  	if err != nil {
	 498  		t.Fatalf("Failed to read stack usage: %v", err)
	 499  	}
	 500  	if expected, got := 100<<10, stackUsage; got > expected {
	 501  		t.Fatalf("expected < %d bytes of memory per thread, got %d", expected, got)
	 502  	}
	 503  }
	 504  
	 505  func TestSigStackSwapping(t *testing.T) {
	 506  	switch runtime.GOOS {
	 507  	case "plan9", "windows":
	 508  		t.Skipf("no sigaltstack on %s", runtime.GOOS)
	 509  	}
	 510  	t.Parallel()
	 511  	got := runTestProg(t, "testprogcgo", "SigStack")
	 512  	want := "OK\n"
	 513  	if got != want {
	 514  		t.Errorf("expected %q got %v", want, got)
	 515  	}
	 516  }
	 517  
	 518  func TestCgoTracebackSigpanic(t *testing.T) {
	 519  	// Test unwinding over a sigpanic in C code without a C
	 520  	// symbolizer. See issue #23576.
	 521  	if runtime.GOOS == "windows" {
	 522  		// On Windows if we get an exception in C code, we let
	 523  		// the Windows exception handler unwind it, rather
	 524  		// than injecting a sigpanic.
	 525  		t.Skip("no sigpanic in C on windows")
	 526  	}
	 527  	t.Parallel()
	 528  	got := runTestProg(t, "testprogcgo", "TracebackSigpanic")
	 529  	want := "runtime.sigpanic"
	 530  	if !strings.Contains(got, want) {
	 531  		t.Fatalf("want failure containing %q. output:\n%s\n", want, got)
	 532  	}
	 533  	nowant := "unexpected return pc"
	 534  	if strings.Contains(got, nowant) {
	 535  		t.Fatalf("failure incorrectly contains %q. output:\n%s\n", nowant, got)
	 536  	}
	 537  }
	 538  
	 539  // Test that C code called via cgo can use large Windows thread stacks
	 540  // and call back in to Go without crashing. See issue #20975.
	 541  //
	 542  // See also TestBigStackCallbackSyscall.
	 543  func TestBigStackCallbackCgo(t *testing.T) {
	 544  	if runtime.GOOS != "windows" {
	 545  		t.Skip("skipping windows specific test")
	 546  	}
	 547  	t.Parallel()
	 548  	got := runTestProg(t, "testprogcgo", "BigStack")
	 549  	want := "OK\n"
	 550  	if got != want {
	 551  		t.Errorf("expected %q got %v", want, got)
	 552  	}
	 553  }
	 554  
	 555  func nextTrace(lines []string) ([]string, []string) {
	 556  	var trace []string
	 557  	for n, line := range lines {
	 558  		if strings.HasPrefix(line, "---") {
	 559  			return trace, lines[n+1:]
	 560  		}
	 561  		fields := strings.Fields(strings.TrimSpace(line))
	 562  		if len(fields) == 0 {
	 563  			continue
	 564  		}
	 565  		// Last field contains the function name.
	 566  		trace = append(trace, fields[len(fields)-1])
	 567  	}
	 568  	return nil, nil
	 569  }
	 570  
	 571  func findTrace(text, top string) []string {
	 572  	lines := strings.Split(text, "\n")
	 573  	_, lines = nextTrace(lines) // Skip the header.
	 574  	for len(lines) > 0 {
	 575  		var t []string
	 576  		t, lines = nextTrace(lines)
	 577  		if len(t) == 0 {
	 578  			continue
	 579  		}
	 580  		if t[0] == top {
	 581  			return t
	 582  		}
	 583  	}
	 584  	return nil
	 585  }
	 586  
	 587  func TestSegv(t *testing.T) {
	 588  	switch runtime.GOOS {
	 589  	case "plan9", "windows":
	 590  		t.Skipf("no signals on %s", runtime.GOOS)
	 591  	}
	 592  
	 593  	for _, test := range []string{"Segv", "SegvInCgo"} {
	 594  		t.Run(test, func(t *testing.T) {
	 595  			t.Parallel()
	 596  			got := runTestProg(t, "testprogcgo", test)
	 597  			t.Log(got)
	 598  			if !strings.Contains(got, "SIGSEGV") {
	 599  				t.Errorf("expected crash from signal")
	 600  			}
	 601  		})
	 602  	}
	 603  }
	 604  
	 605  // TestEINTR tests that we handle EINTR correctly.
	 606  // See issue #20400 and friends.
	 607  func TestEINTR(t *testing.T) {
	 608  	switch runtime.GOOS {
	 609  	case "plan9", "windows":
	 610  		t.Skipf("no EINTR on %s", runtime.GOOS)
	 611  	case "linux":
	 612  		if runtime.GOARCH == "386" {
	 613  			// On linux-386 the Go signal handler sets
	 614  			// a restorer function that is not preserved
	 615  			// by the C sigaction call in the test,
	 616  			// causing the signal handler to crash when
	 617  			// returning the normal code. The test is not
	 618  			// architecture-specific, so just skip on 386
	 619  			// rather than doing a complicated workaround.
	 620  			t.Skip("skipping on linux-386; C sigaction does not preserve Go restorer")
	 621  		}
	 622  	}
	 623  
	 624  	t.Parallel()
	 625  	output := runTestProg(t, "testprogcgo", "EINTR")
	 626  	want := "OK\n"
	 627  	if output != want {
	 628  		t.Fatalf("want %s, got %s\n", want, output)
	 629  	}
	 630  }
	 631  
	 632  // Issue #42207.
	 633  func TestNeedmDeadlock(t *testing.T) {
	 634  	switch runtime.GOOS {
	 635  	case "plan9", "windows":
	 636  		t.Skipf("no signals on %s", runtime.GOOS)
	 637  	}
	 638  	output := runTestProg(t, "testprogcgo", "NeedmDeadlock")
	 639  	want := "OK\n"
	 640  	if output != want {
	 641  		t.Fatalf("want %s, got %s\n", want, output)
	 642  	}
	 643  }
	 644  

View as plain text