// Copyright 2011 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 (
	"bytes"
	"crypto/sha1"
	"errors"
	"fmt"
	"io"
	"os"
	"runtime"
	"sync"
	"testing"
	"time"
	"unsafe"
)

type Point struct {
	x, y int
}

type NamedPoint struct {
	name string
	p    Point
}

type DummyWriter struct {
	state int
}
type Writer interface {
	Write(p []byte) (n int)
}

func (d DummyWriter) Write(p []byte) (n int) {
	return 0
}

var GlobalX, GlobalY int = 0, 0
var GlobalCh chan int = make(chan int, 2)

func GlobalFunc1() {
	GlobalY = GlobalX
	GlobalCh <- 1
}

func GlobalFunc2() {
	GlobalX = 1
	GlobalCh <- 1
}

func TestRaceIntRWGlobalFuncs(t *testing.T) {
	go GlobalFunc1()
	go GlobalFunc2()
	<-GlobalCh
	<-GlobalCh
}

func TestRaceIntRWClosures(t *testing.T) {
	var x, y int
	ch := make(chan int, 2)

	go func() {
		y = x
		ch <- 1
	}()
	go func() {
		x = 1
		ch <- 1
	}()
	<-ch
	<-ch
}

func TestNoRaceIntRWClosures(t *testing.T) {
	var x, y int
	ch := make(chan int, 1)

	go func() {
		y = x
		ch <- 1
	}()
	<-ch
	go func() {
		x = 1
		ch <- 1
	}()
	<-ch

}

func TestRaceInt32RWClosures(t *testing.T) {
	var x, y int32
	ch := make(chan bool, 2)

	go func() {
		y = x
		ch <- true
	}()
	go func() {
		x = 1
		ch <- true
	}()
	<-ch
	<-ch
}

func TestNoRaceCase(t *testing.T) {
	var y int
	for x := -1; x <= 1; x++ {
		switch {
		case x < 0:
			y = -1
		case x == 0:
			y = 0
		case x > 0:
			y = 1
		}
	}
	y++
}

func TestRaceCaseCondition(t *testing.T) {
	var x int = 0
	ch := make(chan int, 2)

	go func() {
		x = 2
		ch <- 1
	}()
	go func() {
		switch x < 2 {
		case true:
			x = 1
			//case false:
			//	x = 5
		}
		ch <- 1
	}()
	<-ch
	<-ch
}

func TestRaceCaseCondition2(t *testing.T) {
	// switch body is rearranged by the compiler so the tests
	// passes even if we don't instrument '<'
	var x int = 0
	ch := make(chan int, 2)

	go func() {
		x = 2
		ch <- 1
	}()
	go func() {
		switch x < 2 {
		case true:
			x = 1
		case false:
			x = 5
		}
		ch <- 1
	}()
	<-ch
	<-ch
}

func TestRaceCaseBody(t *testing.T) {
	var x, y int
	ch := make(chan int, 2)

	go func() {
		y = x
		ch <- 1
	}()
	go func() {
		switch {
		default:
			x = 1
		case x == 100:
			x = -x
		}
		ch <- 1
	}()
	<-ch
	<-ch
}

func TestNoRaceCaseFallthrough(t *testing.T) {
	var x, y, z int
	ch := make(chan int, 2)
	z = 1

	go func() {
		y = x
		ch <- 1
	}()
	go func() {
		switch {
		case z == 1:
		case z == 2:
			x = 2
		}
		ch <- 1
	}()
	<-ch
	<-ch
}

func TestRaceCaseFallthrough(t *testing.T) {
	var x, y, z int
	ch := make(chan int, 2)
	z = 1

	go func() {
		y = x
		ch <- 1
	}()
	go func() {
		switch {
		case z == 1:
			fallthrough
		case z == 2:
			x = 2
		}
		ch <- 1
	}()

	<-ch
	<-ch
}

func TestRaceCaseIssue6418(t *testing.T) {
	m := map[string]map[string]string{
		"a": {
			"b": "c",
		},
	}
	ch := make(chan int)
	go func() {
		m["a"]["x"] = "y"
		ch <- 1
	}()
	switch m["a"]["b"] {
	}
	<-ch
}

func TestRaceCaseType(t *testing.T) {
	var x, y int
	var i interface{} = x
	c := make(chan int, 1)
	go func() {
		switch i.(type) {
		case nil:
		case int:
		}
		c <- 1
	}()
	i = y
	<-c
}

func TestRaceCaseTypeBody(t *testing.T) {
	var x, y int
	var i interface{} = &x
	c := make(chan int, 1)
	go func() {
		switch i := i.(type) {
		case nil:
		case *int:
			*i = y
		}
		c <- 1
	}()
	x = y
	<-c
}

func TestRaceCaseTypeIssue5890(t *testing.T) {
	// spurious extra instrumentation of the initial interface
	// value.
	var x, y int
	m := make(map[int]map[int]interface{})
	m[0] = make(map[int]interface{})
	c := make(chan int, 1)
	go func() {
		switch i := m[0][1].(type) {
		case nil:
		case *int:
			*i = x
		}
		c <- 1
	}()
	m[0][1] = y
	<-c
}

