var zerov V
		return zerok, zerov, false
	}
	return keyval.key, keyval.val, true
}

// chans

func chans_Ranger[T any]() (*chans_Sender[T], *chans_Receiver[T]) { panic(0) }

// A sender is used to send values to a Receiver.
type chans_Sender[T any] struct {
	values chan<- T
	done <-chan bool
}

func (s *chans_Sender[T]) Send(v T) bool {
	select {
	case s.values <- v:
		return true

	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(10))
	var c [4]chan int
	c[0] = make(chan int)
	c[1] = make(chan int)
	c[2] = make(chan int, 2)
	c[3] = make(chan int, 3)
	N := int(1e5)
	if testing.Short() {
		N /= 10
	}
	// There are 4 goroutines that send N values on each of the chans,
	// + 4 goroutines that receive N values on each of the chans,

        def char1 = left as char
        def char2 = right as char
        def caseInsensitiveResult = left.toUpperCase() == right.toUpperCase() ? 0 : result

        expect:
        compareCharsIgnoringCase(char1, char2) == caseInsensitiveResult
        compareCharsIgnoringCase(char2, char1) == -caseInsensitiveResult
        compareChars(char1, char2) == Character.compare(char1, char2)
        compareChars(char2, char1) == Character.compare(char2, char1)

    static int compareCharsIgnoringCase(char char1, char char2) {
        if (char1 == char2) {
            return 0;
        }
        return isFileSeparator(char1)
            ? isFileSeparator(char2)
                ? 0
                : -1
            : isFileSeparator(char2)
                ? 1
                : compareDifferentCharsIgnoringCase(char1, char2);
    }

	go func() {
		close(c)
		compl <- true
	}()
	c = make(chan int)
	<-compl
}

func TestRaceChanItselfLen(t *testing.T) {
	compl := make(chan bool, 1)
	c := make(chan int)
	go func() {
		_ = len(c)
		compl <- true
	}()
	c = make(chan int)
	<-compl
}

func TestRaceChanItselfCap(t *testing.T) {
	compl := make(chan bool, 1)
	c := make(chan int)
	go func() {
		_ = cap(c)

	<-chan (<-chan (<-chan (<-chan (<-chan int))))(nil)

	<-(<-chan int)(nil)
	<-(<-chan chan int)(nil)
	<-(<-chan chan chan int)(nil)
	<-(<-chan chan chan chan int)(nil)
	<-(<-chan chan chan chan chan int)(nil)

	<-(<-chan<-chan int)(nil)
	<-(<-chan<-chan<-chan int)(nil)
	<-(<-chan<-chan<-chan<-chan int)(nil)
	<-(<-chan<-chan<-chan<-chan<-chan int)(nil)

	<-(<-chan (<-chan int))(nil)
	<-(<-chan (<-chan (<-chan int)))(nil)

func Test_getNodeIPs(t *testing.T) {
	var chans [3]chan error

	client := clientsetfake.NewSimpleClientset(
		// node1 initially has no IP address.
		makeNodeWithAddress("node1", ""),

		// node2 initially has an invalid IP address.
		makeNodeWithAddress("node2", "invalid-ip"),

		// node3 initially does not exist.
	)

	for i := range chans {
		chans[i] = make(chan error)
		ch := chans[i]

}

// These values must match ../reflect/value.go:/SelectDir.
type selectDir int

const (
	_             selectDir = iota
	selectSend              // case Chan <- Send
	selectRecv              // case <-Chan:
	selectDefault           // default
)

//go:linkname reflect_rselect reflect.rselect
func reflect_rselect(cases []runtimeSelect) (int, bool) {
	if len(cases) == 0 {
		block()
	}

package p

func f1[T any, C chan T | <-chan T](ch C) {}

func _(ch chan int)   { f1(ch) }
func _(ch <-chan int) { f1(ch) }
func _(ch chan<- int) { f1 /* ERROR "chan<- int does not satisfy chan int | <-chan int" */ (ch) }

func f2[T any, C chan T | chan<- T](ch C) {}

func _(ch chan int)   { f2(ch) }
func _(ch <-chan int) { f2 /* ERROR "<-chan int does not satisfy chan int | chan<- int" */ (ch) }

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

package p

type C0 interface{ int }
type C1 interface{ chan int }
type C2 interface{ chan int | <-chan int }
type C3 interface{ chan int | chan float32 }
type C4 interface{ chan int | chan<- int }
type C5[T any] interface{ ~chan T | <-chan T }

func _[T any](ch T) {
	<-ch // ERRORx `cannot receive from ch .* \(no core type\)`
}

func _[T C0](ch T) {