// wait until all resources appears in discovery
	for _, version := range servedV1Versions(crd) {
		err := wait.PollImmediate(500*time.Millisecond, 30*time.Second, func() (bool, error) {
			return existsInDiscoveryV1(crd, apiExtensionsClient, version)
		})
		if err != nil {
			return nil, err
		}
	}

	return crd, nil
}

	defer func() { close(stop) }()
	mon.Start(stop)

	go func() {
		for i := 0; i < 10; i++ {
			select {
			case <-stop:
				return
			case mon.updateCh <- struct{}{}:
			}
			time.Sleep(time.Millisecond * 100)
		}
	}()
	g.Eventually(func() error {
		c := store.List(gvk.Gateway, "")

		if len(c) != 1 {
			return errors.New("no configs")
		}

		if c[0].Meta.Name != "magic" {

	var cancel context.CancelFunc
	ctx = setCaller(ctx, c.remote)
	if msg.DeadlineMS > 0 {
		ctx, cancel = context.WithTimeout(ctx, time.Duration(msg.DeadlineMS)*time.Millisecond)
	} else {
		ctx, cancel = context.WithCancel(ctx)
	}
	m := muxServer{
		ID:        msg.MuxID,
		RecvSeq:   msg.Seq + 1,
		SendSeq:   msg.Seq,
		ctx:       ctx,
		cancel:    cancel,
		parent:    c,

import (
	"testing"
	"time"
)

func test6997(t *testing.T) {
	r := C.StartThread()
	if r != 0 {
		t.Error("pthread_create failed")
	}
	c := make(chan C.int)
	go func() {
		time.Sleep(500 * time.Millisecond)
		c <- C.CancelThread()
	}()

	select {
	case r = <-c:
		if r == 0 {
			t.Error("pthread finished but wasn't canceled??")
		}
	case <-time.After(30 * time.Second):

	ch := make(chan interface{}, 1)
	lw := newSourceFile("/some/fake/file", "localhost", time.Millisecond, ch)
	err := lw.doWatch()
	if err == nil {
		t.Errorf("Expected error")
	}
}

func TestUpdateOnNonExistentFile(t *testing.T) {
	ch := make(chan interface{})
	NewSourceFile("random_non_existent_path", "localhost", time.Millisecond, ch)
	select {
	case got := <-ch:
		update := got.(kubetypes.PodUpdate)

				// We should have waited for the delayed conf
				return fmt.Errorf("did not wait for valid config file")
			}
			return nil
		}, retry.Delay(time.Millisecond), retry.Timeout(time.Millisecond*250))
		var destFilenm string
		if preConfFile != "" {
			destFilenm = preConfFile
		} else {
			destFilenm = delayedConfFile
		}
		cp(delayedConfFile, tempCNIConfDir+"/"+destFilenm, t)

	"time"

	_ "testcarchive/p"
)

import "C"

var initCh = make(chan int, 1)
var ranMain bool

func init() {
	// emulate an exceedingly slow package initialization function
	time.Sleep(100 * time.Millisecond)
	initCh <- 42
}

func main() { ranMain = true }

//export DidInitRun
func DidInitRun() bool {
	select {
	case x := <-initCh:
		if x != 42 {
			// Just in case initCh was not correctly made.

			}

			// Set arbitrary discovery timeout and retry interval
			timeout := time.Millisecond * 500
			interval := time.Millisecond * 20

			// Patch the JWS signature after a short delay
			if test.delayedJWSSignaturePatch {
				test.configMap.data[bootstrapapi.JWSSignatureKeyPrefix+test.tokenID] = sig
				go func() {
					time.Sleep(time.Millisecond * 60)
					if err := test.configMap.createOrUpdate(client); err != nil {

// that require a valid G/M.
func TestNewOSProc0(t *testing.T) {
	runtime.NewOSProc0(0x800000, unsafe.Pointer(abi.FuncPCABIInternal(newOSProcCreated)))
	check := time.NewTicker(100 * time.Millisecond)
	defer check.Stop()
	end := time.After(5 * time.Second)
	for {
		select {
		case <-check.C:
			if newOSProcDone {
				return
			}
		case <-end:
			t.Fatalf("couldn't create new OS process")
		}

		if intSize < 64 {
			count = 100
		}
	}

	var q Q = &R{&T{}}
	for i := 0; i < count; i++ {
		go func() {
			defer q.Foo([]interface{}{"meow"})
			time.Sleep(100 * time.Millisecond)
		}()
	}
	time.Sleep(1 * time.Second)