func TestNoRaceRange(t *testing.T) {
	ch := make(chan int, 3)
	a := [...]int{1, 2, 3}
	for _, v := range a {
		ch <- v
	}
	close(ch)
}

func TestNoRaceRangeIssue5446(t *testing.T) {
	ch := make(chan int, 3)
	a := []int{1, 2, 3}
	b := []int{4}
	// used to insert a spurious instrumentation of a[i]
	// and crash.
	i := 1
	for i, a[i] = range b {
		ch <- i
	}
	close(ch)
}

func TestRaceRange(t *testing.T) {
	const N = 2
	var a [N]int
	var x, y int
	done := make(chan bool, N)
	for i, v := range a {
		go func(i int) {
			// we don't want a write-vs-write race
			// so there is no array b here
			if i == 0 {
				x = v
			} else {
				y = v
			}
			done <- true
		}(i)
		// Ensure the goroutine runs before we continue the loop.
		runtime.Gosched()
	}
	for i := 0; i < N; i++ {
		<-done
	}
}

func TestRaceForInit(t *testing.T) {
	c := make(chan int)
	x := 0
	go func() {
		c <- x
	}()
	for x = 42; false; {
	}
	<-c
}

func TestNoRaceForInit(t *testing.T) {
	done := make(chan bool)
	c := make(chan bool)
	x := 0
	go func() {
		for {
			_, ok := <-c
			if !ok {
				done <- true
				return
			}
			x++
		}
	}()
	i := 0
	for x = 42; i < 10; i++ {
		c <- true
	}
	close(c)
	<-done
}

func TestRaceForTest(t *testing.T) {
	done := make(chan bool)
	c := make(chan bool)
	stop := false
	go func() {
		for {
			_, ok := <-c
			if !ok {
				done <- true
				return
			}
			stop = true
		}
	}()
	for !stop {
		c <- true
	}
	close(c)
	<-done
}

func TestRaceForIncr(t *testing.T) {
	done := make(chan bool)
	c := make(chan bool)
	x := 0
	go func() {
		for {
			_, ok := <-c
			if !ok {
				done <- true
				return
			}
			x++
		}
	}()
	for i := 0; i < 10; x++ {
		i++
		c <- true
	}
	close(c)
	<-done
}

func TestNoRaceForIncr(t *testing.T) {
	done := make(chan bool)
	x := 0
	go func() {
		x++
		done <- true
	}()
	for i := 0; i < 0; x++ {
	}
	<-done
}

func TestRacePlus(t *testing.T) {
	var x, y, z int
	ch := make(chan int, 2)

	go func() {
		y = x + z
		ch <- 1
	}()
	go func() {
		y = x + z + z
		ch <- 1
	}()
	<-ch
	<-ch
}

func TestRacePlus2(t *testing.T) {
	var x, y, z int
	ch := make(chan int, 2)

	go func() {
		x = 1
		ch <- 1
	}()
	go func() {
		y = +x + z
		ch <- 1
	}()
	<-ch
	<-ch
}

func TestNoRacePlus(t *testing.T) {
	var x, y, z, f int
	ch := make(chan int, 2)

	go func() {
		y = x + z
		ch <- 1
	}()
	go func() {
		f = z + x
		ch <- 1
	}()
	<-ch
	<-ch
}

func TestRaceComplement(t *testing.T) {
	var x, y, z int
	ch := make(chan int, 2)

	go func() {
		x = ^y
		ch <- 1
	}()
	go func() {
		y = ^z
		ch <- 1
	}()
	<-ch
	<-ch
}

func TestRaceDiv(t *testing.T) {
	var x, y, z int
	ch := make(chan int, 2)

	go func() {
		x = y / (z + 1)
		ch <- 1
	}()
	go func() {
		y = z
		ch <- 1
	}()
	<-ch
	<-ch
}

func TestRaceDivConst(t *testing.T) {
	var x, y, z uint32
	ch := make(chan int, 2)

	go func() {
		x = y / 3 // involves only a HMUL node
		ch <- 1
	}()
	go func() {
		y = z
		ch <- 1
	}()
	<-ch
	<-ch
}

func TestRaceMod(t *testing.T) {
	var x, y, z int
	ch := make(chan int, 2)

	go func() {
		x = y % (z + 1)
		ch <- 1
	}()
	go func() {
		y = z
		ch <- 1
	}()
	<-ch
	<-ch
}

func TestRaceModConst(t *testing.T) {
	var x, y, z int
	ch := make(chan int, 2)

	go func() {
		x = y % 3
		ch <- 1
	}()
	go func() {
		y = z
		ch <- 1
	}()
	<-ch
	<-ch
}

func TestRaceRotate(t *testing.T) {
	var x, y, z uint32
	ch := make(chan int, 2)

	go func() {
		x = y<<12 | y>>20
		ch <- 1
	}()
	go func() {
		y = z
		ch <- 1
	}()
	<-ch
	<-ch
}

