| all: disable some tests that have trouble running remotely. |
| |
| --- src/encoding/gob/encoder_test.go |
| +++ src/encoding/gob/encoder_test.go |
| @@ -1125,20 +1125,17 @@ func TestBadData(t *testing.T) { |
| if !strings.Contains(err.Error(), test.error) { |
| t.Errorf("#%d: decode: expected %q error, got %s", i, test.error, err.Error()) |
| } |
| } |
| } |
| |
| // TestHugeWriteFails tests that enormous messages trigger an error. |
| func TestHugeWriteFails(t *testing.T) { |
| - if testing.Short() { |
| - // Requires allocating a monster, so don't do this from all.bash. |
| - t.Skip("skipping huge allocation in short mode") |
| - } |
| + t.Skip("skipping test due to huge memory requirement") |
| huge := make([]byte, tooBig) |
| huge[0] = 7 // Make sure it's not all zeros. |
| buf := new(bytes.Buffer) |
| err := NewEncoder(buf).Encode(huge) |
| if err == nil { |
| t.Fatalf("expected error for huge slice") |
| } |
| if !strings.Contains(err.Error(), "message too big") { |
| --- src/runtime/crash_cgo_test.go |
| +++ src/runtime/crash_cgo_test.go |
| @@ -246,20 +246,17 @@ func TestCgoCCodeSIGPROF(t *testing.T) { |
| got := runTestProg(t, "testprogcgo", "CgoCCodeSIGPROF") |
| want := "OK\n" |
| if got != want { |
| t.Errorf("expected %q got %v", want, got) |
| } |
| } |
| |
| func TestCgoCrashTraceback(t *testing.T) { |
| - t.Parallel() |
| - if runtime.GOOS != "linux" || (runtime.GOARCH != "amd64" && runtime.GOARCH != "ppc64le") { |
| - t.Skipf("not yet supported on %s/%s", runtime.GOOS, runtime.GOARCH) |
| - } |
| + t.Skipf("skip running remotely") |
| got := runTestProg(t, "testprogcgo", "CrashTraceback") |
| for i := 1; i <= 3; i++ { |
| if !strings.Contains(got, fmt.Sprintf("cgo symbolizer:%d", i)) { |
| t.Errorf("missing cgo symbolizer:%d", i) |
| } |
| } |
| } |
| |
| @@ -268,20 +265,17 @@ func TestCgoTracebackContext(t *testing.T) { |
| got := runTestProg(t, "testprogcgo", "TracebackContext") |
| want := "OK\n" |
| if got != want { |
| t.Errorf("expected %q got %v", want, got) |
| } |
| } |
| |
| func testCgoPprof(t *testing.T, buildArg, runArg string) { |
| - t.Parallel() |
| - if runtime.GOOS != "linux" || (runtime.GOARCH != "amd64" && runtime.GOARCH != "ppc64le") { |
| - t.Skipf("not yet supported on %s/%s", runtime.GOOS, runtime.GOARCH) |
| - } |
| + t.Skipf("skip pprof test") |
| testenv.MustHaveGoRun(t) |
| |
| exe, err := buildTestProg(t, "testprogcgo", buildArg) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| got, err := testenv.CleanCmdEnv(goExecCmd(exe, runArg)).CombinedOutput() |
| --- src/runtime/crash_test.go |
| +++ src/runtime/crash_test.go |
| @@ -476,16 +476,17 @@ func TestPanicDeadlockSyscall(t *testing.T) { |
| func TestPanicLoop(t *testing.T) { |
| output := runTestProg(t, "testprog", "PanicLoop") |
| if want := "panic while printing panic value"; !strings.Contains(output, want) { |
| t.Errorf("output does not contain %q:\n%s", want, output) |
| } |
| } |
| |
| func TestMemPprof(t *testing.T) { |
| + t.Skipf("skip pprof test") |
| testenv.MustHaveGoRun(t) |
| |
| exe, err := buildTestProg(t, "testprog") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| got, err := testenv.CleanCmdEnv(goExecCmd(exe, "MemProf")).CombinedOutput() |
| --- src/runtime/crash_unix_test.go |
| +++ src/runtime/crash_unix_test.go |
| @@ -169,19 +169,17 @@ func loop(i int, c chan bool) { |
| |
| func TestPanicSystemstack(t *testing.T) { |
| // Test that GOTRACEBACK=crash prints both the system and user |
| // stack of other threads. |
| |
| // The GOTRACEBACK=crash handler takes 0.1 seconds even if |
| // it's not writing a core file and potentially much longer if |
| // it is. Skip in short mode. |
| - if testing.Short() { |
| - t.Skip("Skipping in short mode (GOTRACEBACK=crash is slow)") |
| - } |
| + t.Skip("Skipping (GOTRACEBACK=crash hangs on arm)") |
| |
| if runtime.Sigisblocked(int(syscall.SIGQUIT)) { |
| t.Skip("skipping; SIGQUIT is blocked, see golang.org/issue/19196") |
| } |
| |
| t.Parallel() |
| cmd := exec.Command(os.Args[0], "testPanicSystemstackInternal") |
| cmd = testenv.CleanCmdEnv(cmd) |
| @@ -239,16 +237,17 @@ func init() { |
| } |
| |
| func testPanicSystemstackInternal() { |
| runtime.BlockOnSystemStack() |
| os.Exit(1) // Should be unreachable. |
| } |
| |
| func TestSignalExitStatus(t *testing.T) { |
| + t.Skipf("skip running remotely") |
| testenv.MustHaveGoBuild(t) |
| exe, err := buildTestProg(t, "testprog") |
| if err != nil { |
| t.Fatal(err) |
| } |
| err = testenv.CleanCmdEnv(goExecCmd(exe, "SignalExitStatus")).Run() |
| if err == nil { |
| t.Error("test program succeeded unexpectedly") |
| --- src/runtime/fastlog2_test.go |
| +++ src/runtime/fastlog2_test.go |
| @@ -11,21 +11,17 @@ import ( |
| ) |
| |
| func TestFastLog2(t *testing.T) { |
| // Compute the euclidean distance between math.Log2 and the FastLog2 |
| // implementation over the range of interest for heap sampling. |
| const randomBitCount = 26 |
| var e float64 |
| |
| - inc := 1 |
| - if testing.Short() { |
| - // Check 1K total values, down from 64M. |
| - inc = 1 << 16 |
| - } |
| + inc := 1 << 16 |
| for i := 1; i < 1<<randomBitCount; i += inc { |
| l, fl := math.Log2(float64(i)), runtime.Fastlog2(float64(i)) |
| d := l - fl |
| e += d * d |
| } |
| e = math.Sqrt(e) |
| |
| if e > 1.0 { |
| --- src/runtime/hash_test.go |
| +++ src/runtime/hash_test.go |
| @@ -156,19 +156,17 @@ func TestSmhasherZeros(t *testing.T) { |
| for i := 0; i <= N; i++ { |
| h.addB(b[:i]) |
| } |
| h.check(t) |
| } |
| |
| // Strings with up to two nonzero bytes all have distinct hashes. |
| func TestSmhasherTwoNonzero(t *testing.T) { |
| - if testing.Short() { |
| - t.Skip("Skipping in short mode") |
| - } |
| + t.Skip("skipping test due to huge memory requirement") |
| h := newHashSet() |
| for n := 2; n <= 16; n++ { |
| twoNonZero(h, n) |
| } |
| h.check(t) |
| } |
| func twoNonZero(h *HashSet, n int) { |
| b := make([]byte, n) |
| @@ -259,19 +257,17 @@ func setbits(h *HashSet, b []byte, i int, k int) { |
| setbits(h, b, j+1, k-1) |
| b[j/8] &= byte(^(1 << uint(j&7))) |
| } |
| } |
| |
| // Test all possible combinations of n blocks from the set s. |
| // "permutation" is a bad name here, but it is what Smhasher uses. |
| func TestSmhasherPermutation(t *testing.T) { |
| - if testing.Short() { |
| - t.Skip("Skipping in short mode") |
| - } |
| + t.Skip("skipping test due to huge memory requirement") |
| permutation(t, []uint32{0, 1, 2, 3, 4, 5, 6, 7}, 8) |
| permutation(t, []uint32{0, 1 << 29, 2 << 29, 3 << 29, 4 << 29, 5 << 29, 6 << 29, 7 << 29}, 8) |
| permutation(t, []uint32{0, 1}, 20) |
| permutation(t, []uint32{0, 1 << 31}, 20) |
| permutation(t, []uint32{0, 1, 2, 3, 4, 5, 6, 7, 1 << 29, 2 << 29, 3 << 29, 4 << 29, 5 << 29, 6 << 29, 7 << 29}, 6) |
| } |
| func permutation(t *testing.T, s []uint32, n int) { |
| b := make([]byte, n*4) |
| --- src/runtime/pprof/pprof_test.go |
| +++ src/runtime/pprof/pprof_test.go |
| @@ -278,24 +278,17 @@ func profileOk(t *testing.T, need []string, prof bytes.Buffer, duration time.Dur |
| return ok |
| } |
| |
| // Fork can hang if preempted with signals frequently enough (see issue 5517). |
| // Ensure that we do not do this. |
| func TestCPUProfileWithFork(t *testing.T) { |
| testenv.MustHaveExec(t) |
| |
| - heap := 1 << 30 |
| - if runtime.GOOS == "android" { |
| - // Use smaller size for Android to avoid crash. |
| - heap = 100 << 20 |
| - } |
| - if testing.Short() { |
| - heap = 100 << 20 |
| - } |
| + heap := 100 << 20 |
| // This makes fork slower. |
| garbage := make([]byte, heap) |
| // Need to touch the slice, otherwise it won't be paged in. |
| done := make(chan bool) |
| go func() { |
| for i := range garbage { |
| garbage[i] = 42 |
| } |