public DefaultGradleEnterprisePluginBuildState(
        Clock clock,
        BuildStartedTime buildStartedTime,
        BuildInvocationScopeId buildInvocationId,
        WorkspaceScopeId workspaceId,
        UserScopeId userId,
        StartParameter startParameter,
        ServiceRegistry serviceRegistry
    ) {
        this.clock = clock;
        this.buildStartedTime = buildStartedTime;

			test: func(t *testing.T, cache *simpleCache, clock *clocktesting.FakeClock) {
				cache.set(key1, twi1)
				got := cache.get(info2, key1)
				twiPtrEquals(t, nil, got)
				cacheLenEquals(t, cache, 1)
			},
		},
		{
			name: "expired get after set",
			test: func(t *testing.T, cache *simpleCache, clock *clocktesting.FakeClock) {
				cache.set(key1, twi1)
				clock.Step(time.Hour)
				got := cache.get(info1, key1)

	if t.t == nil {
		return
	}
	t.t.Stop()
	t.t = nil
}

var (
	// RealTimer can be passed to methods that need a clock.Timer.
	RealTimer = clock.RealClock{}.NewTimer
)

var (
	// internalClock is used for test injection of clocks
	internalClock = clock.RealClock{}

			fr.name = name
			fr.startedTimestamp = clock.Now()

			handler.ServeHTTP(w, r)
			return
		}

		fr := &requestFilterRecord{
			name:             name,
			startedTimestamp: clock.Now(),
		}
		ctx, _ = tracer.Start(ctx, name)
		r = r.WithContext(withRequestFilterRecord(ctx, fr))
		handler.ServeHTTP(w, r)
	})
}

        private final OutputEventListener listener;
        private final String category;
        private final Clock clock;

        public OutputEventDestination(OutputEventListener listener, String category, Clock clock) {
            this.listener = listener;
            this.category = category;
            this.clock = clock;
        }

        @Override
        public void onOutput(CharSequence output) {

    private final ProgressLoggerFactory progressLoggerFactory;
    private final Clock clock;
    private ProgressLogger progressLogger;
    private ProgressLogger statusProgressLogger;

    public BuildOperationProgressEventListenerAdapter(BuildOperationListener buildOperationListener, ProgressLoggerFactory progressLoggerFactory, Clock clock) {
        this.buildOperationListener = buildOperationListener;

            return new DefaultExecutorServiceFactory();
        }

        @Provides
        protected Clock createTimeProvider() {
            return Time.clock();
        }

        @Provides
        protected DistributionFactory createDistributionFactory(Clock clock) {
            return new DistributionFactory(clock);
        }

        @Provides

	expirationcache "k8s.io/client-go/tools/cache"
	"k8s.io/utils/clock"
	testingclock "k8s.io/utils/clock/testing"
)

type testObject struct {
	key string
	val string
}

// A fake objectCache for unit test.
func NewFakeObjectCache(f func() (interface{}, error), ttl time.Duration, clock clock.Clock) *ObjectCache {
	ttlPolicy := &expirationcache.TTLPolicy{TTL: ttl, Clock: clock}
	deleteChan := make(chan string, 1)
	return &ObjectCache{

    private TestDescriptorInternal currentTestClass;

    public TestClassExecutionEventGenerator(TestResultProcessor resultProcessor, IdGenerator<?> idGenerator, Clock clock) {
        this.resultProcessor = resultProcessor;
        this.idGenerator = idGenerator;
        this.clock = clock;
    }

    @Override
    public void testClassStarted(String testClassName) {

    private final BuildOperationTimeSupplier clock;
    private final CurrentBuildOperationRef current;
    private final BuildOperationListener listener;

    public DefaultBuildOperationProgressEventEmitter(BuildOperationTimeSupplier clock, CurrentBuildOperationRef current, BuildOperationListener listener) {
        this.clock = clock;
        this.current = current;
        this.listener = listener;
    }