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:

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

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.event

import org.gradle.internal.service.DefaultServiceRegistry
import org.gradle.internal.service.Provides
import org.gradle.internal.service.ServiceRegistrationProvider
import org.gradle.internal.service.scopes.EventScope
import org.gradle.internal.service.scopes.ListenerService

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;