// May crash if the instrumentation is reckless.
func TestNoRaceEnoughRegisters(t *testing.T) {
	// from erf.go
	const (
		sa1 = 1
		sa2 = 2
		sa3 = 3
		sa4 = 4
		sa5 = 5
		sa6 = 6
		sa7 = 7
		sa8 = 8
	)
	var s, S float64
	s = 3.1415
	S = 1 + s*(sa1+s*(sa2+s*(sa3+s*(sa4+s*(sa5+s*(sa6+s*(sa7+s*sa8)))))))
	s = S
}

// emptyFunc should not be inlined.
func emptyFunc(x int) {
	if false {
		fmt.Println(x)
	}
}

func TestRaceFuncArgument(t *testing.T) {
	var x int
	ch := make(chan bool, 1)
	go func() {
		emptyFunc(x)
		ch <- true
	}()
	x = 1
	<-ch
}

func TestRaceFuncArgument2(t *testing.T) {
	var x int
	ch := make(chan bool, 2)
	go func() {
		x = 42
		ch <- true
	}()
	go func(y int) {
		ch <- true
	}(x)
	<-ch
	<-ch
}

func TestRaceSprint(t *testing.T) {
	var x int
	ch := make(chan bool, 1)
	go func() {
		fmt.Sprint(x)
		ch <- true
	}()
	x = 1
	<-ch
}

func TestRaceArrayCopy(t *testing.T) {
	ch := make(chan bool, 1)
	var a [5]int
	go func() {
		a[3] = 1
		ch <- true
	}()
	a = [5]int{1, 2, 3, 4, 5}
	<-ch
}

// Blows up a naive compiler.
func TestRaceNestedArrayCopy(t *testing.T) {
	ch := make(chan bool, 1)
	type (
		Point32   [2][2][2][2][2]Point
		Point1024 [2][2][2][2][2]Point32
		Point32k  [2][2][2][2][2]Point1024
		Point1M   [2][2][2][2][2]Point32k
	)
	var a, b Point1M
	go func() {
		a[0][1][0][1][0][1][0][1][0][1][0][1][0][1][0][1][0][1][0][1].y = 1
		ch <- true
	}()
	a = b
	<-ch
}

func TestRaceStructRW(t *testing.T) {
	p := Point{0, 0}
	ch := make(chan bool, 1)
	go func() {
		p = Point{1, 1}
		ch <- true
	}()
	q := p
	<-ch
	p = q
}

func TestRaceStructFieldRW1(t *testing.T) {
	p := Point{0, 0}
	ch := make(chan bool, 1)
	go func() {
		p.x = 1
		ch <- true
	}()
	_ = p.x
	<-ch
}

func TestNoRaceStructFieldRW1(t *testing.T) {
	// Same struct, different variables, no
	// pointers. The layout is known (at compile time?) ->
	// no read on p
	// writes on x and y
	p := Point{0, 0}
	ch := make(chan bool, 1)
	go func() {
		p.x = 1
		ch <- true
	}()
	p.y = 1
	<-ch
	_ = p
}

func TestNoRaceStructFieldRW2(t *testing.T) {
	// Same as NoRaceStructFieldRW1
	// but p is a pointer, so there is a read on p
	p := Point{0, 0}
	ch := make(chan bool, 1)
	go func() {
		p.x = 1
		ch <- true
	}()
	p.y = 1
	<-ch
	_ = p
}

func TestRaceStructFieldRW2(t *testing.T) {
	p := &Point{0, 0}
	ch := make(chan bool, 1)
	go func() {
		p.x = 1
		ch <- true
	}()
	_ = p.x
	<-ch
}

func TestRaceStructFieldRW3(t *testing.T) {
	p := NamedPoint{name: "a", p: Point{0, 0}}
	ch := make(chan bool, 1)
	go func() {
		p.p.x = 1
		ch <- true
	}()
	_ = p.p.x
	<-ch
}

func TestRaceEfaceWW(t *testing.T) {
	var a, b interface{}
	ch := make(chan bool, 1)
	go func() {
		a = 1
		ch <- true
	}()
	a = 2
	<-ch
	_, _ = a, b
}

func TestRaceIfaceWW(t *testing.T) {
	var a, b Writer
	ch := make(chan bool, 1)
	go func() {
		a = DummyWriter{1}
		ch <- true
	}()
	a = DummyWriter{2}
	<-ch
	b = a
	a = b
}

func TestRaceIfaceCmp(t *testing.T) {
	var a, b Writer
	a = DummyWriter{1}
	ch := make(chan bool, 1)
	go func() {
		a = DummyWriter{1}
		ch <- true
	}()
	_ = a == b
	<-ch
}

func TestRaceIfaceCmpNil(t *testing.T) {
	var a Writer
	a = DummyWriter{1}
	ch := make(chan bool, 1)
	go func() {
		a = DummyWriter{1}
		ch <- true
	}()
	_ = a == nil
	<-ch
}

