public DefaultServiceRegistry() {
        this(null, NO_PARENTS);
    }

    public DefaultServiceRegistry(String displayName) {
        this(displayName, NO_PARENTS);
    }

    public DefaultServiceRegistry(ServiceRegistry... parents) {
        this(null, parents);
    }

    public DefaultServiceRegistry(@Nullable String displayName, ServiceRegistry... parents) {

        def root = new DefaultServiceRegistry()
        root.add(String, "root")
        def parent1 = new DefaultServiceRegistry(root)
        parent1.add(String, "p1")
        def parent2 = new DefaultServiceRegistry(root)
        parent2.add(String, "p2")
        def registry = new DefaultServiceRegistry(parent1, parent2)

        expect:

class AccessModifierDefaultServiceRegistryTest extends Specification {

    def "can add type to registry that has package private constructor"() {
        when:
        def registry = new DefaultServiceRegistry()
        registry.register {
            it.add(String, "Potato")
            it.add(ModifierStubs.PackagePrivateConstructor)
        }
        then:
        noExceptionThrown()

        this.managedFactory = new ManagedTypeFactory(injectOnlyScheme.deserializationInstantiator());
    }

    private DefaultServiceRegistry defaultServiceRegistry() {
        DefaultServiceRegistry services = new DefaultServiceRegistry("default services");
        services.add(InstantiatorFactory.class, this);
        return services;
    }

    @Override

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);
            }

 * limitations under the License.
 */
package org.gradle.api.internal.artifacts

import org.gradle.internal.service.DefaultServiceRegistry
import spock.lang.Specification

class DependencyManagementBuildScopeServicesTest extends Specification {
    def services = DefaultServiceRegistry.create(new DependencyManagementBuildScopeServices())

    def "provides a DependencyManagementServices"() {
        expect:

    }

    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)))
    }