`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);`,

	c := make(chan struct{})
	go func() {
		wg.Wait()
		c <- struct{}{}
	}()
	select {
	case <-c:
		return true
	case <-time.After(timeout):
		return false
	}
}

func TestSendPushesManyPushes(t *testing.T) {
	stopCh := make(chan struct{})
	defer close(stopCh)

	semaphore := make(chan struct{}, 2)
	queue := NewPushQueue()
	defer queue.ShutDown()

}

// Signed 64-bit comparison with unsigned 8-bit immediate.
func si64xu8(x chan int64) {
	// s390x:"CLGIJ\t[$]8, R[0-9]+, [$]128, "
	for <-x == 128 {
		dummy()
	}

	// s390x:"CLGIJ\t[$]6, R[0-9]+, [$]255, "
	for <-x != 255 {
		dummy()
	}
}

// Signed 32-bit comparison with unsigned 8-bit immediate.
func si32xu8(x chan int32) {
	// s390x:"CLIJ\t[$]8, R[0-9]+, [$]255, "
	for <-x == 255 {
		dummy()

        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)

// 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 {
    }

}

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{}
}

	// 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
}

}

func goGetExpectNotYet(t *testing.T, wr WriteOnce, gots chan interface{}, trigger string) {
	go func() {
		gots <- wr.Get()
	}()
	select {
	case <-gots:
		t.Errorf("Get returned before %s", trigger)
	case <-time.After(time.Second):
		t.Log("Good: Get did not return yet")
	}
}

func goGetAndExpect(t *testing.T, wr WriteOnce, gots chan interface{}, expected interface{}) {
	go func() {
		gots <- wr.Get()

}

var _ Instance = &instance{}

// New creates a new server Instance.
func New() Instance {
	return &instance{
		done:       make(chan struct{}),
		components: make(chan task, 1000), // should be enough?
	}
}

type instance struct {
	components chan task
	done       chan struct{}

	// requiredTerminations keeps track of tasks that should block instance exit

	})

	go q.Run(stop)

	// wait for the task to run twice.
	wg.Wait()
}

func TestResourceFree(t *testing.T) {
	q := NewQueue(1 * time.Microsecond)
	stop := make(chan struct{})
	signal := make(chan struct{})
	go func() {
		q.Run(stop)
		signal <- struct{}{}
	}()

	q.Push(func() error {
		t.Log("mock exec")
		return nil
	})

	// mock queue block wait cond signal