s := make([]byte, 100)
	s[0] = 1
	one := unsafe.SliceData(s)

	done := make(chan struct{})
	runtime.SetFinalizer(one, func(*byte) { close(done) })

	h := g(one)

	if wait(done) {
		panic("GC'd early")
	}

	if *h != 1 {
		panic("lost one")
	}

	if !wait(done) {
		panic("never GC'd")
	}
}

var strDone = make(chan struct{})

//go:noinline
func str(x, y string) {

	return nil
}

func (obj *fakeDBusObject) Go(method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{}) *dbus.Call {
	return nil
}

func (obj *fakeDBusObject) GoWithContext(ctx context.Context, method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{}) *dbus.Call {
	return nil
}

		}
	}
}

func TestDelayQueueOrdering(t *testing.T) {
	dq := NewDelayed(DelayQueueWorkers(2))
	stop := make(chan struct{})
	defer close(stop)
	go dq.Run(stop)

	mu := sync.Mutex{}
	var t0, t1, t2 time.Time

	done := make(chan struct{})
	dq.PushDelayed(func() error {
		mu.Lock()
		defer mu.Unlock()
		defer close(done)
		t2 = time.Now()
		return nil

	start    func(stopCh <-chan struct{})
}

func (s StartableInformer) Start(stopCh <-chan struct{}) {
	s.start(stopCh)
}

// InformerFactory provides access to a shared informer factory
type InformerFactory interface {
	// Start initializes all requested informers. They are handled in goroutines
	// which run until the stop channel gets closed.
	Start(stopCh <-chan struct{})

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import "plugin"

func main() {
	p, err := plugin.Open("issue24351.so")
	if err != nil {
		panic(err)
	}
	f, err := p.Lookup("B")
	if err != nil {
		panic(err)
	}
	c := make(chan bool)
	f.(func(chan bool))(c)
	<-c

			stopChan := make(chan struct{}, 1)
			readyChan := make(chan struct{})

			pf, err := New(dialer, test.ports, stopChan, readyChan, os.Stdout, os.Stderr)
			if err != nil {
				t.Fatalf("%s: unexpected error calling New: %v", testName, err)
			}

			doneChan := make(chan error)
			go func() {
				doneChan <- pf.ForwardPorts()
			}()
			<-pf.Ready

	return &afterFuncContext{}
}

func (c *afterFuncContext) Deadline() (time.Time, bool) {
	return time.Time{}, false
}

func (c *afterFuncContext) Done() <-chan struct{} {
	c.mu.Lock()
	defer c.mu.Unlock()
	if c.done == nil {
		c.done = make(chan struct{})
	}
	return c.done
}

func (c *afterFuncContext) Err() error {
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.err
}

	globalServiceFreezeMu.Lock()
	// Close when we reach 0
	globalServiceFreezeCnt--
	if globalServiceFreezeCnt <= 0 {
		// Set to a nil channel.
		var _ch chan struct{}
		if val := globalServiceFreeze.Swap(_ch); val != nil {
			if ch, ok := val.(chan struct{}); ok && ch != nil {
				// Close previous non-nil channel.
				xioutil.SafeClose(ch)
			}
		}
		globalServiceFreezeCnt = 0 // Don't risk going negative.
	}

)

func TestMonitorLifecycle(t *testing.T) {
	// Regression test to ensure no race conditions during monitor shutdown
	store := memory.Make(collections.Mocks)
	m := memory.NewMonitor(store)
	stop := make(chan struct{})
	go m.Run(stop)
	m.ScheduleProcessEvent(memory.ConfigEvent{})
	close(stop)
	m.ScheduleProcessEvent(memory.ConfigEvent{})
}

func TestEventConsistency(t *testing.T) {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test race condition between timers and wasm calls that led to memory corruption.

package main

import (
	"os"
	"syscall/js"
	"time"
)

func main() {
	ch1 := make(chan struct{})

	go func() {
		for {
			time.Sleep(5 * time.Millisecond)
			ch1 <- struct{}{}
		}