Clément Chigot <******@****.***> 1538380720 +0200

				c <- i
			}
			if len(c) != chanCap || cap(c) != chanCap {
				t.Fatalf("chan[%d]: bad len/cap, expect %v/%v, got %v/%v", chanCap, chanCap, chanCap, len(c), cap(c))
			}
		}

	}
}

func TestNonblockRecvRace(t *testing.T) {
	n := 10000
	if testing.Short() {
		n = 100
	}
	for i := 0; i < n; i++ {
		c := make(chan int, 1)
		c <- 1
		go func() {
			select {

	{"runtime.makechan64", 1},
	{"runtime.makechan", 1},
	{"runtime.chanrecv1", 1},
	{"runtime.chanrecv2", 1},
	{"runtime.chansend1", 1},
	{"runtime.closechan", 1},
	{"runtime.chanlen", 1},
	{"runtime.chancap", 1},
	{"runtime.writeBarrier", 0},
	{"runtime.typedmemmove", 1},
	{"runtime.typedmemclr", 1},
	{"runtime.typedslicecopy", 1},
	{"runtime.selectnbsend", 1},
	{"runtime.selectnbrecv", 1},

}

//go:linkname reflectlite_chanlen internal/reflectlite.chanlen
func reflectlite_chanlen(c *hchan) int {
	return chanlen(c)
}

//go:linkname reflect_chancap reflect.chancap
func reflect_chancap(c *hchan) int {
	return chancap(c)
}

//go:linkname reflect_chanclose reflect.chanclose
func reflect_chanclose(c *hchan) {
	closechan(c)
}

func (q *waitq) enqueue(sgp *sudog) {
	sgp.next = nil

func chanrecv1(hchan <-chan any, elem *any)
func chanrecv2(hchan <-chan any, elem *any) bool
func chansend1(hchan chan<- any, elem *any)
func closechan(hchan chan<- any)
func chanlen(hchan any) int
func chancap(hchan any) int

var writeBarrier struct {
	enabled bool
	pad     [3]byte
	cgo     bool
	alignme uint64
}

// *byte is really *runtime.Type
func typedmemmove(typ *byte, dst *any, src *any)

	{"makechan64", funcTag, 98},
	{"makechan", funcTag, 99},
	{"chanrecv1", funcTag, 101},
	{"chanrecv2", funcTag, 102},
	{"chansend1", funcTag, 104},
	{"closechan", funcTag, 105},
	{"chanlen", funcTag, 106},
	{"chancap", funcTag, 106},
	{"writeBarrier", varTag, 108},
	{"typedmemmove", funcTag, 109},
	{"typedmemclr", funcTag, 110},
	{"typedslicecopy", funcTag, 111},
	{"selectnbsend", funcTag, 112},
	{"selectnbrecv", funcTag, 113},

		init.Append(ir.TakeInit(conv)...)
		_, len := backingArrayPtrLen(cheapExpr(conv.X, init))
		return len
	}
	if isChanLenCap(n) {
		name := "chanlen"
		if n.Op() == ir.OCAP {
			name = "chancap"
		}
		// cannot use chanfn - closechan takes any, not chan any,
		// because it accepts both send-only and recv-only channels.
		fn := typecheck.LookupRuntime(name, n.X.Type())
		return mkcall1(fn, n.Type(), init, n.X)

	}
	return v.capNonSlice()
}

func (v Value) capNonSlice() int {
	k := v.kind()
	switch k {
	case Array:
		return v.typ().Len()
	case Chan:
		return chancap(v.pointer())
	case Ptr:
		if v.typ().Elem().Kind() == abi.Array {
			return v.typ().Elem().Len()
		}
		panic("reflect: call of reflect.Value.Cap on ptr to non-array Value")
	}

	h.handler.ServeHTTP(w, r)
}

// probabilisticGoawayDecider send GOAWAY probabilistically according to chance
type probabilisticGoawayDecider struct {
	chance float64
	next   func() float64
}

// Goaway implement GoawayDecider
func (p *probabilisticGoawayDecider) Goaway(r *http.Request) bool {
	return p.next() < p.chance

// license that can be found in the LICENSE file.

// Test various parsing cases that are a little
// different now that send is a statement, not an expression.

package main

func main() {
	chanchan()
	sendprec()
}

func chanchan() {
	cc := make(chan chan int, 1)
	c := make(chan int, 1)
	cc <- c
	select {
	case <-cc <- 2:
	default:
		panic("nonblock")
	}
	if <-c != 2 {
		panic("bad receive")
	}
}