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