gradleScopedServices
        );
    }

    @Provides
    PluginRegistry createPluginRegistry(PluginRegistry parentRegistry) {
        return parentRegistry.createChild(get(GradleInternal.class).getClassLoaderScope());
    }

    @Provides

            @Provides
            TestListener createListener() {
                created.run()
                return listener
            }
        })
        def broadcast = listenerManager.createChild(Scope.BuildTree).getBroadcaster(TestListener)

        then:
        0 * _

        when:
        broadcast.something("12")

        then:
        1 * created.run()
        1 * listener.something("12")

            controller.withEmptyBuild { settings ->
                Try.ofFailable {
                    val gradle = settings.gradle
                    val baseScope = classLoaderScopeRegistry.coreAndPluginsScope.createChild("accessors-classpath", null).apply {
                        // we export the build logic classpath to the base scope here so that all referenced plugins

    }

    @Provides
    ScopedListenerManager createListenerManager(ScopedListenerManager parent) {
        return parent.createChild(Scope.UserHome.class);
    }

    @Provides
    ScriptSourceHasher createScriptSourceHasher() {
        return new DefaultScriptSourceHasher();
    }

    @Provides

        }
    }

    @Override
    public DefaultListenerManager createChild(Class<? extends Scope> scope) {
        return new DefaultListenerManager(scope, this);
    }

    /**
     * Manages the listeners and state for a given listener type
     */

        return new DefaultTextFileResourceLoader(resolver);
    }

    @Provides
    protected ScopedListenerManager createListenerManager(ScopedListenerManager listenerManager) {
        return listenerManager.createChild(Scope.Build.class);
    }

    @Provides
    protected ClassPathRegistry createClassPathRegistry() {
        ModuleRegistry moduleRegistry = get(ModuleRegistry.class);
        return new DefaultClassPathRegistry(

        container.addAll([task1, task2, task3])

        then:
        thrown(UnsupportedOperationException)
    }

    def factory = new TaskInstantiator(taskIdentityFactory, new TaskFactory().createChild(project, TestUtil.instantiatorFactory().decorateScheme()), project)
    SomeTask a = factory.create("a", SomeTask)
    SomeTask b = factory.create("b", SomeTask)
    SomeTask c = factory.create("c", SomeTask)

            Path idPath = buildPath != null ? buildPath : assignPath(rootBuild, buildName, buildDir);
            BuildIdentifier buildIdentifier = idFor(idPath);

            includedBuild = includedBuildFactory.createBuild(buildIdentifier, buildDefinition, isImplicit, rootBuild);
            includedBuildsByRootDir.put(buildDir, includedBuild);
            nestedBuildsByRootDir.put(buildDir, includedBuild);

) : BuildTreeConfigurationCache, Stoppable {

    interface Host : HostServiceProvider {

        val currentBuild: VintageGradleBuild

        fun createBuild(settingsFile: File?): ConfigurationCacheBuild

        fun visitBuilds(visitor: (VintageGradleBuild) -> Unit)

        fun <T> factory(serviceType: Class<T>): Factory<T>
    }

    private

    }

    private
    suspend fun DefaultReadContext.readRootBuild(): List<CachedBuildState> {
        val settingsFile = read() as File?
        val rootBuild = host.createBuild(settingsFile)
        val gradle = rootBuild.gradle
        readBuildTreeScopedState(gradle)
        return readBuildsInTree(rootBuild)
    }

    private