newSucceededPods: []metav1.Time{
				metav1.NewTime(defaultTestTime.Add(-2 * time.Millisecond)),
			},
			newFailedPods: []metav1.Time{
				defaultTestTime,
				metav1.NewTime(defaultTestTime.Add(-4 * time.Millisecond)),
				metav1.NewTime(defaultTestTime.Add(-3 * time.Millisecond)),
				metav1.NewTime(defaultTestTime.Add(-1 * time.Millisecond)),
			},
			wantBackoffRecord: backoffRecord{
				key:                      "key",

	}
	return nil
}

func waitForNoReload(reloads *uint32, expected uint32) error {
	utilwait.PollImmediate(50*time.Millisecond, 250*time.Millisecond, func() (bool, error) {
		return atomic.LoadUint32(reloads) > expected, nil
	})

	got := atomic.LoadUint32(reloads)
	if got != expected {
		return fmt.Errorf("expected %d, got %d", expected, got)
	}
	return nil
}

func waitForBlocked(mfe *monitorFakeExec) error {

	// Give the goroutine ample chance to block on the pipe.
	time.Sleep(10 * time.Millisecond)

	// Start tracing.
	if err := trace.Start(os.Stdout); err != nil {
		log.Fatalf("failed to start tracing: %v", err)
	}

	// This isn't enough to have a full generation pass by default,
	// but it is generally enough in stress mode.
	time.Sleep(100 * time.Millisecond)

	// Write to the pipe to unblock it.

	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()

			b1 := make([]byte, 1024)
			b2 := make([]byte, 1024)
			for j := 0; j < 100; j++ {
				_, err := c1.Write(b1)
				copy(b1, b2) // Mutate b1 to trigger potential race
				if err != nil {
					checkForTimeoutError(t, err)
					c1.SetWriteDeadline(time.Now().Add(time.Millisecond))
				}
			}
		}()

				DenyTTL:      minDenyTTL,
				RetryBackoff: minRetryBackoff * time.Millisecond,
			},
			wantErr: false,
		},
		{
			test: "config within normal ranges for max values",
			config: imagePolicyWebhookConfig{
				AllowTTL:     maxAllowTTL / time.Second,
				DenyTTL:      maxDenyTTL / time.Second,
				RetryBackoff: maxRetryBackoff / time.Millisecond,
			},
			normalizedConfig: imagePolicyWebhookConfig{

		for i := 0; i < N; i++ {
			w.Add(i)
		}
		start := time.Now()
		var n int32
		w.Do(N, func(x int) {
			time.Sleep(1 * time.Millisecond)
			atomic.AddInt32(&n, +1)
		})
		if n != N {
			t.Fatalf("par.Work.Do did not do all the work")
		}
		if time.Since(start) < N/2*time.Millisecond {
			return
		}
	}
	t.Fatalf("par.Work.Do does not seem to be parallel")
}

func TestCache(t *testing.T) {

	"k8s.io/apimachinery/pkg/util/managedfields/internal"
)

func TestAtMostEvery(t *testing.T) {
	duration := time.Second
	delay := 179 * time.Millisecond
	atMostEvery := internal.NewAtMostEvery(delay)
	count := 0
	exit := time.NewTicker(duration)
	tick := time.NewTicker(2 * time.Millisecond)
	defer exit.Stop()
	defer tick.Stop()

	done := false
	for !done {
		select {
		case <-exit.C:
			done = true
		case <-tick.C:

					Host: "localhost",
					Port: uint32(listener.port),
				},
			},
		}, nil, []string{"127.0.0.1"}, false)
		// Speed up tests
		tcpHealthChecker.config.CheckFrequency = time.Millisecond

		quitChan := make(chan struct{})

		expectedTCPEvents := [3]*ProbeEvent{
			{Healthy: false},
			{Healthy: true},
			{Healthy: false},
		}
		tcpHealthStatuses := [3]bool{false, true, false}

	for push := 0; push < 100; push++ {
		for _, proxy := range proxies {
			queue.Enqueue(proxy, &model.PushRequest{Push: &model.PushContext{}})
		}
		time.Sleep(time.Millisecond * 10)
	}
	for queue.Pending() > 0 {
		time.Sleep(time.Millisecond)
	}
	pushesMu.Lock()
	defer pushesMu.Unlock()
	for proxy, numPushes := range pushes {
		if numPushes == 0 {
			t.Fatalf("Proxy %v had 0 pushes", proxy)
		}
	}

	err = os.WriteFile(fileName, []byte{1, 2, 3}, 0555)
	if err != nil {
		t.Fatalf("unable to write test file %#v", err)
	}

	ch := make(chan interface{}, 1)
	lw := newSourceFile(fileName, "localhost", time.Millisecond, ch)
	err = lw.listConfig()
	if err == nil {
		t.Fatalf("expected error, got nil")
	}
	expectEmptyChannel(t, ch)
}

func TestExtractFromEmptyDir(t *testing.T) {
	dirName, err := mkTempDir("file-test")