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

func _() {
	type namedA chan int
	type namedB chan<- int

	var a chan int
	var A namedA
	var b chan<- int
	var B namedB

	// Defined types win over channel types irrespective of channel direction.
	f(A, b /* ERROR "cannot use b (variable of type chan<- int) as namedA value in argument to f" */)
	f(b /* ERROR "cannot use b (variable of type chan<- int) as namedA value in argument to f" */, A)

	var x int
	_ = x
	compl := make(chan bool)
	c := make(chan bool)
	c1 := make(chan bool)
	go func() {
		select {
		case <-c:
		case <-c1:
		}
		x = 1
		compl <- true
	}()
	x = 2
	close(c)
	runtime.Gosched()
	<-compl
}

func TestNoRaceSelect3(t *testing.T) {
	var x int
	_ = x
	compl := make(chan bool)
	c := make(chan bool, 10)
	c1 := make(chan bool)
	go func() {
		x = 1
		select {

package main

import "runtime"

func recv1(c <-chan int) {
	<-c
}

func recv2(c <-chan int) {
	select {
	case <-c:
	}
}

func recv3(c <-chan int) {
	c2 := make(chan int)
	select {
	case <-c:
	case <-c2:
	}
}

func send1(recv func(<-chan int)) {
	c := make(chan int)
	go recv(c)
	runtime.Gosched()
	c <- 1
}

func send2(recv func(<-chan int)) {
	c := make(chan int)
	go recv(c)

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

// chan.go tests chan operations.
package main

import "testing"

//go:noinline
func lenChan_ssa(v chan int) int {
	return len(v)
}

//go:noinline
func capChan_ssa(v chan int) int {
	return cap(v)
}

func testLenChan(t *testing.T) {

	v := make(chan int, 10)
	v <- 1
	v <- 1
	v <- 1

package main

type M interface{}

type A struct {
	a string
	b chan M
}

func (a *A) I() (b <-chan M, c chan<- M) {
	a.b, c = make(chan M), make(chan M)
	b = a.b

	return
}

func Init(a string, b *A, c interface {
	I() (<-chan M, chan<- M)
}) {
	b.a = a
	go b.c(c.I())
}

	[10]int
	struct{}
	*int
	func()
	interface{}
	map[string]int
	chan T
	chan<- T
	<-chan T
	T[int]
}

type _ interface {
	int | string
	[]byte | string
	[10]int | string
	struct{} | string
	*int | string
	func() | string
	interface{} | string
	map[string]int | string
	chan T | string
	chan<- T | string
	<-chan T | string
	T[int] | string
}

type _ interface {
	~int | string