1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
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
}
|
