key: "foo",
		val: "bar",
	}
	objectCache := NewFakeObjectCache(func() (interface{}, error) {
		return nil, fmt.Errorf("Unexpected Error: updater should never be called in this test")
	}, 1*time.Hour, testingclock.NewFakeClock(time.Now()))

	err := objectCache.Add(testObj.key, testObj.val)
	if err != nil {
		t.Errorf("Unable to add obj %#v by key: %s", testObj, testObj.key)
	}
	value, err := objectCache.Get(testObj.key)
	if err != nil {

)

func TestDelayedHealthCheck(t *testing.T) {
	t.Run("test that liveness check returns true until the delay has elapsed", func(t *testing.T) {
		t0 := time.Unix(0, 0)
		c := testingclock.NewFakeClock(t0)
		doneCh := make(chan struct{})

		healthCheck := delayedHealthCheck(postStartHookHealthz{"test", doneCh}, c, time.Duration(10)*time.Second)
		err := healthCheck.Check(nil)
		if err != nil {

		atomic.AddInt32(&testVal, 1)
		wg.Done()
		return nil
	})
	now := time.Now()
	then := now.Add(10 * time.Second)
	fakeClock := testingclock.NewFakeClock(now)
	queue.clock = fakeClock
	queue.AddWork(context.TODO(), NewWorkArgs("1", "1"), now, then)
	queue.AddWork(context.TODO(), NewWorkArgs("2", "2"), now, then)
	queue.AddWork(context.TODO(), NewWorkArgs("3", "3"), now, then)

					LeaseDuration: time.Minute,
					Name:          "foo",
				},
				observedRecord: rl.LeaderElectionRecord{
					HolderIdentity: "healthTest",
				},
				observedTime: current,
				clock:        clock.NewFakeClock(current.Add(time.Hour)),
			},
		},
		{
			description:    "call check when the lease is far expired but held by another server",
			expected:       nil,
			adaptorTimeout: time.Second * 20,

	})
}

func TestRecordAllTimestamps(t *testing.T) {
	t.Run("all timestamps are recorded", func(t *testing.T) {
		metrics.Register()
		defer clearMetrics()

		fakeClock := testingclock.NewFakeClock(frozenTime)
		tracker := &basicNodeStartupLatencyTracker{
			bootTime:         frozenTime.Add(-100 * time.Millisecond),
			kubeletStartTime: frozenTime,
			clock:            fakeClock,
		}

	"time"

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

func TestSimpleCacheSetError(t *testing.T) {
	fakeClock := testingclock.NewFakeClock(time.Now())
	cache := newSimpleCache(fakeClock, time.Second, "providerName")

	tests := []struct {
		name        string
		key         []byte
		transformer value.Transformer
	}{
		{

				if tr.Status.Token != "foo" {
					t.Fatalf("unexpected token: %v", tr.Status.Token)
				}
			},
		},
	}

	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			clock := testingclock.NewFakeClock(time.Time{}.Add(30 * 24 * time.Hour))
			expSecs := int64(c.exp.Seconds())
			s := &suite{
				clock: clock,
				mgr:   NewManager(nil),
				tg: &fakeTokenGetter{
					tr: &authenticationv1.TokenRequest{

		filterRecord = requestFilterRecordFrom(req.Context())
	})

	requestFilterStarted := time.Now()
	wrapped := trackStarted(handler, noopoteltrace.NewTracerProvider(), filterName, testingclock.NewFakeClock(requestFilterStarted))

	testRequest, err := http.NewRequest(http.MethodGet, "/api/v1/namespaces", nil)
	if err != nil {
		t.Fatalf("failed to create new http request - %v", err)
	}

*/

package flowcontrol

import (
	"fmt"
	"sync"
	"testing"
	"time"

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

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

	// The following table represents the list over time of:
	// - seconds elapsed (as computed since the initial time)

	// all old pods are unavailable so should be surged
	manager.failedPodsBackoff.Clock = testingclock.NewFakeClock(time.Unix(100, 0))
	clearExpectations(t, manager, ds, podControl)
	expectSyncDaemonSets(t, manager, ds, podControl, 5, 0, 0)

	// waiting for pods to go ready, old pods are deleted
	manager.failedPodsBackoff.Clock = testingclock.NewFakeClock(time.Unix(200, 0))
	clearExpectations(t, manager, ds, podControl)