return new TcpOutgoingConnector();
    }

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

    @Provides
    BuildOperationIdFactory createBuildOperationIdFactory() {
        return new DefaultBuildOperationIdFactory();
    }

    @Provides

    private final LogLevel logLevel;
    private final Clock clock;
    private final StringBuilder buffer = new StringBuilder();
    private List<StyledTextOutputEvent.Span> spans = new ArrayList<StyledTextOutputEvent.Span>();
    private Style style = Style.Normal;

    public LoggingBackedStyledTextOutput(OutputEventListener listener, String category, LogLevel logLevel, Clock clock) {
        this.listener = listener;

        this.styledTextOutputFactory = styledTextOutputFactory;
        this.workValidationWarningReporter = workValidationWarningReporter;
        this.clock = clock;
        this.gradleEnterprisePluginManager = gradleEnterprisePluginManager;
    }

    }

    ThrottlingOutputEventListener(OutputEventListener listener, int throttleMs, ScheduledExecutorService executor, Clock clock) {
        this.throttleMs = throttleMs;
        this.listener = listener;
        this.executor = executor;
        this.clock = clock;
        scheduleUpdateNow();
    }

    private void scheduleUpdateNow() {

func delayedHealthCheck(check healthz.HealthChecker, clock clock.Clock, delay time.Duration) healthz.HealthChecker {
	return delayedLivezCheck{
		check,
		clock.Now().Add(delay),
		clock,
	}
}

type delayedLivezCheck struct {
	check      healthz.HealthChecker
	startCheck time.Time
	clock      clock.Clock
}

func (c delayedLivezCheck) Name() string {
	return c.check.Name()
}

    private final Clock clock;
    private final GarbageCollectorMXBean garbageCollectorMXBean;

    private final String heapMemoryPool;
    private final SlidingWindow<GarbageCollectionEvent> heapEvents;

    private final String nonHeapMemoryPool;
    private final SlidingWindow<GarbageCollectionEvent> nonHeapEvents;

import org.gradle.internal.time.Clock;

/**
 * Provides logging services per thread.
 */
public class SynchronizedLogging implements LoggingProvider {
    private final ThreadLocal<ThreadLoggingServices> services = new ThreadLocal<ThreadLoggingServices>();
    private final Clock clock;
    private final BuildOperationIdFactory buildOperationIdFactory;

	mu              sync.RWMutex
	CurrentState    map[status.Resource]map[string]Progress
	ObservationTime map[string]time.Time
	UpdateInterval  time.Duration
	dynamicClient   dynamic.Interface
	clock           clock.Clock
	workers         *status.Controller
	StaleInterval   time.Duration
	cmInformer      cache.SharedIndexInformer
	cmHandle        cache.ResourceEventHandlerRegistration
}

	firstNodeReadyTime           time.Time

	// For testability
	clock clock.Clock
}

func NewNodeStartupLatencyTracker() NodeStartupLatencyTracker {
	bootTime, err := GetBootTime()
	if err != nil {
		bootTime = time.Time{}
	}
	return &basicNodeStartupLatencyTracker{
		bootTime:         bootTime,
		kubeletStartTime: time.Now(),
		clock:            clock.RealClock{},
	}
}

import java.util.concurrent.CancellationException;

import static org.gradle.internal.FileUtils.hasExtension;

public class DistributionFactory {
    private final Clock clock;

    public DistributionFactory(Clock clock) {
        this.clock = clock;
    }

    /**
     * Returns the default distribution to use for the specified project.
     */