package main

func main() {
	c := make(chan int, 1)
	x := 0
	select {
	case c <- x: // should see x = 0, not x = 42 (after makec)
	case <-makec(&x): // should be evaluated only after c and x on previous line
	}
	y := <-c
	if y != 0 {
		panic(y)
	}
}

func makec(px *int) chan bool {
	if false { for {} }
	*px = 42
	return make(chan bool, 0)

package main

import "runtime"

func main() {
	{
		x := inuse()
		c := make(chan []byte, 10)
		c <- make([]byte, 10<<20)
		close(c)
		f1(c, x)
	}
	{
		x := inuse()
		c := make(chan []byte, 10)
		c <- make([]byte, 10<<20)
		close(c)
		f2(c, x)
	}
}

func f1(c chan []byte, start int64) {
	for x := range c {
		if delta := inuse() - start; delta < 9<<20 {

				return G2(619.2)
			}(G3(""), 954.0)])
		}
		var m7 map[G2]int64
		var ch7 chan byte
		var fnc1 func(bool, func(chan G2, struct {
			h0 G2
		}, int64) **rune, int) map[complex128]int32 = func(p0 bool, p1 func(chan G2, struct {
			h0 G2
		}, int64) **rune, p2 int) map[complex128]int32 {
			pf2 = pf2
			as7 = as7

	x any
	t any
	b bool
}{
	{new(chan int), new(<-chan int), true},
	{new(<-chan int), new(chan int), false},
	{new(*int), new(IntPtr), true},
	{new(IntPtr), new(*int), true},
	{new(IntPtr), new(IntPtr1), false},
	{new(Ch), new(<-chan any), true},
	// test runs implementsTests too
}

type IntPtr *int
type IntPtr1 *int
type Ch <-chan any

func TestAssignableTo(t *testing.T) {

	remoteHost := remote.HostName()

	// 1: Echo
	serverSent := make(chan struct{})
	serverCanceled := make(chan struct{})
	register := func(manager *Manager) {
		errFatal(manager.RegisterStreamingHandler(handlerTest, StreamHandler{
			Handle: func(ctx context.Context, payload []byte, _ <-chan []byte, resp chan<- []byte) *RemoteErr {
				// Send many responses.
				// Test that this doesn't block.

func ContextForChannel(parentCh <-chan struct{}) context.Context {
	return channelContext{stopCh: parentCh}
}

var _ context.Context = channelContext{}

// channelContext will behave as if the context were cancelled when stopCh is
// closed.
type channelContext struct {
	stopCh <-chan struct{}
}

func (c channelContext) Done() <-chan struct{} { return c.stopCh }

		s.addTerminatingStartFunc("ingress status", func(stop <-chan struct{}) error {
			leaderelection.
				NewLeaderElection(args.Namespace, args.PodName, leaderelection.IngressController, args.Revision, s.kubeClient).
				AddRunFunction(func(leaderStop <-chan struct{}) {
					ingressSyncer := ingress.NewStatusSyncer(s.environment.Watcher, s.kubeClient)

func TestStress(t *testing.T) {
	dur := 3 * time.Second
	if testing.Short() {
		dur = 100 * time.Millisecond
	}
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))
	done := make(chan bool)
	finished := make(chan bool)
	go func() {
		sig := make(chan os.Signal, 1)
		Notify(sig, syscall.Note("alarm"))
		defer Stop(sig)
	Loop:
		for {
			select {
			case <-sig:
			case <-done:
				break Loop
			}
		}

// forgets to typecheck the declarations in the inlined copy.

package main

type reader struct {
	C chan T
}

type T struct{ C chan []byte }

var r = newReader()

func newReader() *reader { return new(reader) }

func (r *reader) Read(n int) ([]byte, error) {
	req := T{C: make(chan []byte)}
	r.C <- req
	return <-req.C, nil
}

func main() {
	s, err := r.Read(1)
	_, _ = s, err

// Copyright 2014 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 main

func main() {
	c := make(chan chan int, 1)
	c1 := make(chan int, 1)
	c1 <- 42
	c <- c1
	x := <-<-c
	if x != 42 {
		println("BUG:", x, "!= 42")
	}