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

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

    /**
     * Measures elapsed time.
     *

import org.gradle.internal.time.Clock;

public class OutputEventListenerBackedLogger extends BuildOperationAwareLogger {

    private final String name;
    private final OutputEventListenerBackedLoggerContext context;
    private final Clock clock;

    public OutputEventListenerBackedLogger(String name, OutputEventListenerBackedLoggerContext context, Clock clock) {
        this.name = name;

import org.gradle.internal.time.Clock;

import javax.inject.Inject;

public class DefaultBuildScanClock implements BuildScanClock {

    private final Clock clock;

    @Inject
    public DefaultBuildScanClock(Clock clock) {
        this.clock = clock;
    }

    @Override
    public long getCurrentTime() {
        return clock.getCurrentTime();
    }

}

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

	recorder record.EventRecorder,
	clock clock.Clock,
) (*activeDeadlineHandler, error) {

	// check for all required fields
	if clock == nil || podStatusProvider == nil || recorder == nil {
		return nil, fmt.Errorf("required arguments must not be nil: %v, %v, %v", clock, podStatusProvider, recorder)
	}
	return &activeDeadlineHandler{
		clock:             clock,
		podStatusProvider: podStatusProvider,

import org.gradle.internal.time.Clock;

@ServiceScope(Scope.BuildTree.class)
public class ProfileCoordinator implements RootBuildLifecycleListener {
    private final BuildProfile profile;
    private final ReportGeneratingProfileListener generator;
    private final Clock clock;

    public ProfileCoordinator(BuildProfile profile, ReportGeneratingProfileListener generator, Clock clock) {
        this.profile = profile;

import org.gradle.internal.time.Clock;

public class DefaultStyledTextOutputFactory extends AbstractStyledTextOutputFactory implements StyledTextOutputFactory {
    private final OutputEventListener outputEventListener;
    private final Clock clock;

    public DefaultStyledTextOutputFactory(OutputEventListener outputEventListener, Clock clock) {
        this.outputEventListener = outputEventListener;

		}
	}()
	clock.Run(nil)
	expectGotValue(t, gots, aval)
	goGetAndExpect(t, clock, counter, wr, gots, aval)
	later := time.Now()
	bval := &later
	func() {
		lock.Lock()
		defer lock.Unlock()
		if wr.Set(bval) {
			t.Error("second Set() returned true")
		}
	}()
	goGetAndExpect(t, clock, counter, wr, gots, aval)
	counter.Add(1) // account for unblocking the receive on doneCh
	close(doneCh)

import org.gradle.internal.id.IdGenerator;
import org.gradle.internal.time.Clock;

public class JUnitTestClassProcessor extends AbstractJUnitTestClassProcessor {

    private final IdGenerator<?> idGenerator;
    private final JUnitSpec spec;
    private final Clock clock;

    public JUnitTestClassProcessor(JUnitSpec spec, IdGenerator<?> idGenerator, ActorFactory actorFactory, Clock clock) {
        super(actorFactory);
        this.spec = spec;