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

    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.api.internal.artifacts.ivyservice.IvyContextManager
import org.gradle.internal.service.DefaultServiceRegistry
import spock.lang.Specification

class DependencyManagementGlobalScopeServicesTest extends Specification {
    def services = DefaultServiceRegistry.create(new DependencyManagementGlobalScopeServices())

    def "provides an IvyContextManager"() {
        expect: