return projectsForThisBuild != null && projectsForThisBuild.getRootProject().isCreated();
    }

    @Override
    public void ensureProjectsConfigured() {
        getBuildController().configureProjects();
    }

    @Override
    public GradleInternal getMutableModel() {
        return getBuildController().getGradle();
    }

    @Override
    public BuildWorkGraphController getWorkGraph() {

            throw new IllegalArgumentException("Project has unexpected owner.");
        }
        // Force configuration of the containing build and then locate the builder for target project
        buildController.configureProjects();
        return doLocate(target, modelName, param);
    }

    private ToolingModelScope doLocate(ProjectState target, String modelName, boolean param) {

     */
    <T> T withSettings(Function<? super SettingsInternal, T> action);

    /**
     * Configures the projects of the build, if not already done.
     * Can be called multiple times.
     */
    void configureProjects();

    /**
     * Runs the given action against the mutable state of this build after configuring the projects of the build.
     * This may fail with an error, if this build is loaded from cache rather than configured.

           }
           gradle.addListener(listener)
       """
    }

    void afterBuild() {
        configuredProjects = asList(fixtureData.text.split(";"))
        assert fixtureData.delete()
    }

    void assertProjectsConfigured(String ... projectPaths) {
        assert configuredProjects == projectPaths
    }

                }
            """
        )
        configureProject().assertBuildScriptCompiled().assertOutputContains("foo")

        withPrecompiledScriptPluginInBuildSrc(
            pluginId,
            """
                tasks.register("foo") { doLast { println("bar from task") } }
            """
        )
        configureProject("foo").assertBuildScriptCompilationAvoided().assertOutputContains("bar from task")

        )
        withUniqueScript("$packageName.foo()")
        configureProject().assertBuildScriptCompiled().assertOutputContains("foo")

        givenKotlinScriptInBuildSrcContains(
            "Foo",
            """
            fun foo() {
                println("bar")
            }
            """
        )
        configureProject().assertBuildScriptCompilationAvoided().assertOutputContains("bar")
    }

        1 * projectRegistry.addProject(project)
        1 * dependencyResolutionManagement.configureProject(project)
    }

    def "creates a project with missing build script"() {
        def buildFile = tmpDir.file("build.gradle")
        def projectDir = tmpDir.createFile("project")

        given:

import java.util.List;

@ServiceScope(Scope.Build.class)
public interface DependencyResolutionManagementInternal extends DependencyResolutionManagement, FinalizableValue {

    void configureProject(ProjectInternal project);

    void applyRules(ComponentMetadataHandler target);

    RepositoriesModeInternal getConfiguredRepositoriesMode();

    RulesModeInternal getConfiguredRulesMode();

    @Override

        return "$packageName.$className"
    }

    protected
    fun withUniqueScript(script: String) = withBuildScript(script).apply {
        bustScriptCache()
    }

    protected
    fun configureProject(vararg tasks: String): BuildOperationsAssertions {
        val buildOperations = BuildOperationsFixture(executer, testDirectoryProvider)
        val output = executer.withTasks(*tasks).run().normalizedOutput

            owner,
            serviceRegistryFactory,
            selfClassLoaderScope,
            baseClassLoaderScope
        );
        gradle.getServices().get(DependencyResolutionManagementInternal.class).configureProject(project);
        project.beforeEvaluate(p -> {
            NameValidator.validate(project.getName(), "project name", DefaultProjectDescriptor.INVALID_NAME_IN_INCLUDE_HINT);