LOGGER.warn("Project accessors enabled, but root project name not explicitly set for '" + project.getName() +
                "'. Checking out the project in different folders will impact the generated code and implicitly the buildscript classpath, breaking caching.");
        }
    }

    private void executeWork(UnitOfWork work) {
        ExecutionEngine.Result result = engine.createRequest(work).execute();

    }

    void 'finalizer tasks are not run when finalized task does not run due to unrelated task failure and not using --continue'() {
        given:
        buildScript("""
            task a {
            }
            task b {
                finalizedBy a
                doLast {
                    throw new RuntimeException("broken")
                }
            }

    val appliedPlugins: List<String>
)


private
fun ProjectInternal.applyPlugins(pluginRequests: PluginRequests) {
    serviceOf<PluginRequestApplicator>().applyPlugins(
        pluginRequests,
        buildscript,
        pluginManager,
        classLoaderScope
    )
}


private
fun <T> withCapturedOutputOnError(block: () -> T, onError: (ErrorWithCapturedOutput) -> T): T {

        'build.gradle.kts'
    }

    /**
     * Sets (replacing) the contents of the build.gradle file.
     *
     * To append, use #buildFile(String).
     */
    protected TestFile buildScript(@GroovyBuildScriptLanguage String script) {
        buildFile.text = script
        buildFile
    }

    /**
     * Sets (replacing) the contents of the settings.gradle file.
     *

However, it will use a single shared classloader for all units of work.
This means that each unit of work can affect one another through static class state.
It also means that every unit of work uses the same version of libraries on the buildscript classpath.
If you wanted the user to be able to configure the task to run with a different (but compatible) version of the

                        version = "1.0"
                        from root
                    }
                }
            }
        """
    }

    /**
     * Buildscript code that should only be defined once
     */
    def header() {
        """
            plugins {
                id 'maven-publish'
            }

            publishing {

        return project
    }

    //TODO please move more coverage to NewDefaultProjectTest

    def scriptClasspath() {
        when:
        project.buildscript {
            repositories
        }

        then:
        1 * scriptHandlerMock.getRepositories()
    }

    def testProject() {
        expect:
        project.is(child1.parent)

    @Issue("https://github.com/gradle/gradle/issues/15679")
    def "fileTrees with regular file roots cannot be used as output files"() {
        enableProblemsApiCheck()
        expectReindentedValidationMessage()
        buildScript """
            task myTask {
                inputs.file file('input.txt')
                outputs.files(files('build/output.txt').asFileTree).withPropertyName('output')
                doLast {

        if (start >= 0) {
            existingScript = existingScript.substring(0, start) + existingScript.substring(end, existingScript.length())
        }
        def buildScriptBlock = """
buildscript {
    dependencies.classpath files("${ClasspathUtil.getClasspathForClass(GenerateGraphTask).toURI()}")
}
"""
        String generatedContent = ""
        builder.configs.forEach { config, taskName ->

Previously, any `pluginManagement {}` blocks inside a settings script were executed during the normal execution of the script.

Now, they are executed earlier in a similar manner to `buildscript {}` or `plugins {}`.
This means that code inside such a block cannot reference anything declared elsewhere in the script.