import org.gradle.internal.time.Clock;

public class TestExecutionBuildOperationBuildSessionScopeServices implements ServiceRegistrationProvider {

    @Provides
    TestListenerBuildOperationAdapter createTestListenerBuildOperationAdapter(BuildOperationListenerManager listener, BuildOperationIdFactory buildOperationIdFactory, Clock clock) {

import org.gradle.internal.time.Clock;

public class WorkerTestClassProcessor extends SuiteTestClassProcessor {

    public WorkerTestClassProcessor(TestClassProcessor processor, Object workerSuiteId, String workerDisplayName,
                                    Clock clock) {
        super(new WorkerTestSuiteDescriptor(workerSuiteId, workerDisplayName), processor, clock);
    }

        this.suiteFiles = suiteFiles;
    }

    @Override
    public TestClassProcessor create(IdGenerator<?> idGenerator, ActorFactory actorFactory, Clock clock) {
        return new TestNGTestClassProcessor(testReportDir, options, suiteFiles, idGenerator, clock, actorFactory);
    }

var work workType

type workType struct {
	full  lfstack          // lock-free list of full blocks workbuf
	_     cpu.CacheLinePad // prevents false-sharing between full and empty
	empty lfstack          // lock-free list of empty blocks workbuf
	_     cpu.CacheLinePad // prevents false-sharing between empty and nproc/nwait

	wbufSpans struct {
		lock mutex
		// free is a list of spans dedicated to workbufs, but

    final IntegrationTestBuildContext buildContext
    final GradleDistribution gradleDistribution
    final BuildExperimentRunner experimentRunner
    final Clock clock = Time.clock()

    String testClassName
    String testId
    String testGroup
    String testProject
    List<BuildExperimentSpec> specs = []
    boolean measureGarbageCollection = true

        this.spec = spec;
    }

    @Override
    public TestClassProcessor create(IdGenerator<?> idGenerator, ActorFactory actorFactory, Clock clock) {
        return new JUnitTestClassProcessor(spec, idGenerator, actorFactory, clock);
    }

    private final IdGenerator<?> idGenerator;
    private final Clock clock;
    private final ActorFactory actorFactory;
    private ClassLoader applicationClassLoader;
    private Actor resultProcessorActor;
    private TestResultProcessor resultProcessor;

    public TestNGTestClassProcessor(File testReportDir, TestNGSpec spec, List<File> suiteFiles, IdGenerator<?> idGenerator, Clock clock, ActorFactory actorFactory) {

    fun `ignores unresolved pluginsManagement blocks before plugins`() {
        val result = pluginsSchema.runChecks(
            """
            pluginManagement { }
            pluginManagement { }
            plugins { }
            """.trimIndent()
        )

        assertTrue(result.isEmpty())
    }

    @Test
    fun `reports all order violations for plugins blocks`() {
        val result = pluginsSchema.runChecks(

}

func (i *objectCacheItem) setLastAccessTime(time time.Time) {
	i.lock.Lock()
	defer i.lock.Unlock()
	i.lastAccessTime = time
}

func (i *objectCacheItem) setImmutable() {
	i.lock.Lock()
	defer i.lock.Unlock()
	i.immutable = true
}

func (i *objectCacheItem) stopIfIdle(now time.Time, maxIdleTime time.Duration) bool {
	i.lock.Lock()
	defer i.lock.Unlock()
	// Ensure that we don't try to stop not yet initialized reflector.

    private final AtomicReference<OutputEventListener> outputEventListener = new AtomicReference<OutputEventListener>();
    private final Clock clock;

    public OutputEventListenerBackedLoggerContext(Clock clock) {
        this.clock = clock;
        applyDefaultLoggersConfig();
        reset();
    }

    private void applyDefaultLoggersConfig() {
        addNoOpLogger("java.lang.ProcessBuilder");