func TestRaceEfaceConv(t *testing.T) {
	c := make(chan bool)
	v := 0
	go func() {
		go func(x interface{}) {
		}(v)
		c <- true
	}()
	v = 42
	<-c
}

type OsFile struct{}

func (*OsFile) Read() {
}

type IoReader interface {
	Read()
}

func TestRaceIfaceConv(t *testing.T) {
	c := make(chan bool)
	f := &OsFile{}
	go func() {
		go func(x IoReader) {
		}(f)
		c <- true
	}()
	f = &OsFile{}
	<-c
}

func TestRaceError(t *testing.T) {
	ch := make(chan bool, 1)
	var err error
	go func() {
		err = nil
		ch <- true
	}()
	_ = err
	<-ch
}

func TestRaceIntptrRW(t *testing.T) {
	var x, y int
	var p *int = &x
	ch := make(chan bool, 1)
	go func() {
		*p = 5
		ch <- true
	}()
	y = *p
	x = y
	<-ch
}

func TestRaceStringRW(t *testing.T) {
	ch := make(chan bool, 1)
	s := ""
	go func() {
		s = "abacaba"
		ch <- true
	}()
	_ = s
	<-ch
}

func TestRaceStringPtrRW(t *testing.T) {
	ch := make(chan bool, 1)
	var x string
	p := &x
	go func() {
		*p = "a"
		ch <- true
	}()
	_ = *p
	<-ch
}

func TestRaceFloat64WW(t *testing.T) {
	var x, y float64
	ch := make(chan bool, 1)
	go func() {
		x = 1.0
		ch <- true
	}()
	x = 2.0
	<-ch

	y = x
	x = y
}

func TestRaceComplex128WW(t *testing.T) {
	var x, y complex128
	ch := make(chan bool, 1)
	go func() {
		x = 2 + 2i
		ch <- true
	}()
	x = 4 + 4i
	<-ch

	y = x
	x = y
}

func TestRaceUnsafePtrRW(t *testing.T) {
	var x, y, z int
	x, y, z = 1, 2, 3
	var p unsafe.Pointer = unsafe.Pointer(&x)
	ch := make(chan bool, 1)
	go func() {
		p = (unsafe.Pointer)(&z)
		ch <- true
	}()
	y = *(*int)(p)
	x = y
	<-ch
}

func TestRaceFuncVariableRW(t *testing.T) {
	var f func(x int) int
	f = func(x int) int {
		return x * x
	}
	ch := make(chan bool, 1)
	go func() {
		f = func(x int) int {
			return x
		}
		ch <- true
	}()
	y := f(1)
	<-ch
	x := y
	y = x
}

func TestRaceFuncVariableWW(t *testing.T) {
	var f func(x int) int
	ch := make(chan bool, 1)
	go func() {
		f = func(x int) int {
			return x
		}
		ch <- true
	}()
	f = func(x int) int {
		return x * x
	}
	<-ch
}

// This one should not belong to mop_test
func TestRacePanic(t *testing.T) {
	var x int
	var zero int = 0
	ch := make(chan bool, 2)
	go func() {
		defer func() {
			err := recover()
			if err == nil {
				panic("should be panicking")
			}
			x = 1
			ch <- true
		}()
		var y int = 1 / zero
		zero = y
	}()
	go func() {
		defer func() {
			err := recover()
			if err == nil {
				panic("should be panicking")
			}
			x = 2
			ch <- true
		}()
		var y int = 1 / zero
		zero = y
	}()

	<-ch
	<-ch
	if zero != 0 {
		panic("zero has changed")
	}
}

func TestNoRaceBlank(t *testing.T) {
	var a [5]int
	ch := make(chan bool, 1)
	go func() {
		_, _ = a[0], a[1]
		ch <- true
	}()
	_, _ = a[2], a[3]
	<-ch
	a[1] = a[0]
}

func TestRaceAppendRW(t *testing.T) {
	a := make([]int, 10)
	ch := make(chan bool)
	go func() {
		_ = append(a, 1)
		ch <- true
	}()
	a[0] = 1
	<-ch
}

func TestRaceAppendLenRW(t *testing.T) {
	a := make([]int, 0)
	ch := make(chan bool)
	go func() {
		a = append(a, 1)
		ch <- true
	}()
	_ = len(a)
	<-ch
}

func TestRaceAppendCapRW(t *testing.T) {
	a := make([]int, 0)
	ch := make(chan string)
	go func() {
		a = append(a, 1)
		ch <- ""
	}()
	_ = cap(a)
	<-ch
}

func TestNoRaceFuncArgsRW(t *testing.T) {
	ch := make(chan byte, 1)
	var x byte
	go func(y byte) {
		_ = y
		ch <- 0
	}(x)
	x = 1
	<-ch
}

func TestRaceFuncArgsRW(t *testing.T) {
	ch := make(chan byte, 1)
	var x byte
	go func(y *byte) {
		_ = *y
		ch <- 0
	}(&x)
	x = 1
	<-ch
}

