internal val targetScope: ClassLoaderScope,
    private val baseScope: ClassLoaderScope,
    private val serviceRegistry: ServiceRegistry
) {

    internal
    val fileName = scriptSource.fileName!!

    internal
    val fileOperations: FileOperations by unsafeLazy {
        fileOperationsFor(serviceRegistry, scriptSource.resource.location.file?.parentFile)
    }

    internal

    private final ServiceRegistry serviceRegistry;

    public BinarySourceTransformations(TaskContainer tasks, LanguageTransformContainer transforms, ServiceRegistry serviceRegistry) {
        this.tasks = tasks;
        this.prioritizedTransforms = prioritize(transforms);
        this.serviceRegistry = serviceRegistry;
    }

    public void createTasksFor(BinarySpecInternal binary) {

            final FileResolver fileResolver = serviceRegistry.get(FileResolver.class);
            final ExecActionFactory execActionFactory = serviceRegistry.get(ExecActionFactory.class);
            final CompilerOutputFileNamingSchemeFactory compilerOutputFileNamingSchemeFactory = serviceRegistry.get(CompilerOutputFileNamingSchemeFactory.class);

        def dependency = Mock(ServiceDependency)
        def serviceRegistry = Mock(ServiceRegistry)
        1 * serviceRegistry.find(ServiceDependency) >> dependency
        1 * serviceRegistry.get(InstantiatorFactory) >> TestUtil.instantiatorFactory()

        def subject = new DependencyInjectingServiceLoader(serviceRegistry)

        when:
        def service = subject.load(ServiceType, classLoader).iterator().next()

    }
    def factory = new ProjectFactory(instantiator, new DefaultTextFileResourceLoader(), scriptResolution)
    def rootProjectScope = Mock(ClassLoaderScope)
    def baseScope = Mock(ClassLoaderScope)
    def serviceRegistry = Mock(ServiceRegistry)
    def dependencyResolutionManagement = Mock(DependencyResolutionManagementInternal)

    def setup() {
        owner.buildIdentifier >> buildId
    }

import org.gradle.internal.service.ServiceRegistry;

public class FlatClassLoaderWorker extends AbstractClassLoaderWorker {
    private final ClassLoader workerClassLoader;

    public FlatClassLoaderWorker(ClassLoader workerClassLoader, ServiceRegistry serviceRegistry, ActionExecutionSpecFactory actionExecutionSpecFactory, InstantiatorFactory instantiatorFactory) {
        super(serviceRegistry, actionExecutionSpecFactory, instantiatorFactory);

				ServiceRegistry: provider.Kubernetes,
				Name:            "reviews",
				Namespace:       "default",
			},
			"reviews.default.svc.cluster.local",
		},
		{
			"Service With Port pattern",
			"%SERVICE%_%SERVICE_PORT%",
			"reviews.default.svc.cluster.local",
			"",
			0,
			&model.Port{Name: "grpc-svc", Port: 7443, Protocol: "GRPC"},
			&model.ServiceAttributes{
				ServiceRegistry: provider.Kubernetes,

        this.scope = scope;
        this.strict = true;
        return this;
    }

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

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

                                                    final File buildDir, ServiceRegistry serviceRegistry) {

        final BinaryNamingScheme namingScheme = namingSchemeFor(testSuite, (NativeBinarySpecInternal) testedBinary, typeString);
        final NativeDependencyResolver resolver = serviceRegistry.get(NativeDependencyResolver.class);

     */
    ServiceRegistry getServicesFor(File gradleUserHomeDir);

    /**
     * Locates the shared services from the last used user home dir - if any.
     *
     * The method will never create services, so the caller should not release the registry.
     */
    Optional<ServiceRegistry> getCurrentServices();

    /**