ClassLoaderScope baseProjectClassLoaderScope = gradle.baseProjectClassLoaderScope();
        ClassLoaderScope rootProjectClassLoaderScope = baseProjectClassLoaderScope.createChild("root-project[" + gradle.getIdentityPath() + "]", null);

        ProjectState projectState = gradle.getOwner().getProjects().getProject(rootProjectDescriptor.path());

        when:
        def scope1 = root.createChild("child1", null).export(c1).local(c2).lock()
        scope1.exportClassLoader

        def scope2 = root.createChild("child2", null).export(c1).local(c2).lock()
        scope2.exportClassLoader

        then:
        scope1.exportClassLoader.is scope2.exportClassLoader

        when:
        def child = scope1.createChild("child", null).export(c1).local(c2).lock()

        expect:
        action.execute()
    }

    void appliesScriptsToDefaultTargetObject() {
        given:
        1 * resolver.resolveUri('script') >> file
        1 * parentCompileScope.createChild("script-$file", null) >> scriptCompileScope
        1 * scriptHandlerFactory.create(_, scriptCompileScope) >> scriptHandler

                return createChild();
            }

            @Override
            public VersionHierarchy mergeWithExisting(VersionHierarchy child) {
                return createChild();
            }

            @Override
            public VersionHierarchy createChild() {
                return VersionHierarchy.empty(newVersion);
            }

import org.gradle.internal.classpath.ClassPath;
import org.gradle.internal.hash.HashCode;

import javax.annotation.Nullable;
import java.util.function.Function;

/**
 * Provides common {@link #getPath} and {@link #createChild} behaviour for {@link ClassLoaderScope} implementations.
 */
public abstract class AbstractClassLoaderScope implements ClassLoaderScope {

    protected final ClassLoaderScopeIdentifier id;
    @Nullable

    def broadcasterDoesNothingWhenNoListenersRegistered() {
        when:
        manager.getBroadcaster(TestFooListener.class).foo("param")
        manager.createChild(Scope.Build).getBroadcaster(BuildScopeListener.class).foo("param")
        manager.createChild(Scope.Build).createAnonymousBroadcaster(BuildScopeListener.class).source.foo("param")

        then:
        0 * _
    }

    def cachesBroadcasters() {

import org.gradle.api.internal.project.ProjectInternal;
import org.gradle.internal.instantiation.InstantiationScheme;

import javax.annotation.Nullable;

public interface ITaskFactory {
    ITaskFactory createChild(ProjectInternal project, InstantiationScheme instantiationScheme);

    /**
     * @param constructorArgs null == do not invoke constructor, empty == invoke constructor with no args, non-empty = invoke constructor with args

        String siblingPath = targetPath.pathFromChild(commonPrefix).getAsString();
        ChildMap.Entry<T> sibling = new ChildMap.Entry<>(siblingPath, handler.createChild());
        ChildMap<T> newChildren = ChildMapFactory.childMap(caseSensitivity, newChild, sibling);
        return withReplacedChild(commonPrefix, handler.createNodeFromChildren(newChildren));
    }

    @Override

        this.taskFactory = taskFactory;
    }

    @Override
    public ITaskFactory createChild(ProjectInternal project, InstantiationScheme instantiationScheme) {
        return new AnnotationProcessingTaskFactory(instantiator, taskClassInfoStore, taskFactory.createChild(project, instantiationScheme));
    }

    @Override

    ProjectState rootProjectState = Mock(ProjectState)

    def rootProjectClassLoaderScope = Mock(ClassLoaderScope)
    def baseProjectClassLoaderScope = Mock(ClassLoaderScope) {
        1 * createChild("root-project[:]", null) >> rootProjectClassLoaderScope
    }

    @Rule
    public TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    def setup() {