// from the mailing list, slightly modified
// unprotected concurrent access to seen[]
func TestRaceCrawl(t *testing.T) {
	url := "dummyurl"
	depth := 3
	seen := make(map[string]bool)
	ch := make(chan int, 100)
	var wg sync.WaitGroup
	var crawl func(string, int)
	crawl = func(u string, d int) {
		nurl := 0
		defer func() {
			ch <- nurl
		}()
		seen[u] = true
		if d <= 0 {
			wg.Done()
			return
		}
		urls := [...]string{"a", "b", "c"}
		for _, uu := range urls {
			if _, ok := seen[uu]; !ok {
				wg.Add(1)
				go crawl(uu, d-1)
				nurl++
			}
		}
		wg.Done()
	}
	wg.Add(1)
	go crawl(url, depth)
	wg.Wait()
}

func TestRaceIndirection(t *testing.T) {
	ch := make(chan struct{}, 1)
	var y int
	var x *int = &y
	go func() {
		*x = 1
		ch <- struct{}{}
	}()
	*x = 2
	<-ch
	_ = *x
}

func TestRaceRune(t *testing.T) {
	c := make(chan bool)
	var x rune
	go func() {
		x = 1
		c <- true
	}()
	_ = x
	<-c
}

func TestRaceEmptyInterface1(t *testing.T) {
	c := make(chan bool)
	var x interface{}
	go func() {
		x = nil
		c <- true
	}()
	_ = x
	<-c
}

func TestRaceEmptyInterface2(t *testing.T) {
	c := make(chan bool)
	var x interface{}
	go func() {
		x = &Point{}
		c <- true
	}()
	_ = x
	<-c
}

func TestRaceTLS(t *testing.T) {
	comm := make(chan *int)
	done := make(chan bool, 2)
	go func() {
		var x int
		comm <- &x
		x = 1
		x = *(<-comm)
		done <- true
	}()
	go func() {
		p := <-comm
		*p = 2
		comm <- p
		done <- true
	}()
	<-done
	<-done
}

func TestNoRaceHeapReallocation(t *testing.T) {
	// It is possible that a future implementation
	// of memory allocation will ruin this test.
	// Increasing n might help in this case, so
	// this test is a bit more generic than most of the
	// others.
	const n = 2
	done := make(chan bool, n)
	empty := func(p *int) {}
	for i := 0; i < n; i++ {
		ms := i
		go func() {
			<-time.After(time.Duration(ms) * time.Millisecond)
			runtime.GC()
			var x int
			empty(&x) // x goes to the heap
			done <- true
		}()
	}
	for i := 0; i < n; i++ {
		<-done
	}
}

func TestRaceAnd(t *testing.T) {
	c := make(chan bool)
	x, y := 0, 0
	go func() {
		x = 1
		c <- true
	}()
	if x == 1 && y == 1 {
	}
	<-c
}

func TestRaceAnd2(t *testing.T) {
	c := make(chan bool)
	x, y := 0, 0
	go func() {
		x = 1
		c <- true
	}()
	if y == 0 && x == 1 {
	}
	<-c
}

func TestNoRaceAnd(t *testing.T) {
	c := make(chan bool)
	x, y := 0, 0
	go func() {
		x = 1
		c <- true
	}()
	if y == 1 && x == 1 {
	}
	<-c
}

func TestRaceOr(t *testing.T) {
	c := make(chan bool)
	x, y := 0, 0
	go func() {
		x = 1
		c <- true
	}()
	if x == 1 || y == 1 {
	}
	<-c
}

func TestRaceOr2(t *testing.T) {
	c := make(chan bool)
	x, y := 0, 0
	go func() {
		x = 1
		c <- true
	}()
	if y == 1 || x == 1 {
	}
	<-c
}

func TestNoRaceOr(t *testing.T) {
	c := make(chan bool)
	x, y := 0, 0
	go func() {
		x = 1
		c <- true
	}()
	if y == 0 || x == 1 {
	}
	<-c
}

func TestNoRaceShortCalc(t *testing.T) {
	c := make(chan bool)
	x, y := 0, 0
	go func() {
		y = 1
		c <- true
	}()
	if x == 0 || y == 0 {
	}
	<-c
}

func TestNoRaceShortCalc2(t *testing.T) {
	c := make(chan bool)
	x, y := 0, 0
	go func() {
		y = 1
		c <- true
	}()
	if x == 1 && y == 0 {
	}
	<-c
}

func TestRaceFuncItself(t *testing.T) {
	c := make(chan bool)
	f := func() {}
	go func() {
		f()
		c <- true
	}()
	f = func() {}
	<-c
}

func TestNoRaceFuncUnlock(t *testing.T) {
	ch := make(chan bool, 1)
	var mu sync.Mutex
	x := 0
	go func() {
		mu.Lock()
		x = 42
		mu.Unlock()
		ch <- true
	}()
	x = func(mu *sync.Mutex) int {
		mu.Lock()
		return 43
	}(&mu)
	mu.Unlock()
	<-ch
}

