}

func TestUnionRun(t *testing.T) {
	backends := []Backend{
		&cannotMultipleRunBackend{started: make(chan struct{})},
		&cannotMultipleRunBackend{started: make(chan struct{})},
		&cannotMultipleRunBackend{started: make(chan struct{})},
	}

	b := Union(backends...)

	if err := b.Run(make(chan struct{})); err != nil {
		t.Errorf("union backend run: %v", err)
	}

	`package p; import "fmt"; func f() { fmt.Println("Hello, World!") };`,
	`package p; func f() { if f(T{}) {} };`,
	`package p; func f() { _ = <-chan int(nil) };`,
	`package p; func f() { _ = (<-chan int)(nil) };`,
	`package p; func f() { _ = (<-chan <-chan int)(nil) };`,
	`package p; func f() { _ = <-chan <-chan <-chan <-chan <-int(nil) };`,
	`package p; func f(func() func() func());`,
	`package p; func f(...T);`,
	`package p; func f(float, ...int);`,

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 13265: nil pointer deref.

package p

func f() {
    var c chan chan chan int
    for ; ; <-<-<-c {
    }

        def char1 = left as char
        def char2 = right as char

        expect:
        compareCharsIgnoringCase(char1, char2) == result
        compareCharsIgnoringCase(char2, char1) == -result
        compareChars(char1, char2) == result
        compareChars(char2, char1) == -result
        equalChars(char1, char2, caseSensitivity) == (result == 0)
        equalChars(char2, char1, caseSensitivity) == (result == 0)

}

type imagePuller interface {
	pullImage(context.Context, kubecontainer.ImageSpec, []v1.Secret, chan<- pullResult, *runtimeapi.PodSandboxConfig)
}

var _, _ imagePuller = &parallelImagePuller{}, &serialImagePuller{}

type parallelImagePuller struct {
	imageService kubecontainer.ImageService
	tokens       chan struct{}
}

func _() (x int)
func _() (x int)
func _() (x int)

// special cases: some channel types require parentheses
func _(x chan (<-chan int))
func _(x chan (<-chan int))
func _(x chan (<-chan int))

func _(x chan<- (chan int))
func _(x chan<- (chan int))
func _(x chan<- (chan int))

// don't introduce comma after last parameter if the closing ) is on the same line

	"os"
	"strconv"
)

func f(left, right chan int) {
	left <- <-right
}

func main() {
	var n = 10000
	if len(os.Args) > 1 {
		var err error
		n, err = strconv.Atoi(os.Args[1])
		if err != nil {
			print("bad arg\n")
			os.Exit(1)
		}
	}
	leftmost := make(chan int)
	right := leftmost
	left := leftmost
	for i := 0; i < n; i++ {
		right = make(chan int)
		go f(left, right)
		left = right
	}

	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() {

	isBool(b)
	asBool(!b)
	isBool(!b)
	asBool(true)
	asBool(*&b)
	isBool(*&b)
	asBool(Bool(true))
	isBool(Bool(true))

	asChan(c)
	isChan(c)
	asChan(make(Chan))
	isChan(make(Chan))
	asChan(*&c)
	isChan(*&c)
	asChan(Chan(nil))
	isChan(Chan(nil))

	asFloat(f)
	isFloat(f)
	asFloat(-f)
	isFloat(-f)
	asFloat(+f)
	isFloat(+f)
	asFloat(f + 1)
	isFloat(f + 1)
	asFloat(1 + f)
	isFloat(1 + f)

	// do not have to be related to the file itself.
	watchedFiles map[string]*fileTracker

	// tracker lifecycle
	retireTrackerCh chan *fileTracker

	// tells the worker to exit
	terminateCh chan bool
}

type fileTracker struct {
	events chan fsnotify.Event
	errors chan error

	// Hash sum to indicate if a file has been updated.
	hash []byte
}