return new NestedLogging();
    }

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

    @Provides
    protected StyledTextOutputFactory createStyledTextOutputFactory() {
        return new DefaultStyledTextOutputFactory(getStdoutListener(), get(Clock.class));
    }

    protected TextStreamOutputEventListener getStdoutListener() {

	mu              sync.Mutex                          // guards call to set
	recordCacheSize func(providerName string, size int) // for unit tests
}

func newSimpleCache(clock clock.Clock, ttl time.Duration, providerName string) *simpleCache {
	cache := utilcache.NewExpiringWithClock(clock)
	cache.AllowExpiredGet = true // for a given key, the value (the decryptTransformer) is always the same
	return &simpleCache{
		cache: cache,
		ttl:   ttl,

        return loggingManagerFactory.create();
    }

    @Provides
    @Override
    protected BuildOperationProgressEventEmitter createBuildOperationProgressEventEmitter(
        Clock clock,
        CurrentBuildOperationRef currentBuildOperationRef,
        BuildOperationListenerManager listenerManager
    ) {
        return new NoOpBuildOperationProgressEventEmitter();
    }

}

func initReporterWithoutStarting() (out Reporter) {
	out.PodName = "tespod"
	out.inProgressResources = map[string]*inProgressEntry{}
	out.client = nil              // TODO
	out.clock = clock.RealClock{} // TODO
	out.UpdateInterval = 300 * time.Millisecond
	out.cm = nil // TODO
	out.reverseStatus = make(map[string]sets.String)
	out.status = make(map[string]string)
	return
}

    def test = Mock(TestClassRunInfo)
    def resultProcessor = Mock(TestResultProcessor)
    def worker = new TestWorker(factory)
    def serviceRegistry = new DefaultServiceRegistry().add(Clock, Time.clock())

    def setup() {
        workerContext.workerId >> "<worker-id>"
        workerContext.serverConnection >> connection
        workerContext.serviceRegistry >> serviceRegistry
    }

import org.gradle.internal.service.scopes.ServiceScope;

/**
 * A view of the Gradle runtime's clock used by build scans.
 *
 * The provider is _required_ to provide monotonic timestamps.
 *
 * @since 4.2
 */
@ServiceScope(Scope.BuildTree.class)
public interface BuildScanClock {

    /**
     * The current wall clock time.
     */
    long getCurrentTime();

import org.gradle.internal.logging.events.UpdateNowEvent
import org.gradle.internal.time.Clock
import org.gradle.internal.time.MockClock
import org.gradle.util.internal.MockExecutor
import spock.lang.Subject

class ThrottlingOutputEventListenerTest extends OutputSpecification {
    def listener = Mock(OutputEventListener)
    def clock = new MockClock()
    def executor = new MockExecutor()

            LOG.info("Full recompilation is required because the source roots could not be inferred.");
            return rebuildAllCompiler.execute(spec);
        }

        Timer clock = Time.startTimer();
        CurrentCompilation currentCompilation = new CurrentCompilation(spec, classpathSnapshotter);

import org.gradle.internal.operations.BuildOperationIdFactory
import org.gradle.internal.time.Clock
import org.gradle.test.fixtures.concurrent.ConcurrentSpec

import java.util.concurrent.CopyOnWriteArraySet

public class SynchronizedLoggingTest extends ConcurrentSpec {
    def logging = new SynchronizedLogging(Stub(Clock), Stub(BuildOperationIdFactory))

    def "initialises on first usage"() {
        expect:

	return withRequestDeadline(handler, sink, policy, longRunning, negotiatedSerializer, requestTimeoutMaximum, clock.RealClock{})
}

func withRequestDeadline(handler http.Handler, sink audit.Sink, policy audit.PolicyRuleEvaluator, longRunning request.LongRunningRequestCheck,
	negotiatedSerializer runtime.NegotiatedSerializer, requestTimeoutMaximum time.Duration, clock clock.PassiveClock) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {