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,

	"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
	}{
		{

		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)

}

func TestNewActiveDeadlineHandler(t *testing.T) {
	pods := newTestPods(1)
	podStatusProvider := &mockPodStatusProvider{pods: pods}
	fakeRecorder := &record.FakeRecorder{}
	fakeClock := testingclock.NewFakeClock(time.Now())

	testCases := []struct {
		podStatusProvider status.PodStatusProvider
		recorder          record.EventRecorder
		clock             clock.Clock
	}{
		{podStatusProvider, fakeRecorder, fakeClock},

		// does the handler chain that follows see the request received timestamp?
		receivedTimestampGot, ok = request.ReceivedTimestampFrom(req.Context())
	})

	wrapped := withRequestReceivedTimestampWithClock(handler, testingclock.NewFakeClock(receivedTimestampExpected))

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

*/

package fairqueuing

import (
	"math"
	"testing"
	"time"

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

func TestIntegrator(t *testing.T) {
	now := time.Now()
	clk := testclock.NewFakeClock(now)
	igr := NewNamedIntegrator(clk, "testee")
	igr.Add(3)
	clk.Step(time.Second)
	results := igr.GetResults()
	rToo := igr.Reset()