Bypass Manager Pro

Editing: waitgroup_test.go

// 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 (
	"runtime"
	"sync"
	"testing"
	"time"
)

func TestNoRaceWaitGroup(t *testing.T) {
	var x int
	_ = x
	var wg sync.WaitGroup
	n := 1
	for i := 0; i < n; i++ {
		wg.Add(1)
		j := i
		go func() {
			x = j
			wg.Done()
		}()
	}
	wg.Wait()
}

func TestRaceWaitGroup(t *testing.T) {
	var x int
	_ = x
	var wg sync.WaitGroup
	n := 2
	for i := 0; i < n; i++ {
		wg.Add(1)
		j := i
		go func() {
			x = j
			wg.Done()
		}()
	}
	wg.Wait()
}

func TestNoRaceWaitGroup2(t *testing.T) {
	var x int
	_ = x
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		x = 1
		wg.Done()
	}()
	wg.Wait()
	x = 2
}

// incrementing counter in Add and locking wg's mutex
func TestRaceWaitGroupAsMutex(t *testing.T) {
	var x int
	_ = x
	var wg sync.WaitGroup
	c := make(chan bool, 2)
	go func() {
		wg.Wait()
		time.Sleep(100 * time.Millisecond)
		wg.Add(+1)
		x = 1
		wg.Add(-1)
		c <- true
	}()
	go func() {
		wg.Wait()
		time.Sleep(100 * time.Millisecond)
		wg.Add(+1)
		x = 2
		wg.Add(-1)
		c <- true
	}()
	<-c
	<-c
}

// Incorrect usage: Add is too late.
func TestRaceWaitGroupWrongWait(t *testing.T) {
	c := make(chan bool, 2)
	var x int
	_ = x
	var wg sync.WaitGroup
	go func() {
		wg.Add(1)
		runtime.Gosched()
		x = 1
		wg.Done()
		c <- true
	}()
	go func() {
		wg.Add(1)
		runtime.Gosched()
		x = 2
		wg.Done()
		c <- true
	}()
	wg.Wait()
	<-c
	<-c
}

func TestRaceWaitGroupWrongAdd(t *testing.T) {
	c := make(chan bool, 2)
	var wg sync.WaitGroup
	go func() {
		wg.Add(1)
		time.Sleep(100 * time.Millisecond)
		wg.Done()
		c <- true
	}()
	go func() {
		wg.Add(1)
		time.Sleep(100 * time.Millisecond)
		wg.Done()
		c <- true
	}()
	time.Sleep(50 * time.Millisecond)
	wg.Wait()
	<-c
	<-c
}

func TestNoRaceWaitGroupMultipleWait(t *testing.T) {
	c := make(chan bool, 2)
	var wg sync.WaitGroup
	go func() {
		wg.Wait()
		c <- true
	}()
	go func() {
		wg.Wait()
		c <- true
	}()
	wg.Wait()
	<-c
	<-c
}

func TestNoRaceWaitGroupMultipleWait2(t *testing.T) {
	c := make(chan bool, 2)
	var wg sync.WaitGroup
	wg.Add(2)
	go func() {
		wg.Done()
		wg.Wait()
		c <- true
	}()
	go func() {
		wg.Done()
		wg.Wait()
		c <- true
	}()
	wg.Wait()
	<-c
	<-c
}

func TestNoRaceWaitGroupMultipleWait3(t *testing.T) {
	const P = 3
	var data [P]int
	done := make(chan bool, P)
	var wg sync.WaitGroup
	wg.Add(P)
	for p := 0; p < P; p++ {
		go func(p int) {
			data[p] = 42
			wg.Done()
		}(p)
	}
	for p := 0; p < P; p++ {
		go func() {
			wg.Wait()
			for p1 := 0; p1 < P; p1++ {
				_ = data[p1]
			}
			done <- true
		}()
	}
	for p := 0; p < P; p++ {
		<-done
	}
}

// Correct usage but still a race
func TestRaceWaitGroup2(t *testing.T) {
	var x int
	_ = x
	var wg sync.WaitGroup
	wg.Add(2)
	go func() {
		x = 1
		wg.Done()
	}()
	go func() {
		x = 2
		wg.Done()
	}()
	wg.Wait()
}

func TestNoRaceWaitGroupPanicRecover(t *testing.T) {
	var x int
	_ = x
	var wg sync.WaitGroup
	defer func() {
		err := recover()
		if err != "sync: negative WaitGroup counter" {
			t.Fatalf("Unexpected panic: %#v", err)
		}
		x = 2
	}()
	x = 1
	wg.Add(-1)
}

// TODO: this is actually a panic-synchronization test, not a
// WaitGroup test. Move it to another *_test file
// Is it possible to get a race by synchronization via panic?
func TestNoRaceWaitGroupPanicRecover2(t *testing.T) {
	var x int
	_ = x
	var wg sync.WaitGroup
	ch := make(chan bool, 1)
	var f func() = func() {
		x = 2
		ch <- true
	}
	go func() {
		defer func() {
			err := recover()
			if err != "sync: negative WaitGroup counter" {
			}
			go f()
		}()
		x = 1
		wg.Add(-1)
	}()

<-ch
}

func TestNoRaceWaitGroupTransitive(t *testing.T) {
	x, y := 0, 0
	var wg sync.WaitGroup
	wg.Add(2)
	go func() {
		x = 42
		wg.Done()
	}()
	go func() {
		time.Sleep(1e7)
		y = 42
		wg.Done()
	}()
	wg.Wait()
	_ = x
	_ = y
}

func TestNoRaceWaitGroupReuse(t *testing.T) {
	const P = 3
	var data [P]int
	var wg sync.WaitGroup
	for try := 0; try < 3; try++ {
		wg.Add(P)
		for p := 0; p < P; p++ {
			go func(p int) {
				data[p]++
				wg.Done()
			}(p)
		}
		wg.Wait()
		for p := 0; p < P; p++ {
			data[p]++
		}
	}
}

func TestNoRaceWaitGroupReuse2(t *testing.T) {
	const P = 3
	var data [P]int
	var wg sync.WaitGroup
	for try := 0; try < 3; try++ {
		wg.Add(P)
		for p := 0; p < P; p++ {
			go func(p int) {
				data[p]++
				wg.Done()
			}(p)
		}
		done := make(chan bool)
		go func() {
			wg.Wait()
			for p := 0; p < P; p++ {
				data[p]++
			}
			done <- true
		}()
		wg.Wait()
		<-done
		for p := 0; p < P; p++ {
			data[p]++
		}
	}
}

func TestRaceWaitGroupReuse(t *testing.T) {
	const P = 3
	const T = 3
	done := make(chan bool, T)
	var wg sync.WaitGroup
	for try := 0; try < T; try++ {
		var data [P]int
		wg.Add(P)
		for p := 0; p < P; p++ {
			go func(p int) {
				time.Sleep(50 * time.Millisecond)
				data[p]++
				wg.Done()
			}(p)
		}
		go func() {
			wg.Wait()
			for p := 0; p < P; p++ {
				data[p]++
			}
			done <- true
		}()
		time.Sleep(100 * time.Millisecond)
		wg.Wait()
	}
	for try := 0; try < T; try++ {
		<-done
	}
}

func TestNoRaceWaitGroupConcurrentAdd(t *testing.T) {
	const P = 4
	waiting := make(chan bool, P)
	var wg sync.WaitGroup
	for p := 0; p < P; p++ {
		go func() {
			wg.Add(1)
			waiting <- true
			wg.Done()
		}()
	}
	for p := 0; p < P; p++ {
		<-waiting
	}
	wg.Wait()
}

BATAL