import org.gradle.test.fixtures.concurrent.ConcurrentSpec

class DefaultServiceRegistryConcurrencyTest extends ConcurrentSpec {
    def "multiple threads can locate services"() {
        def registry = new DefaultServiceRegistry()
        registry.addProvider(new ServiceRegistrationProvider() {
            @Provides
            String createString(Integer value) {
                return value.toString()
            }

public class ValidationServicesFixture {

    public static ServiceRegistry getServices() {
        DefaultServiceRegistry registry = new DefaultServiceRegistry();
        registry.addProvider(new ServiceRegistrationProvider() {
            @Provides
            ExecutionGlobalServices.AnnotationHandlerRegistration createAnnotationRegistration() {
                return () -> ImmutableList.of(ValidationProblem.class);
            }

    }

    private DefaultServiceRegistry createLoggingServices(ServiceLookup clientLoggingServices) {
        // Need to use some specific logging services from the client-specific registry, rather than the global registry
        DefaultServiceRegistry loggingServices = new DefaultServiceRegistry(sharedServices);

                .execute(flowAction.parameters ?: FlowParameters.None.INSTANCE)
        }
    }

    private
    fun injectableServicesOf(serviceRegistry: ServiceRegistry): DefaultServiceRegistry {
        return DefaultServiceRegistry().apply {
            add(serviceRegistry.get(ArchiveOperations::class.java))
            add(serviceRegistry.get(ExecOperations::class.java))

    def chmod = Stub(Chmod)
    @Rule TestNameTestDirectoryProvider tmp = new TestNameTestDirectoryProvider(getClass())
    def parent = new DefaultServiceRegistry() {{
        add(FileLockManager, lockManager)
        add(Chmod, chmod)
    }}

    def registry(baseDir) {
        new DefaultServiceRegistry(parent).addProvider(new DaemonRegistryServices(tmp.createDir(baseDir)))
    }

    def classPath = ClassPath.EMPTY
    BuildSessionState state

    def setup() {
        _ * userHomeServiceRegistry.getServicesFor(_) >> new DefaultServiceRegistry()
        def services = new DefaultServiceRegistry()
        services.add(BuildSessionActionExecutor, actionExecutor)
        services.add(listenerManager)
        _ * crossBuildState.services >> services

import org.gradle.internal.concurrent.ExecutorFactory;
import org.gradle.internal.operations.BuildOperationIdFactory;
import org.gradle.internal.operations.DefaultBuildOperationIdFactory;
import org.gradle.internal.service.DefaultServiceRegistry;
import org.gradle.internal.service.Provides;
import org.gradle.internal.time.Clock;
import org.gradle.internal.time.Time;
import org.gradle.tooling.CancellationTokenSource;

        DefaultServiceRegistry registry = new DefaultServiceRegistry();
        registry.addProvider(new ServiceRegistrationProvider() {
            @Provides
            RepositoryResourceAccessor createResourceAccessor() {

    }

    public ServiceRegistry build() {
        ServiceRegistry[] parents = this.parents.toArray(new ServiceRegistry[0]);

        DefaultServiceRegistry registry = scope != null
            ? new ScopedServiceRegistry(scope, strict, displayName, parents)
            : new DefaultServiceRegistry(displayName, parents);

        for (ServiceRegistrationProvider provider : providers) {
            registry.addProvider(provider);
        }

import org.gradle.api.internal.tasks.testing.TestResultProcessor
import org.gradle.api.internal.tasks.testing.WorkerTestClassProcessorFactory
import org.gradle.internal.remote.ObjectConnection
import org.gradle.internal.service.DefaultServiceRegistry
import org.gradle.internal.time.Clock
import org.gradle.internal.time.Time
import org.gradle.process.internal.worker.WorkerProcessContext
import org.gradle.test.fixtures.concurrent.ConcurrentSpec