func TestRaceStructInit(t *testing.T) {
	type X struct {
		x, y int
	}
	c := make(chan bool, 1)
	y := 0
	go func() {
		y = 42
		c <- true
	}()
	x := X{x: y}
	_ = x
	<-c
}

func TestRaceArrayInit(t *testing.T) {
	c := make(chan bool, 1)
	y := 0
	go func() {
		y = 42
		c <- true
	}()
	x := []int{0, y, 42}
	_ = x
	<-c
}

func TestRaceMapInit(t *testing.T) {
	c := make(chan bool, 1)
	y := 0
	go func() {
		y = 42
		c <- true
	}()
	x := map[int]int{0: 42, y: 42}
	_ = x
	<-c
}

func TestRaceMapInit2(t *testing.T) {
	c := make(chan bool, 1)
	y := 0
	go func() {
		y = 42
		c <- true
	}()
	x := map[int]int{0: 42, 42: y}
	_ = x
	<-c
}

type Inter interface {
	Foo(x int)
}
type InterImpl struct {
	x, y int
}

func (p InterImpl) Foo(x int) {
	// prevent inlining
	z := 42
	x = 85
	y := x / z
	z = y * z
	x = z * y
	_, _, _ = x, y, z
}

type InterImpl2 InterImpl

func (p *InterImpl2) Foo(x int) {
	if p == nil {
		InterImpl{}.Foo(x)
	}
	InterImpl(*p).Foo(x)
}

func TestRaceInterCall(t *testing.T) {
	c := make(chan bool, 1)
	p := InterImpl{}
	var x Inter = p
	go func() {
		p2 := InterImpl{}
		x = p2
		c <- true
	}()
	x.Foo(0)
	<-c
}

func TestRaceInterCall2(t *testing.T) {
	c := make(chan bool, 1)
	p := InterImpl{}
	var x Inter = p
	z := 0
	go func() {
		z = 42
		c <- true
	}()
	x.Foo(z)
	<-c
}

func TestRaceFuncCall(t *testing.T) {
	c := make(chan bool, 1)
	f := func(x, y int) {}
	x, y := 0, 0
	go func() {
		y = 42
		c <- true
	}()
	f(x, y)
	<-c
}

func TestRaceMethodCall(t *testing.T) {
	c := make(chan bool, 1)
	i := InterImpl{}
	x := 0
	go func() {
		x = 42
		c <- true
	}()
	i.Foo(x)
	<-c
}

func TestRaceMethodCall2(t *testing.T) {
	c := make(chan bool, 1)
	i := &InterImpl{}
	go func() {
		i = &InterImpl{}
		c <- true
	}()
	i.Foo(0)
	<-c
}

// Method value with concrete value receiver.
func TestRaceMethodValue(t *testing.T) {
	c := make(chan bool, 1)
	i := InterImpl{}
	go func() {
		i = InterImpl{}
		c <- true
	}()
	_ = i.Foo
	<-c
}

// Method value with interface receiver.
func TestRaceMethodValue2(t *testing.T) {
	c := make(chan bool, 1)
	var i Inter = InterImpl{}
	go func() {
		i = InterImpl{}
		c <- true
	}()
	_ = i.Foo
	<-c
}

// Method value with implicit dereference.
func TestRaceMethodValue3(t *testing.T) {
	c := make(chan bool, 1)
	i := &InterImpl{}
	go func() {
		*i = InterImpl{}
		c <- true
	}()
	_ = i.Foo // dereferences i.
	<-c
}

// Method value implicitly taking receiver address.
func TestNoRaceMethodValue(t *testing.T) {
	c := make(chan bool, 1)
	i := InterImpl2{}
	go func() {
		i = InterImpl2{}
		c <- true
	}()
	_ = i.Foo // takes the address of i only.
	<-c
}

func TestRacePanicArg(t *testing.T) {
	c := make(chan bool, 1)
	err := errors.New("err")
	go func() {
		err = errors.New("err2")
		c <- true
	}()
	defer func() {
		recover()
		<-c
	}()
	panic(err)
}

func TestRaceDeferArg(t *testing.T) {
	c := make(chan bool, 1)
	x := 0
	go func() {
		x = 42
		c <- true
	}()
	func() {
		defer func(x int) {
		}(x)
	}()
	<-c
}

type DeferT int

func (d DeferT) Foo() {
}

func TestRaceDeferArg2(t *testing.T) {
	c := make(chan bool, 1)
	var x DeferT
	go func() {
		var y DeferT
		x = y
		c <- true
	}()
	func() {
		defer x.Foo()
	}()
	<-c
}

func TestNoRaceAddrExpr(t *testing.T) {
	c := make(chan bool, 1)
	x := 0
	go func() {
		x = 42
		c <- true
	}()
	_ = &x
	<-c
}

type AddrT struct {
	_ [256]byte
	x int
}

type AddrT2 struct {
	_ [512]byte
	p *AddrT
}

func TestRaceAddrExpr(t *testing.T) {
	c := make(chan bool, 1)
	a := AddrT2{p: &AddrT{x: 42}}
	go func() {
		a.p = &AddrT{x: 43}
		c <- true
	}()
	_ = &a.p.x
	<-c
}

