"k8s.io/apimachinery/pkg/util/sets"
	"k8s.io/utils/clock"
	testingclock "k8s.io/utils/clock/testing"
)

func newTestBasicWorkQueue() (*basicWorkQueue, *testingclock.FakeClock) {
	fakeClock := testingclock.NewFakeClock(time.Now())
	wq := &basicWorkQueue{
		clock: fakeClock,
		queue: make(map[types.UID]time.Time),
	}
	return wq, fakeClock
}

func compareResults(t *testing.T, expected, actual []types.UID) {

	pollTimeout     = 5 * time.Second
)

func TestConditionalProgressRequester(t *testing.T) {
	_, ctx := ktesting.NewTestContext(t)
	logger := klog.FromContext(ctx)

	clock := testingclock.NewFakeClock(time.Now())
	pr := newTestConditionalProgressRequester(clock)
	stopCh := make(chan struct{})
	go pr.Run(stopCh)
	var wantRequestsSent int32
	var requestsSent int32

	logger.Info("Wait for ticker to be created")

				twiPtrEquals(t, nil, got22)
			},
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			clock := clocktesting.NewFakeClock(time.Now())
			cache := newSimpleCache(clock, 10*time.Second)
			tt.test(t, cache, clock)
		})
	}
}

func twiPtrEquals(t *testing.T, want, got *transformerWithInfo) {
	t.Helper()

limitations under the License.
*/

package cacher

import (
	"testing"
	"time"

	testingclock "k8s.io/utils/clock/testing"
)

func TestTimeBudget(t *testing.T) {
	fakeClock := testingclock.NewFakeClock(time.Now())

	budget := &timeBudgetImpl{
		clock:     fakeClock,
		budget:    time.Duration(0),
		maxBudget: 200 * time.Millisecond,
		refresh:   50 * time.Millisecond,
		last:      fakeClock.Now(),
	}

	})

	assertKeys(t, c.Keys(), []any{"other-long-lived"})

	expectNotEntry(t, c, "long-lived")
	expectEntry(t, c, "other-long-lived", "12345")
}

func TestExpiredGet(t *testing.T) {
	fakeClock := testingclock.NewFakeClock(time.Now())
	c := NewLRUExpireCacheWithClock(10, fakeClock)
	c.Add("short-lived", "12345", 1*time.Millisecond)
	// ensure the entry expired
	fakeClock.Step(2 * time.Millisecond)

	"k8s.io/utils/pointer"
)

// Test_Controller validates the garbage collection logic for the apiserverleasegc controller.
func Test_Controller(t *testing.T) {
	fakeClock := testingclock.NewFakeClock(time.Now())
	tests := []struct {
		name          string
		lease         *coordinationv1.Lease
		expectDeleted bool
	}{
		{
			name: "lease not expired",
			lease: &coordinationv1.Lease{

		t.Run(test.name, func(t *testing.T) {
			client := fake.NewSimpleClientset(test.clientObjects...)
			limiter := rate.NewLimiter(rate.Every(throttlePeriod), 1)
			controller := newController(client, testingclock.NewFakeClock(now), limiter)
			if test.existingConfigMap != nil {
				controller.configMapCache.Add(test.existingConfigMap)
			}

			if err := controller.syncConfigMap(); err != nil {

	testingclock "k8s.io/utils/clock/testing"
)

func newTestEventedPLEG() *EventedPLEG {
	return &EventedPLEG{
		runtime:        &containertest.FakeRuntime{},
		clock:          testingclock.NewFakeClock(time.Time{}),
		cache:          kubecontainer.NewCache(),
		runtimeService: critest.NewFakeRuntimeService(),
		eventChannel:   make(chan *PodLifecycleEvent, 100),
	}
}

func TestHealthyEventedPLEG(t *testing.T) {