}
	return false
}

func setup() (chan interface{}, chan interface{}, OperationExecutor) {
	ch, quit := make(chan interface{}), make(chan interface{})
	return ch, quit, NewOperationExecutor(newFakeOperationGenerator(ch, quit))
}

// This function starts by writing to ch and blocks on the quit channel
// until it is closed by the currently running test
func startOperationAndBlock(ch chan<- interface{}, quit <-chan interface{}) {

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

package p

func f[S []T, T any](S, T) {}

func _() {
	type L chan int
	f([]L{}, make(chan int))
	f([]L{}, make(L))
	f([]chan int{}, make(chan int))
	f /* ERROR "[]chan int does not satisfy []L ([]chan int missing in []p.L)" */ ([]chan int{}, make(L))
}

// test case from issue

func Append[S ~[]T, T any](s S, x ...T) S { /* implementation of append */ return s }

package main

import "os"

const N = 10

func AsynchFifo() {
	ch := make(chan int, N)
	for i := 0; i < N; i++ {
		ch <- i
	}
	for i := 0; i < N; i++ {
		if <-ch != i {
			print("bad receive\n")
			os.Exit(1)
		}
	}
}

func Chain(ch <-chan int, val int, in <-chan int, out chan<- int) {
	<-in
	if <-ch != val {
		panic(val)
	}
	out <- 1
}

// ResultChan implements Interface
func (w emptyWatch) ResultChan() <-chan Event {
	return chan Event(w)
}

// FakeWatcher lets you test anything that consumes a watch.Interface; threadsafe.
type FakeWatcher struct {
	result  chan Event
	stopped bool
	sync.Mutex
}

func NewFake() *FakeWatcher {
	return &FakeWatcher{
		result: make(chan Event),
	}
}

		_ _RecvChan = C
		_ _Chan     = C

		_ SendChan = c
		_ RecvChan = c
		_ Chan     = c

		_ SendChan = C // ERRORx `cannot use C .* as SendChan value`
		_ RecvChan = C // ERRORx `cannot use C .* as RecvChan value`
		_ Chan     = C
		_ Chan     = make /* ERRORx `cannot use make\(chan Basic\) .* as Chan value` */ (chan Basic)
	)

	var (
		_ _CC = C // ERRORx `cannot use C .* as _CC value`

		t.Fatalf("want %d subscribers, got %d", want, got)
	}
}

func TestSubscribeExceedingLimit(t *testing.T) {
	ps := New[Maskable, Maskable](2)
	ch1 := make(chan Maskable, 1)
	ch2 := make(chan Maskable, 1)
	ch3 := make(chan Maskable, 1)
	doneCh := make(chan struct{})
	defer close(doneCh)
	if err := ps.Subscribe(MaskAll, ch1, doneCh, nil); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	x = make(map[int]int, zero) // ERROR "cannot use make\(map\[int\]int, zero\)|incompatible"
	x = make(chan int)          // ERROR "cannot use make\(chan int\)|incompatible"
	x = make(chan int, 0)       // ERROR "cannot use make\(chan int, 0\)|incompatible"
	x = make(chan int, zero)    // ERROR "cannot use make\(chan int, zero\)|incompatible"

import (
	"container/heap"
	"container/ring"
)

// Return a chan of odd numbers, starting from 5.
func odds() chan int {
	out := make(chan int, 50)
	go func() {
		n := 5
		for {
			out <- n
			n += 2
		}
	}()
	return out
}

// Return a chan of odd multiples of the prime number p, starting from p*p.
func multiples(p int) chan int {
	out := make(chan int, 10)
	go func() {
		n := p * p
		for {
			out <- n

	ch := make(chan bool, 1)
	go func() {
		delete(m, "")
		ch <- true
	}()
	m[""] = true
	<-ch
}

func TestRaceMapLenDelete(t *testing.T) {
	m := make(map[string]bool)
	ch := make(chan bool, 1)
	go func() {
		delete(m, "a")
		ch <- true
	}()
	_ = len(m)
	<-ch
}

func TestRaceMapVariable(t *testing.T) {
	ch := make(chan bool, 1)
	m := make(map[int]int)

// 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 send to ch .* no core type` */ 0
}

func _[T C0](ch T) {