then:
        output.contains "the name: foobar"
    }

    @ToBeFixedForIsolatedProjects(because = "allprojects, evaluationDependsOn")
    def "shows deprecation warning when calling Project#afterEvaluate(Closure) after the project was evaluated"() {
        buildFile << '''
            allprojects { p ->
                println "[1] Adding afterEvaluate for $p.name"
                p.afterEvaluate {

            problem("Build file 'build.gradle.kts': Project ':' cannot access 'Project.plugins' functionality on $message", 2)
        }

        where:
        block         | message
        "allprojects" | "subprojects via 'allprojects'"
        "subprojects" | "subprojects"
    }

    def "reports problem when build script uses #block block to access dynamically added elements"() {
        createDirs("a", "b")

        given:
        createDirs("a", "b")
        settingsFile << "include 'a', 'b'"

        when:
        buildScript """
            ${testPluginImpl()}

            allprojects { apply type: TestPlugin }

            $code {
                model {
                    strings {
                        add "foo"
                    }
                }
            }

        """

            withLocatedProblem(new StringContains("ijIdeaPluginConfigurator"), "Project ':' cannot access 'disableSources' extension on subprojects via 'allprojects'")
            withLocatedProblem("Plugin class 'JetGradlePlugin'", "Project ':' cannot access 'Project.extensions' functionality on subprojects via 'allprojects'")

    }

    @ToBeFixedForIsolatedProjects(because = "allprojects")
    def "can use camel-case for all segments of qualified task name"() {
        createDirs("child", "child/child")
        settingsFile << "include 'child', 'child:child'"

        buildFile << """
allprojects { task thing }
"""
        when:
        run "chi:chi:th"

        then:

            buildFile << """
                allprojects {
                    apply plugin: '${pluginId}'
                    apply plugin: '${libraryPluginId}'
                }
                dependencies { implementation 'org.test:p1:1.2' }
            """
        }
        def buildB = multiProjectBuild("buildB", ["p1", "p2"]) {
            buildFile << """
                allprojects {
                    apply plugin: '${pluginId}'

        createDirs("a", "b", "c")
        settingsFile << """
                include 'a', 'b', 'c'
            """
        setupBuildWithTransformFileInputs()
        buildFile << """
            allprojects {
                ext.inputFiles = files('a.txt', 'b.txt')
            }

            project(':a') {
                dependencies {
                    implementation project(':b')

    def setup() {
        resolve.prepare()
    }

    def "can specify producer task for file dependency"() {
        settingsFile << "include 'sub'; rootProject.name='main'"
        buildFile << '''
            allprojects {
                configurations { compile }
                task jar {
                    def jarFile = file("${project.name}.jar")
                    doLast {
                        jarFile.text = 'content'

            include 'api'
            include 'shared:api', 'shared:model'
            include 'util'
        """

        def buildFile = file("build.gradle")
        buildFile << """
            allprojects {
                apply plugin: 'java'
                apply plugin: 'idea'
            }

            project(':api') {
                dependencies {
                    implementation project(':shared:api')

class ConfigurationBuildDependenciesIntegrationTest extends AbstractHttpDependencyResolutionTest {
    def setup() {
        createDirs("child")
        settingsFile << "include 'child'"
        buildFile << """
            allprojects {
                configurations {
                    compile
                    create('default').extendsFrom compile
                }
            }
            task useCompileConfiguration {