//
//export AwaitSIGIO
func AwaitSIGIO() {
	<-sigioChan
}

// SawSIGIO reports whether we saw a SIGIO within a brief pause.
//
//export SawSIGIO
func SawSIGIO() bool {
	timer := time.NewTimer(100 * time.Millisecond)
	select {
	case <-sigioChan:
		timer.Stop()
		return true
	case <-timer.C:
		return false
	}
}

func main() {

// WaitForClose an error if the timeout expires.
func WaitForClose(q Instance, timeout time.Duration) error {
	closed := q.Closed()
	if timeout == 0 {
		<-closed
		return nil
	}
	timer := time.NewTimer(timeout)
	defer timer.Stop()
	select {
	case <-closed:
		return nil
	case <-timer.C:
		return fmt.Errorf("timeout waiting for queue to close after %v", timeout)
	}

}

// Until sleeps for the given duration, or until the channel is closed.
// Returns true if the sleep completes the full duration
func Until(ch <-chan struct{}, d time.Duration) bool {
	timer := time.NewTimer(d)
	select {
	case <-ch:
		if !timer.Stop() {
			<-timer.C
		}
		return false
	case <-timer.C:
		return true
	}

	// We manually create a runtimeTimer with huge period, but that expires
	// immediately. The public Timer interface would require waiting for
	// the entire period before the first update.
	t := newTimer(runtimeNano(), 1<<63-1, empty, nil, nil)
	defer t.Stop()

	// If this test fails, we will either throw (when siftdownTimer detects
	// bad when on update), or other timers will hang (if the timer in a

	default:
	}
	if fx.Delegate != nil {
		fx.Delegate.RemoveShard(shardKey)
	}
}

func (fx *Updater) WaitOrFail(t test.Failer, et string) *Event {
	t.Helper()
	delay := time.NewTimer(time.Second * 5)
	defer delay.Stop()
	for {
		select {
		case e := <-fx.Events:
			if e.Type == et {
				return &e
			}
			log.Infof("skipping event %q want %q", e.Type, et)
			continue

	poller.failureThreshold = 0
	stopCh := make(chan struct{})
	defer close(stopCh)
	go poller.Run(stopCh)
	go func() {
		// The test might have false negative, but won't be flaky
		timer := time.NewTimer(2 * time.Second)
		defer timer.Stop()
		<-timer.C
		fakeGetSucceedLock.Lock()
		defer fakeGetSucceedLock.Unlock()
		fakeGetSucceed = true
	}()

	done := make(chan struct{})
	go func(t *testing.T) {

// Timer returns a timer implementation appropriate to this backoff's parameters
// for use with wait functions.
func (b Backoff) Timer() Timer {
	if b.Steps > 1 || b.Jitter != 0 {
		return &variableTimer{new: internalClock.NewTimer, fn: b.DelayFunc()}
	}
	if b.Duration > 0 {
		return &fixedTimer{new: internalClock.NewTicker, interval: b.Duration}
	}
	return newNoopTimer()
}

// delay implements the core delay algorithm used in this package.

is in a module with a `go.mod` `go` line using Go 1.23.0 or later.
When Go 1.23 builds older programs, the old behaviors remain in effect.
The new [GODEBUG setting](/doc/godebug) [`asynctimerchan=1`](/pkg/time/#NewTimer)
can be used to revert back to asynchronous channel behaviors

			}
		})
	}

	run(t, "After", func() { After(Hour) })
	run(t, "Tick", func() { Tick(Hour) })
	run(t, "NewTimer", func() { NewTimer(Hour) })
	run(t, "NewTicker", func() { NewTicker(Hour) })
	run(t, "NewTimerStop", func() { NewTimer(Hour).Stop() })
	run(t, "NewTickerStop", func() { NewTicker(Hour).Stop() })
}

func TestChan(t *testing.T) {

	}()

	go func() {
		if IsAzure() {
			log.Info("platform detected is Azure")
			plat <- NewAzure()
		}
		wg.Done()
	}()

	go func() {
		wg.Wait()
		close(done)
	}()

	timer := time.NewTimer(timeout)
	defer timer.Stop()
	select {
	case p := <-plat:
		return p
	case <-done:
		select {
		case p := <-plat:
			return p
		default:
			return &Unknown{}
		}
	case <-timer.C: