bootTime:         frozenTime.Add(-100 * time.Millisecond),
			kubeletStartTime: frozenTime,
			clock:            fakeClock,
		}

		fakeClock.Step(800 * time.Millisecond)
		tracker.RecordAttemptRegisterNode()

		assert.Equal(t, frozenTime.Add(800*time.Millisecond), tracker.firstRegistrationAttemptTime)

		fakeClock.Step(400 * time.Millisecond)
		tracker.RecordRegisteredNewNode()

	// Run again, before minInterval expires.
	timer.advance(500 * time.Millisecond) // rel=500ms
	runner.Run()
	waitForDefer("too soon after first", t, timer, obj, 500*time.Millisecond)

	// Run again, before minInterval expires.
	timer.advance(499 * time.Millisecond) // rel=999ms
	runner.Run()
	waitForDefer("still too soon after first", t, timer, obj, 1*time.Millisecond)

	// Do the deferred run

			t.Fatal("need update even though just updated")
		}

		// Test transitioning the bucket to enable the GC.

		l.StartGCTransition(true, advance(109*time.Millisecond))
		l.FinishGCTransition(advance(2*time.Millisecond + 1*time.Microsecond))

		if expect := uint64((2*time.Millisecond + 1*time.Microsecond) * procs); l.Fill() != expect {
			t.Fatalf("expected fill of %d, got %d cpu-ns", expect, l.Fill())
		}

		{d: 0, want: "0s"},
		{d: time.Second - time.Millisecond, want: "0s"},
		{d: time.Second, want: "1s"},
		{d: 2*time.Second - time.Millisecond, want: "1s"},
		{d: time.Minute - time.Millisecond, want: "59s"},
		{d: time.Minute, want: "1m"},
		{d: 2*time.Minute - time.Millisecond, want: "1m"},
		{d: time.Hour - time.Millisecond, want: "59m"},
		{d: time.Hour, want: "1h"},

				case <-c:
				}
			}()
		}
		time.Sleep(1 * time.Millisecond)
		release()

		close(c) // let select put its sudog's into the cache
		time.Sleep(1 * time.Millisecond)

		// pick up top sudog
		var cond1 sync.Cond
		var mu1 sync.Mutex
		cond1.L = &mu1
		go func() {
			mu1.Lock()
			cond1.Wait()
			mu1.Unlock()
		}()
		time.Sleep(1 * time.Millisecond)

		// pick up next sudog
		var cond2 sync.Cond

	}
}

func TestJwtPubKeyEvictionForNotUsed(t *testing.T) {
	r := NewJwksResolver(
		100*time.Millisecond, /*EvictionDuration*/
		2*time.Millisecond,   /*RefreshInterval*/
		2*time.Millisecond,   /*RefreshIntervalOnFailure*/
		testRetryInterval,
	)
	defer r.Close()

	ms := startMockServer(t)
	defer ms.Stop()

	allocHog(25 * time.Millisecond)

	// checkProcStartStop relies on this.
	var wg2 sync.WaitGroup
	for i := 0; i < runtime.GOMAXPROCS(0); i++ {
		wg2.Add(1)
		go func() {
			defer wg2.Done()
			cpuHog(50 * time.Millisecond)
		}()
	}
	wg2.Wait()

	// checkSyscalls relies on this.
	done := make(chan error)
	go blockingSyscall(50*time.Millisecond, done)
	if err := <-done; err != nil {

	c := &callbackRecorder{callbacks: 0}
	ttl := NewTTLWithCallback(50*time.Millisecond, time.Millisecond, c.callback)
	testCacheEvicter(ttl)
	if atomic.LoadInt64(&c.callbacks) != 1 {
		t.Errorf("evictExpired() => failed to invoke EvictionCallback: got %d callbacks, wanted 1", c.callbacks)
	}
}

func TestTTLFinalizer(t *testing.T) {
	ttl := NewTTL(5*time.Second, 1*time.Millisecond).(*ttlWrapper)
	testCacheFinalizer(&ttl.evicterTerminated)
}

		defer close(done)
		t2 = time.Now()
		return nil
	}, 200*time.Millisecond)
	dq.PushDelayed(func() error {
		mu.Lock()
		defer mu.Unlock()
		t1 = time.Now()
		return nil
	}, 100*time.Millisecond)
	dq.Push(func() error {
		mu.Lock()
		defer mu.Unlock()
		t0 = time.Now()
		return nil
	})

	select {
	case <-time.After(500 * time.Millisecond):
	case <-done:
	}

	mu.Lock()

	go func() {
		for {
			runtime.GC()
			time.Sleep(1 * time.Millisecond)
		}
	}()

	// Start tracing.
	if err := trace.Start(os.Stdout); err != nil {
		log.Fatalf("failed to start tracing: %v", err)
	}
	// Run GOMAXPROCS a bunch of times, up and down.
	for i := 1; i <= 16; i *= 2 {
		runtime.GOMAXPROCS(i)
		time.Sleep(1 * time.Millisecond)
	}
	for i := 16; i >= 1; i /= 2 {
		runtime.GOMAXPROCS(i)