func TestRaceTypeAssert(t *testing.T) {
	c := make(chan bool, 1)
	x := 0
	var i interface{} = x
	go func() {
		y := 0
		i = y
		c <- true
	}()
	_ = i.(int)
	<-c
}

func TestRaceBlockAs(t *testing.T) {
	c := make(chan bool, 1)
	var x, y int
	go func() {
		x = 42
		c <- true
	}()
	x, y = y, x
	<-c
}

func TestRaceBlockCall1(t *testing.T) {
	done := make(chan bool)
	x, y := 0, 0
	go func() {
		f := func() (int, int) {
			return 42, 43
		}
		x, y = f()
		done <- true
	}()
	_ = x
	<-done
	if x != 42 || y != 43 {
		panic("corrupted data")
	}
}
func TestRaceBlockCall2(t *testing.T) {
	done := make(chan bool)
	x, y := 0, 0
	go func() {
		f := func() (int, int) {
			return 42, 43
		}
		x, y = f()
		done <- true
	}()
	_ = y
	<-done
	if x != 42 || y != 43 {
		panic("corrupted data")
	}
}
func TestRaceBlockCall3(t *testing.T) {
	done := make(chan bool)
	var x *int
	y := 0
	go func() {
		f := func() (*int, int) {
			i := 42
			return &i, 43
		}
		x, y = f()
		done <- true
	}()
	_ = x
	<-done
	if *x != 42 || y != 43 {
		panic("corrupted data")
	}
}
func TestRaceBlockCall4(t *testing.T) {
	done := make(chan bool)
	x := 0
	var y *int
	go func() {
		f := func() (int, *int) {
			i := 43
			return 42, &i
		}
		x, y = f()
		done <- true
	}()
	_ = y
	<-done
	if x != 42 || *y != 43 {
		panic("corrupted data")
	}
}
func TestRaceBlockCall5(t *testing.T) {
	done := make(chan bool)
	var x *int
	y := 0
	go func() {
		f := func() (*int, int) {
			i := 42
			return &i, 43
		}
		x, y = f()
		done <- true
	}()
	_ = y
	<-done
	if *x != 42 || y != 43 {
		panic("corrupted data")
	}
}
func TestRaceBlockCall6(t *testing.T) {
	done := make(chan bool)
	x := 0
	var y *int
	go func() {
		f := func() (int, *int) {
			i := 43
			return 42, &i
		}
		x, y = f()
		done <- true
	}()
	_ = x
	<-done
	if x != 42 || *y != 43 {
		panic("corrupted data")
	}
}
func TestRaceSliceSlice(t *testing.T) {
	c := make(chan bool, 1)
	x := make([]int, 10)
	go func() {
		x = make([]int, 20)
		c <- true
	}()
	_ = x[2:3]
	<-c
}

func TestRaceSliceSlice2(t *testing.T) {
	c := make(chan bool, 1)
	x := make([]int, 10)
	i := 2
	go func() {
		i = 3
		c <- true
	}()
	_ = x[i:4]
	<-c
}

func TestRaceSliceString(t *testing.T) {
	c := make(chan bool, 1)
	x := "hello"
	go func() {
		x = "world"
		c <- true
	}()
	_ = x[2:3]
	<-c
}

func TestRaceSliceStruct(t *testing.T) {
	type X struct {
		x, y int
	}
	c := make(chan bool, 1)
	x := make([]X, 10)
	go func() {
		y := make([]X, 10)
		copy(y, x)
		c <- true
	}()
	x[1].y = 42
	<-c
}

func TestRaceAppendSliceStruct(t *testing.T) {
	type X struct {
		x, y int
	}
	c := make(chan bool, 1)
	x := make([]X, 10)
	go func() {
		y := make([]X, 0, 10)
		y = append(y, x...)
		c <- true
	}()
	x[1].y = 42
	<-c
}

func TestRaceStructInd(t *testing.T) {
	c := make(chan bool, 1)
	type Item struct {
		x, y int
	}
	i := Item{}
	go func(p *Item) {
		*p = Item{}
		c <- true
	}(&i)
	i.y = 42
	<-c
}

func TestRaceAsFunc1(t *testing.T) {
	var s []byte
	c := make(chan bool, 1)
	go func() {
		var err error
		s, err = func() ([]byte, error) {
			t := []byte("hello world")
			return t, nil
		}()
		c <- true
		_ = err
	}()
	_ = string(s)
	<-c
}

func TestRaceAsFunc2(t *testing.T) {
	c := make(chan bool, 1)
	x := 0
	go func() {
		func(x int) {
		}(x)
		c <- true
	}()
	x = 42
	<-c
}

func TestRaceAsFunc3(t *testing.T) {
	c := make(chan bool, 1)
	var mu sync.Mutex
	x := 0
	go func() {
		func(x int) {
			mu.Lock()
		}(x) // Read of x must be outside of the mutex.
		mu.Unlock()
		c <- true
	}()
	mu.Lock()
	x = 42
	mu.Unlock()
	<-c
}

