← Back to branch summary

~ubuntu-branches/ubuntu/saucy/golang/saucy

« back to all changes in this revision

Viewing changes to src/pkg/runtime/race/testdata/slice_test.go

  • Committer: Package Import Robot
  • Author(s): Adam Conrad
  • Date: 2013-07-08 05:52:37 UTC
  • mfrom: (29.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20130708055237-at01839e0hp8z3ni
Tags: 2:1.1-1ubuntu1
016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/runtime/race/testdata/slice_test.go
 
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 race_test
 
6
 
 
7
import (
 
8
        "testing"
 
9
)
 
10
 
 
11
func TestRaceSliceRW(t *testing.T) {
 
12
        ch := make(chan bool, 1)
 
13
        a := make([]int, 2)
 
14
        go func() {
 
15
                a[1] = 1
 
16
                ch <- true
 
17
        }()
 
18
        _ = a[1]
 
19
        <-ch
 
20
}
 
21
 
 
22
func TestNoRaceSliceRW(t *testing.T) {
 
23
        ch := make(chan bool, 1)
 
24
        a := make([]int, 2)
 
25
        go func() {
 
26
                a[0] = 1
 
27
                ch <- true
 
28
        }()
 
29
        _ = a[1]
 
30
        <-ch
 
31
}
 
32
 
 
33
func TestRaceSliceWW(t *testing.T) {
 
34
        a := make([]int, 10)
 
35
        ch := make(chan bool, 1)
 
36
        go func() {
 
37
                a[1] = 1
 
38
                ch <- true
 
39
        }()
 
40
        a[1] = 2
 
41
        <-ch
 
42
}
 
43
 
 
44
func TestNoRaceArrayWW(t *testing.T) {
 
45
        var a [5]int
 
46
        ch := make(chan bool, 1)
 
47
        go func() {
 
48
                a[0] = 1
 
49
                ch <- true
 
50
        }()
 
51
        a[1] = 2
 
52
        <-ch
 
53
}
 
54
 
 
55
func TestRaceArrayWW(t *testing.T) {
 
56
        var a [5]int
 
57
        ch := make(chan bool, 1)
 
58
        go func() {
 
59
                a[1] = 1
 
60
                ch <- true
 
61
        }()
 
62
        a[1] = 2
 
63
        <-ch
 
64
}
 
65
 
 
66
func TestNoRaceSliceWriteLen(t *testing.T) {
 
67
        ch := make(chan bool, 1)
 
68
        a := make([]bool, 1)
 
69
        go func() {
 
70
                a[0] = true
 
71
                ch <- true
 
72
        }()
 
73
        _ = len(a)
 
74
        <-ch
 
75
}
 
76
 
 
77
func TestNoRaceSliceWriteCap(t *testing.T) {
 
78
        ch := make(chan bool, 1)
 
79
        a := make([]uint64, 100)
 
80
        go func() {
 
81
                a[50] = 123
 
82
                ch <- true
 
83
        }()
 
84
        _ = cap(a)
 
85
        <-ch
 
86
}
 
87
 
 
88
func TestRaceSliceCopyRead(t *testing.T) {
 
89
        ch := make(chan bool, 1)
 
90
        a := make([]int, 10)
 
91
        b := make([]int, 10)
 
92
        go func() {
 
93
                _ = a[5]
 
94
                ch <- true
 
95
        }()
 
96
        copy(a, b)
 
97
        <-ch
 
98
}
 
99
 
 
100
func TestNoRaceSliceWriteCopy(t *testing.T) {
 
101
        ch := make(chan bool, 1)
 
102
        a := make([]int, 10)
 
103
        b := make([]int, 10)
 
104
        go func() {
 
105
                a[5] = 1
 
106
                ch <- true
 
107
        }()
 
108
        copy(a[:5], b[:5])
 
109
        <-ch
 
110
}
 
111
 
 
112
func TestRaceSliceCopyWrite2(t *testing.T) {
 
113
        ch := make(chan bool, 1)
 
114
        a := make([]int, 10)
 
115
        b := make([]int, 10)
 
116
        go func() {
 
117
                b[5] = 1
 
118
                ch <- true
 
119
        }()
 
120
        copy(a, b)
 
121
        <-ch
 
122
}
 
123
 
 
124
func TestRaceSliceCopyWrite3(t *testing.T) {
 
125
        ch := make(chan bool, 1)
 
126
        a := make([]byte, 10)
 
127
        go func() {
 
128
                a[7] = 1
 
129
                ch <- true
 
130
        }()
 
131
        copy(a, "qwertyqwerty")
 
132
        <-ch
 
133
}
 
134
 
 
135
func TestNoRaceSliceCopyRead(t *testing.T) {
 
136
        ch := make(chan bool, 1)
 
137
        a := make([]int, 10)
 
138
        b := make([]int, 10)
 
139
        go func() {
 
140
                _ = b[5]
 
141
                ch <- true
 
142
        }()
 
143
        copy(a, b)
 
144
        <-ch
 
145
}
 
146
 
 
147
func TestNoRaceSliceWriteSlice2(t *testing.T) {
 
148
        ch := make(chan bool, 1)
 
149
        a := make([]float64, 10)
 
150
        go func() {
 
151
                a[2] = 1.0
 
152
                ch <- true
 
153
        }()
 
154
        _ = a[0:5]
 
155
        <-ch
 
156
}
 
157
 
 
158
func TestRaceSliceWriteSlice(t *testing.T) {
 
159
        ch := make(chan bool, 1)
 
160
        a := make([]float64, 10)
 
161
        go func() {
 
162
                a[2] = 1.0
 
163
                ch <- true
 
164
        }()
 
165
        a = a[5:10]
 
166
        <-ch
 
167
}
 
168
 
 
169
func TestNoRaceSliceWriteSlice(t *testing.T) {
 
170
        ch := make(chan bool, 1)
 
171
        a := make([]float64, 10)
 
172
        go func() {
 
173
                a[2] = 1.0
 
174
                ch <- true
 
175
        }()
 
176
        _ = a[5:10]
 
177
        <-ch
 
178
}
 
179
 
 
180
func TestNoRaceSliceLenCap(t *testing.T) {
 
181
        ch := make(chan bool, 1)
 
182
        a := make([]struct{}, 10)
 
183
        go func() {
 
184
                _ = len(a)
 
185
                ch <- true
 
186
        }()
 
187
        _ = cap(a)
 
188
        <-ch
 
189
}
 
190
 
 
191
func TestNoRaceStructSlicesRangeWrite(t *testing.T) {
 
192
        type Str struct {
 
193
                a []int
 
194
                b []int
 
195
        }
 
196
        ch := make(chan bool, 1)
 
197
        var s Str
 
198
        s.a = make([]int, 10)
 
199
        s.b = make([]int, 10)
 
200
        go func() {
 
201
                for _ = range s.a {
 
202
                }
 
203
                ch <- true
 
204
        }()
 
205
        s.b[5] = 5
 
206
        <-ch
 
207
}
 
208
 
 
209
func TestRaceSliceDifferent(t *testing.T) {
 
210
        c := make(chan bool, 1)
 
211
        s := make([]int, 10)
 
212
        s2 := s
 
213
        go func() {
 
214
                s[3] = 3
 
215
                c <- true
 
216
        }()
 
217
        // false negative because s2 is PAUTO w/o PHEAP
 
218
        // so we do not instrument it
 
219
        s2[3] = 3
 
220
        <-c
 
221
}
 
222
 
 
223
func TestRaceSliceRangeWrite(t *testing.T) {
 
224
        c := make(chan bool, 1)
 
225
        s := make([]int, 10)
 
226
        go func() {
 
227
                s[3] = 3
 
228
                c <- true
 
229
        }()
 
230
        for _, v := range s {
 
231
                _ = v
 
232
        }
 
233
        <-c
 
234
}
 
235
 
 
236
func TestNoRaceSliceRangeWrite(t *testing.T) {
 
237
        c := make(chan bool, 1)
 
238
        s := make([]int, 10)
 
239
        go func() {
 
240
                s[3] = 3
 
241
                c <- true
 
242
        }()
 
243
        for _ = range s {
 
244
        }
 
245
        <-c
 
246
}
 
247
 
 
248
func TestRaceSliceRangeAppend(t *testing.T) {
 
249
        c := make(chan bool, 1)
 
250
        s := make([]int, 10)
 
251
        go func() {
 
252
                s = append(s, 3)
 
253
                c <- true
 
254
        }()
 
255
        for _ = range s {
 
256
        }
 
257
        <-c
 
258
}
 
259
 
 
260
func TestNoRaceSliceRangeAppend(t *testing.T) {
 
261
        c := make(chan bool, 1)
 
262
        s := make([]int, 10)
 
263
        go func() {
 
264
                _ = append(s, 3)
 
265
                c <- true
 
266
        }()
 
267
        for _ = range s {
 
268
        }
 
269
        <-c
 
270
}
 
271
 
 
272
func TestRaceSliceVarWrite(t *testing.T) {
 
273
        c := make(chan bool, 1)
 
274
        s := make([]int, 10)
 
275
        go func() {
 
276
                s[3] = 3
 
277
                c <- true
 
278
        }()
 
279
        s = make([]int, 20)
 
280
        <-c
 
281
}
 
282
 
 
283
func TestRaceSliceVarRead(t *testing.T) {
 
284
        c := make(chan bool, 1)
 
285
        s := make([]int, 10)
 
286
        go func() {
 
287
                _ = s[3]
 
288
                c <- true
 
289
        }()
 
290
        s = make([]int, 20)
 
291
        <-c
 
292
}
 
293
 
 
294
func TestRaceSliceVarRange(t *testing.T) {
 
295
        c := make(chan bool, 1)
 
296
        s := make([]int, 10)
 
297
        go func() {
 
298
                for _ = range s {
 
299
                }
 
300
                c <- true
 
301
        }()
 
302
        s = make([]int, 20)
 
303
        <-c
 
304
}
 
305
 
 
306
func TestRaceSliceVarAppend(t *testing.T) {
 
307
        c := make(chan bool, 1)
 
308
        s := make([]int, 10)
 
309
        go func() {
 
310
                _ = append(s, 10)
 
311
                c <- true
 
312
        }()
 
313
        s = make([]int, 20)
 
314
        <-c
 
315
}
 
316
 
 
317
func TestRaceSliceVarCopy(t *testing.T) {
 
318
        c := make(chan bool, 1)
 
319
        s := make([]int, 10)
 
320
        go func() {
 
321
                s2 := make([]int, 10)
 
322
                copy(s, s2)
 
323
                c <- true
 
324
        }()
 
325
        s = make([]int, 20)
 
326
        <-c
 
327
}
 
328
 
 
329
func TestRaceSliceVarCopy2(t *testing.T) {
 
330
        c := make(chan bool, 1)
 
331
        s := make([]int, 10)
 
332
        go func() {
 
333
                s2 := make([]int, 10)
 
334
                copy(s2, s)
 
335
                c <- true
 
336
        }()
 
337
        s = make([]int, 20)
 
338
        <-c
 
339
}
 
340
 
 
341
func TestRaceSliceAppend(t *testing.T) {
 
342
        c := make(chan bool, 1)
 
343
        s := make([]int, 10, 20)
 
344
        go func() {
 
345
                _ = append(s, 1)
 
346
                c <- true
 
347
        }()
 
348
        _ = append(s, 2)
 
349
        <-c
 
350
}
 
351
 
 
352
func TestRaceSliceAppendWrite(t *testing.T) {
 
353
        c := make(chan bool, 1)
 
354
        s := make([]int, 10)
 
355
        go func() {
 
356
                _ = append(s, 1)
 
357
                c <- true
 
358
        }()
 
359
        s[0] = 42
 
360
        <-c
 
361
}
 
362
 
 
363
func TestRaceSliceAppendSlice(t *testing.T) {
 
364
        c := make(chan bool, 1)
 
365
        s := make([]int, 10)
 
366
        go func() {
 
367
                s2 := make([]int, 10)
 
368
                _ = append(s, s2...)
 
369
                c <- true
 
370
        }()
 
371
        s[0] = 42
 
372
        <-c
 
373
}
 
374
 
 
375
func TestRaceSliceAppendSlice2(t *testing.T) {
 
376
        c := make(chan bool, 1)
 
377
        s := make([]int, 10)
 
378
        s2foobar := make([]int, 10)
 
379
        go func() {
 
380
                _ = append(s, s2foobar...)
 
381
                c <- true
 
382
        }()
 
383
        s2foobar[5] = 42
 
384
        <-c
 
385
}
 
386
 
 
387
func TestRaceSliceAppendString(t *testing.T) {
 
388
        c := make(chan bool, 1)
 
389
        s := make([]byte, 10)
 
390
        go func() {
 
391
                _ = append(s, "qwerty"...)
 
392
                c <- true
 
393
        }()
 
394
        s[0] = 42
 
395
        <-c
 
396
}
 
397
 
 
398
func TestNoRaceSliceIndexAccess(t *testing.T) {
 
399
        c := make(chan bool, 1)
 
400
        s := make([]int, 10)
 
401
        v := 0
 
402
        go func() {
 
403
                _ = v
 
404
                c <- true
 
405
        }()
 
406
        s[v] = 1
 
407
        <-c
 
408
}
 
409
 
 
410
func TestNoRaceSliceIndexAccess2(t *testing.T) {
 
411
        c := make(chan bool, 1)
 
412
        s := make([]int, 10)
 
413
        v := 0
 
414
        go func() {
 
415
                _ = v
 
416
                c <- true
 
417
        }()
 
418
        _ = s[v]
 
419
        <-c
 
420
}
 
421
 
 
422
func TestRaceSliceIndexAccess(t *testing.T) {
 
423
        c := make(chan bool, 1)
 
424
        s := make([]int, 10)
 
425
        v := 0
 
426
        go func() {
 
427
                v = 1
 
428
                c <- true
 
429
        }()
 
430
        s[v] = 1
 
431
        <-c
 
432
}
 
433
 
 
434
func TestRaceSliceIndexAccess2(t *testing.T) {
 
435
        c := make(chan bool, 1)
 
436
        s := make([]int, 10)
 
437
        v := 0
 
438
        go func() {
 
439
                v = 1
 
440
                c <- true
 
441
        }()
 
442
        _ = s[v]
 
443
        <-c
 
444
}
 
445
 
 
446
func TestRaceSliceByteToString(t *testing.T) {
 
447
        c := make(chan string)
 
448
        s := make([]byte, 10)
 
449
        go func() {
 
450
                c <- string(s)
 
451
        }()
 
452
        s[0] = 42
 
453
        <-c
 
454
}
 
455
 
 
456
func TestRaceSliceRuneToString(t *testing.T) {
 
457
        c := make(chan string)
 
458
        s := make([]rune, 10)
 
459
        go func() {
 
460
                c <- string(s)
 
461
        }()
 
462
        s[9] = 42
 
463
        <-c
 
464
}
 
465
 
 
466
func TestRaceConcatString(t *testing.T) {
 
467
        s := "hello"
 
468
        c := make(chan string, 1)
 
469
        go func() {
 
470
                c <- s + " world"
 
471
        }()
 
472
        s = "world"
 
473
        <-c
 
474
}
 
475
 
 
476
func TestRaceCompareString(t *testing.T) {
 
477
        s1 := "hello"
 
478
        s2 := "world"
 
479
        c := make(chan bool, 1)
 
480
        go func() {
 
481
                c <- s1 == s2
 
482
        }()
 
483
        s1 = s2
 
484
        <-c
 
485
}