...
Run Format

Source file src/runtime/race/testdata/slice_test.go

Documentation: runtime/race/testdata

  // Copyright 2012 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  package race_test
  
  import (
  	"testing"
  )
  
  func TestRaceSliceRW(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]int, 2)
  	go func() {
  		a[1] = 1
  		ch <- true
  	}()
  	_ = a[1]
  	<-ch
  }
  
  func TestNoRaceSliceRW(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]int, 2)
  	go func() {
  		a[0] = 1
  		ch <- true
  	}()
  	_ = a[1]
  	<-ch
  }
  
  func TestRaceSliceWW(t *testing.T) {
  	a := make([]int, 10)
  	ch := make(chan bool, 1)
  	go func() {
  		a[1] = 1
  		ch <- true
  	}()
  	a[1] = 2
  	<-ch
  }
  
  func TestNoRaceArrayWW(t *testing.T) {
  	var a [5]int
  	ch := make(chan bool, 1)
  	go func() {
  		a[0] = 1
  		ch <- true
  	}()
  	a[1] = 2
  	<-ch
  }
  
  func TestRaceArrayWW(t *testing.T) {
  	var a [5]int
  	ch := make(chan bool, 1)
  	go func() {
  		a[1] = 1
  		ch <- true
  	}()
  	a[1] = 2
  	<-ch
  }
  
  func TestNoRaceSliceWriteLen(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]bool, 1)
  	go func() {
  		a[0] = true
  		ch <- true
  	}()
  	_ = len(a)
  	<-ch
  }
  
  func TestNoRaceSliceWriteCap(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]uint64, 100)
  	go func() {
  		a[50] = 123
  		ch <- true
  	}()
  	_ = cap(a)
  	<-ch
  }
  
  func TestRaceSliceCopyRead(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]int, 10)
  	b := make([]int, 10)
  	go func() {
  		_ = a[5]
  		ch <- true
  	}()
  	copy(a, b)
  	<-ch
  }
  
  func TestNoRaceSliceWriteCopy(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]int, 10)
  	b := make([]int, 10)
  	go func() {
  		a[5] = 1
  		ch <- true
  	}()
  	copy(a[:5], b[:5])
  	<-ch
  }
  
  func TestRaceSliceCopyWrite2(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]int, 10)
  	b := make([]int, 10)
  	go func() {
  		b[5] = 1
  		ch <- true
  	}()
  	copy(a, b)
  	<-ch
  }
  
  func TestRaceSliceCopyWrite3(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]byte, 10)
  	go func() {
  		a[7] = 1
  		ch <- true
  	}()
  	copy(a, "qwertyqwerty")
  	<-ch
  }
  
  func TestNoRaceSliceCopyRead(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]int, 10)
  	b := make([]int, 10)
  	go func() {
  		_ = b[5]
  		ch <- true
  	}()
  	copy(a, b)
  	<-ch
  }
  
  func TestRacePointerSliceCopyRead(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]*int, 10)
  	b := make([]*int, 10)
  	go func() {
  		_ = a[5]
  		ch <- true
  	}()
  	copy(a, b)
  	<-ch
  }
  
  func TestNoRacePointerSliceWriteCopy(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]*int, 10)
  	b := make([]*int, 10)
  	go func() {
  		a[5] = new(int)
  		ch <- true
  	}()
  	copy(a[:5], b[:5])
  	<-ch
  }
  
  func TestRacePointerSliceCopyWrite2(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]*int, 10)
  	b := make([]*int, 10)
  	go func() {
  		b[5] = new(int)
  		ch <- true
  	}()
  	copy(a, b)
  	<-ch
  }
  
  func TestNoRacePointerSliceCopyRead(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]*int, 10)
  	b := make([]*int, 10)
  	go func() {
  		_ = b[5]
  		ch <- true
  	}()
  	copy(a, b)
  	<-ch
  }
  
  func TestNoRaceSliceWriteSlice2(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]float64, 10)
  	go func() {
  		a[2] = 1.0
  		ch <- true
  	}()
  	_ = a[0:5]
  	<-ch
  }
  
  func TestRaceSliceWriteSlice(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]float64, 10)
  	go func() {
  		a[2] = 1.0
  		ch <- true
  	}()
  	a = a[5:10]
  	<-ch
  }
  
  func TestNoRaceSliceWriteSlice(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]float64, 10)
  	go func() {
  		a[2] = 1.0
  		ch <- true
  	}()
  	_ = a[5:10]
  	<-ch
  }
  
  func TestNoRaceSliceLenCap(t *testing.T) {
  	ch := make(chan bool, 1)
  	a := make([]struct{}, 10)
  	go func() {
  		_ = len(a)
  		ch <- true
  	}()
  	_ = cap(a)
  	<-ch
  }
  
  func TestNoRaceStructSlicesRangeWrite(t *testing.T) {
  	type Str struct {
  		a []int
  		b []int
  	}
  	ch := make(chan bool, 1)
  	var s Str
  	s.a = make([]int, 10)
  	s.b = make([]int, 10)
  	go func() {
  		for range s.a {
  		}
  		ch <- true
  	}()
  	s.b[5] = 5
  	<-ch
  }
  
  func TestRaceSliceDifferent(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	s2 := s
  	go func() {
  		s[3] = 3
  		c <- true
  	}()
  	// false negative because s2 is PAUTO w/o PHEAP
  	// so we do not instrument it
  	s2[3] = 3
  	<-c
  }
  
  func TestRaceSliceRangeWrite(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	go func() {
  		s[3] = 3
  		c <- true
  	}()
  	for _, v := range s {
  		_ = v
  	}
  	<-c
  }
  
  func TestNoRaceSliceRangeWrite(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	go func() {
  		s[3] = 3
  		c <- true
  	}()
  	for range s {
  	}
  	<-c
  }
  
  func TestRaceSliceRangeAppend(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	go func() {
  		s = append(s, 3)
  		c <- true
  	}()
  	for range s {
  	}
  	<-c
  }
  
  func TestNoRaceSliceRangeAppend(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	go func() {
  		_ = append(s, 3)
  		c <- true
  	}()
  	for range s {
  	}
  	<-c
  }
  
  func TestRaceSliceVarWrite(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	go func() {
  		s[3] = 3
  		c <- true
  	}()
  	s = make([]int, 20)
  	<-c
  }
  
  func TestRaceSliceVarRead(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	go func() {
  		_ = s[3]
  		c <- true
  	}()
  	s = make([]int, 20)
  	<-c
  }
  
  func TestRaceSliceVarRange(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	go func() {
  		for range s {
  		}
  		c <- true
  	}()
  	s = make([]int, 20)
  	<-c
  }
  
  func TestRaceSliceVarAppend(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	go func() {
  		_ = append(s, 10)
  		c <- true
  	}()
  	s = make([]int, 20)
  	<-c
  }
  
  func TestRaceSliceVarCopy(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	go func() {
  		s2 := make([]int, 10)
  		copy(s, s2)
  		c <- true
  	}()
  	s = make([]int, 20)
  	<-c
  }
  
  func TestRaceSliceVarCopy2(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	go func() {
  		s2 := make([]int, 10)
  		copy(s2, s)
  		c <- true
  	}()
  	s = make([]int, 20)
  	<-c
  }
  
  func TestRaceSliceAppend(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10, 20)
  	go func() {
  		_ = append(s, 1)
  		c <- true
  	}()
  	_ = append(s, 2)
  	<-c
  }
  
  func TestRaceSliceAppendWrite(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	go func() {
  		_ = append(s, 1)
  		c <- true
  	}()
  	s[0] = 42
  	<-c
  }
  
  func TestRaceSliceAppendSlice(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	go func() {
  		s2 := make([]int, 10)
  		_ = append(s, s2...)
  		c <- true
  	}()
  	s[0] = 42
  	<-c
  }
  
  func TestRaceSliceAppendSlice2(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	s2foobar := make([]int, 10)
  	go func() {
  		_ = append(s, s2foobar...)
  		c <- true
  	}()
  	s2foobar[5] = 42
  	<-c
  }
  
  func TestRaceSliceAppendString(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]byte, 10)
  	go func() {
  		_ = append(s, "qwerty"...)
  		c <- true
  	}()
  	s[0] = 42
  	<-c
  }
  
  func TestRacePointerSliceAppend(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]*int, 10, 20)
  	go func() {
  		_ = append(s, new(int))
  		c <- true
  	}()
  	_ = append(s, new(int))
  	<-c
  }
  
  func TestRacePointerSliceAppendWrite(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]*int, 10)
  	go func() {
  		_ = append(s, new(int))
  		c <- true
  	}()
  	s[0] = new(int)
  	<-c
  }
  
  func TestRacePointerSliceAppendSlice(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]*int, 10)
  	go func() {
  		s2 := make([]*int, 10)
  		_ = append(s, s2...)
  		c <- true
  	}()
  	s[0] = new(int)
  	<-c
  }
  
  func TestRacePointerSliceAppendSlice2(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]*int, 10)
  	s2foobar := make([]*int, 10)
  	go func() {
  		_ = append(s, s2foobar...)
  		c <- true
  	}()
  	println("WRITE:", &s2foobar[5])
  	s2foobar[5] = nil
  	<-c
  }
  
  func TestNoRaceSliceIndexAccess(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	v := 0
  	go func() {
  		_ = v
  		c <- true
  	}()
  	s[v] = 1
  	<-c
  }
  
  func TestNoRaceSliceIndexAccess2(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	v := 0
  	go func() {
  		_ = v
  		c <- true
  	}()
  	_ = s[v]
  	<-c
  }
  
  func TestRaceSliceIndexAccess(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	v := 0
  	go func() {
  		v = 1
  		c <- true
  	}()
  	s[v] = 1
  	<-c
  }
  
  func TestRaceSliceIndexAccess2(t *testing.T) {
  	c := make(chan bool, 1)
  	s := make([]int, 10)
  	v := 0
  	go func() {
  		v = 1
  		c <- true
  	}()
  	_ = s[v]
  	<-c
  }
  
  func TestRaceSliceByteToString(t *testing.T) {
  	c := make(chan string)
  	s := make([]byte, 10)
  	go func() {
  		c <- string(s)
  	}()
  	s[0] = 42
  	<-c
  }
  
  func TestRaceSliceRuneToString(t *testing.T) {
  	c := make(chan string)
  	s := make([]rune, 10)
  	go func() {
  		c <- string(s)
  	}()
  	s[9] = 42
  	<-c
  }
  
  func TestRaceConcatString(t *testing.T) {
  	s := "hello"
  	c := make(chan string, 1)
  	go func() {
  		c <- s + " world"
  	}()
  	s = "world"
  	<-c
  }
  
  func TestRaceCompareString(t *testing.T) {
  	s1 := "hello"
  	s2 := "world"
  	c := make(chan bool, 1)
  	go func() {
  		c <- s1 == s2
  	}()
  	s1 = s2
  	<-c
  }
  
  func TestRaceSlice3(t *testing.T) {
  	done := make(chan bool)
  	x := make([]int, 10)
  	i := 2
  	go func() {
  		i = 3
  		done <- true
  	}()
  	_ = x[:1:i]
  	<-done
  }
  

View as plain text