},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			clock := testingclock.NewFakeClock(time.Time{}.Add(24 * time.Hour))
			mgr := NewManager(nil)
			mgr.clock = clock

			mgr.set("key", &authenticationv1.TokenRequest{
				Status: authenticationv1.TokenRequestStatus{
					ExpirationTimestamp: metav1.Time{Time: mgr.clock.Now().Add(c.relativeExp)},
				},
			})
			mgr.cleanup()

        1 * nanoTime() >> START_NANOS
    }

    private Clock clock = new MonotonicClock(timeSource, SYNC_INTERVAL)

    def "prevents time from going backwards"() {
        when:
        setNanos 0

        then:
        clock.currentTime == START_MILLIS + 0

        when:
        setNanos 10

        then:
        clock.currentTime == START_MILLIS + 10

        when:
        setNanos 8

            if (!requestMetaData.isInteractive()) {
                return new NonInteractiveUserInputHandler();
            }

            return new DefaultUserInputHandler(outputEventListenerManager.getBroadcaster(), clock, inputReader);
        }

        @Provides

    private final Clock clock;
    private final Object lock = new Object();
    private final Map<Description, TestDescriptorInternal> executing = new HashMap<Description, TestDescriptorInternal>();
    private final Set<Description> assumptionFailed = new HashSet<Description>();

    public JUnitTestEventAdapter(TestResultProcessor resultProcessor, Clock clock, IdGenerator<?> idGenerator) {

    public ProfileEventAdapter(BuildProfile buildProfile, BuildStartedTime buildStartedTime, Clock clock) {
        this.buildProfile = buildProfile;
        this.buildStartedTime = buildStartedTime;
        this.clock = clock;
    }

    // BuildListener
    @Override
    public void beforeSettings(Settings settings) {
        long now = clock.getCurrentTime();
        buildProfile.setBuildStarted(now);

    private final ActorFactory actorFactory;
    private final ForkedTestClasspathFactory testClasspathFactory;
    private final WorkerLeaseService workerLeaseService;
    private final int maxWorkerCount;
    private final Clock clock;
    private final DocumentationRegistry documentationRegistry;
    private final DefaultTestFilter testFilter;
    private TestClassProcessor processor;

    public DefaultTestExecuter(

 * in between syncs with the system wall clock.
 * When issuing the first timestamp after the sync interval has expired,
 * The system wall clock will be read, and the current time set to the max of wall clock time or the most recently issued timestamp.
 * All other timestamps are calculated as the wall clock time at last sync + elapsed time since.
 * <p>
 * This clock deals relatively well when the system wall clock shift is adjusted by small amounts.

     */
    public static Clock clock() {
        return CLOCK;
    }

    /**
     * Replacement for System.currentTimeMillis(), based on {@link #clock()}.
     */
    public static long currentTimeMillis() {
        return CLOCK.getCurrentTime();
    }

    /**
     * Measures elapsed time.
     *

}

type basicWorkQueue struct {
	clock clock.Clock
	lock  sync.Mutex
	queue map[types.UID]time.Time
}

var _ WorkQueue = &basicWorkQueue{}

// NewBasicWorkQueue returns a new basic WorkQueue with the provided clock
func NewBasicWorkQueue(clock clock.Clock) WorkQueue {
	queue := make(map[types.UID]time.Time)
	return &basicWorkQueue{queue: queue, clock: clock}
}

func (q *basicWorkQueue) GetWork() []types.UID {

	// Dial the time to 1 hour ahead.
	clock.Step(time.Hour)
	expected = []types.UID{types.UID("foo3"), types.UID("foo4")}
	compareResults(t, expected, q.GetWork())
	compareResults(t, []types.UID{}, q.GetWork())
}

func TestNewBasicWorkQueue(t *testing.T) {
	tests := []struct {
		clock             clock.Clock
		expectedWorkQueue WorkQueue
	}{
		{
			clock:             clock.RealClock{},