func TestNoRaceAsFunc4(t *testing.T) {
	c := make(chan bool, 1)
	var mu sync.Mutex
	x := 0
	go func() {
		x = func() int { // Write of x must be under the mutex.
			mu.Lock()
			return 42
		}()
		mu.Unlock()
		c <- true
	}()
	mu.Lock()
	x = 42
	mu.Unlock()
	<-c
}

func TestRaceHeapParam(t *testing.T) {
	done := make(chan bool)
	x := func() (x int) {
		go func() {
			x = 42
			done <- true
		}()
		return
	}()
	_ = x
	<-done
}

func TestNoRaceEmptyStruct(t *testing.T) {
	type Empty struct{}
	type X struct {
		y int64
		Empty
	}
	type Y struct {
		x X
		y int64
	}
	c := make(chan X)
	var y Y
	go func() {
		x := y.x
		c <- x
	}()
	y.y = 42
	<-c
}

func TestRaceNestedStruct(t *testing.T) {
	type X struct {
		x, y int
	}
	type Y struct {
		x X
	}
	c := make(chan Y)
	var y Y
	go func() {
		c <- y
	}()
	y.x.y = 42
	<-c
}

func TestRaceIssue5567(t *testing.T) {
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))
	in := make(chan []byte)
	res := make(chan error)
	go func() {
		var err error
		defer func() {
			close(in)
			res <- err
		}()
		path := "mop_test.go"
		f, err := os.Open(path)
		if err != nil {
			return
		}
		defer f.Close()
		var n, total int
		b := make([]byte, 17) // the race is on b buffer
		for err == nil {
			n, err = f.Read(b)
			total += n
			if n > 0 {
				in <- b[:n]
			}
		}
		if err == io.EOF {
			err = nil
		}
	}()
	h := sha1.New()
	for b := range in {
		h.Write(b)
	}
	_ = h.Sum(nil)
	err := <-res
	if err != nil {
		t.Fatal(err)
	}
}

func TestRaceIssue5654(t *testing.T) {
	text := `Friends, Romans, countrymen, lend me your ears;
I come to bury Caesar, not to praise him.
The evil that men do lives after them;
The good is oft interred with their bones;
So let it be with Caesar. The noble Brutus
Hath told you Caesar was ambitious:
If it were so, it was a grievous fault,
And grievously hath Caesar answer'd it.
Here, under leave of Brutus and the rest -
For Brutus is an honourable man;
So are they all, all honourable men -
Come I to speak in Caesar's funeral.
He was my friend, faithful and just to me:
But Brutus says he was ambitious;
And Brutus is an honourable man.`

	data := bytes.NewBufferString(text)
	in := make(chan []byte)

	go func() {
		buf := make([]byte, 16)
		var n int
		var err error
		for ; err == nil; n, err = data.Read(buf) {
			in <- buf[:n]
		}
		close(in)
	}()
	res := ""
	for s := range in {
		res += string(s)
	}
	_ = res
}

type Base int

func (b *Base) Foo() int {
	return 42
}

func (b Base) Bar() int {
	return int(b)
}

func TestNoRaceMethodThunk(t *testing.T) {
	type Derived struct {
		pad int
		Base
	}
	var d Derived
	done := make(chan bool)
	go func() {
		_ = d.Foo()
		done <- true
	}()
	d = Derived{}
	<-done
}

func TestRaceMethodThunk(t *testing.T) {
	type Derived struct {
		pad int
		*Base
	}
	var d Derived
	done := make(chan bool)
	go func() {
		_ = d.Foo()
		done <- true
	}()
	d = Derived{}
	<-done
}

func TestRaceMethodThunk2(t *testing.T) {
	type Derived struct {
		pad int
		Base
	}
	var d Derived
	done := make(chan bool)
	go func() {
		_ = d.Bar()
		done <- true
	}()
	d = Derived{}
	<-done
}

func TestRaceMethodThunk3(t *testing.T) {
	type Derived struct {
		pad int
		*Base
	}
	var d Derived
	d.Base = new(Base)
	done := make(chan bool)
	go func() {
		_ = d.Bar()
		done <- true
	}()
	d.Base = new(Base)
	<-done
}

func TestRaceMethodThunk4(t *testing.T) {
	type Derived struct {
		pad int
		*Base
	}
	var d Derived
	d.Base = new(Base)
	done := make(chan bool)
	go func() {
		_ = d.Bar()
		done <- true
	}()
	*(*int)(d.Base) = 42
	<-done
}

func TestNoRaceTinyAlloc(t *testing.T) {
	const P = 4
	const N = 1e6
	var tinySink *byte
	done := make(chan bool)
	for p := 0; p < P; p++ {
		go func() {
			for i := 0; i < N; i++ {
				var b byte
				if b != 0 {
					tinySink = &b // make it heap allocated
				}
				b = 42
			}
			done <- true
		}()
	}
	for p := 0; p < P; p++ {
		<-done
	}
}
