defer wg.mu.RUnlock()
	if wg.wait && delta > 0 {
		return fmt.Errorf("add with positive delta after Wait is forbidden")
	}
	wg.wg.Add(delta)
	return nil
}

// Done decrements the WaitGroup counter.
func (wg *SafeWaitGroup) Done() {
	wg.wg.Done()
}

// Wait blocks until the WaitGroup counter is zero.
func (wg *SafeWaitGroup) Wait() {
	wg.mu.Lock()
	wg.wait = true
	wg.mu.Unlock()
	wg.wg.Wait()

// and provide the appropriate initialization data
func (i *PluginInitializer) Initialize(plugin admission.Interface) {
	if wants, ok := plugin.(initializer.WantsQuotaConfiguration); ok {
		wants.SetQuotaConfiguration(i.quotaConfiguration)
	}

	if wants, ok := plugin.(initializer.WantsExcludedAdmissionResources); ok {
		wants.SetExcludedAdmissionResources(i.excludedAdmissionResources)
	}

                long waitMs = mostRecentEvent + timeout.toMillis() - clock.getCurrentTime();
                if (waitMs < 0) {
                    failure = new AssertionError("Timeout waiting request to block.");
                    condition.signalAll();
                    throw failure;
                }
                try {
                    condition.await(waitMs, TimeUnit.MILLISECONDS);

			need = 1 // to ensure we read at least one byte for every Read
			tokens = b
		}
	} else { // all tokens go towards payload
		need = int(math.Min(float64(b), float64(need)))
		tokens = need
	}

	err = r.throttle.WaitN(r.ctx, tokens)
	if err != nil {
		return
	}

	n, err = r.r.Read(buf[:need])
	if err != nil {
		r.lastErr = err
		return
	}
	r.m.updateMeasurement(r.opts.BucketOptions, uint64(tokens))
	return
}

	wg.Add(1)
	go func() {
		defer wg.Done()
		batch = backend.collectEvents(tc, nil)
	}()
	// Wait for the queued events to be collected.
	err := wait.Poll(time.Second, wait.ForeverTestTimeout, func() (bool, error) {
		return len(backend.buffer) == 0, nil
	})
	require.NoError(t, err)

	tc <- time.Now() // Trigger "timeout"
	wg.Wait()
	assert.Len(t, batch, 2, "Expected partial batch")

func (i *PluginInitializer) Initialize(plugin admission.Interface) {
	if wants, ok := plugin.(WantsServiceResolver); ok {
		wants.SetServiceResolver(i.serviceResolver)
	}

	if wants, ok := plugin.(WantsAuthenticationInfoResolverWrapper); ok {
		if i.authenticationInfoResolverWrapper != nil {
			wants.SetAuthenticationInfoResolverWrapper(i.authenticationInfoResolverWrapper)
		}
	}

	vlp := (*efaceWords)(unsafe.Pointer(&val))
	for {
		typ := LoadPointer(&vp.typ)
		if typ == nil {
			// Attempt to start first store.
			// Disable preemption so that other goroutines can use
			// active spin wait to wait for completion.
			runtime_procPin()
			if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(&firstStoreInProgress)) {
				runtime_procUnpin()
				continue
			}
			// Complete first store.

	})
	return err
}

// PipeReader is similar to io.PipeReader with wait group
type PipeReader struct {
	*io.PipeReader
	wait func()
}

// CloseWithError close with supplied error the reader end
func (r *PipeReader) CloseWithError(err error) error {
	err = r.PipeReader.CloseWithError(err)
	r.wait()
	return err
}

// WaitPipe implements wait-group backend io.Pipe to provide

package net

import (
	"context"
	"testing"
)

func TestCgoLookupIP(t *testing.T) {
	defer dnsWaitGroup.Wait()
	ctx := context.Background()
	_, err := cgoLookupIP(ctx, "ip", "localhost")
	if err != nil {
		t.Error(err)
	}
}

func TestCgoLookupIPWithCancel(t *testing.T) {
	defer dnsWaitGroup.Wait()
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	_, err := cgoLookupIP(ctx, "ip", "localhost")

// ErrWaitTimeout, as methods that cancel a context may not return that error.
//
// Instead of:
//
//	err := wait.Poll(...)
//	if err == wait.ErrWaitTimeout {
//	    log.Infof("Wait for operation exceeded")
//	} else ...
//
// Use:
//
//	err := wait.Poll(...)
//	if wait.Interrupted(err) {
//	    log.Infof("Wait for operation exceeded")
//	} else ...
func Interrupted(err error) bool {
	switch {