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}'

    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'

    }

    String getCleanTaskName() {
        return "clean${lifeCycleTaskName.capitalize()}"
    }

    Project project(String projectName, boolean allProjects = true, Closure configClosure) {
        String applyTo = allProjects ? "allprojects" : "subprojects"
        buildFile.createFile().text = """
$applyTo {
    apply plugin:'java'
    apply plugin:'$ideName'
}
"""

    @Test
    @ToBeFixedForConfigurationCache
    void "external dependency substituted with project dependency"() {
        createDirs("project1", "project2")
        runEclipseTask("include 'project1', 'project2'", """
allprojects {
    apply plugin: "java"
    apply plugin: "eclipse"
}

project(":project2") {
    dependencies {
        implementation group: "junit", name: "junit", version: "4.7"
    }

    configurations.all {

"""
    }

    def 'does not apply lock defined in a dependent project'() {
        mavenRepo.module('org', 'foo', '1.0').publish()
        mavenRepo.module('org', 'foo', '1.1').publish()

        buildFile << """
allprojects {
    apply plugin: 'java-library'
    repositories {
        maven { url "${mavenRepo.uri}" }
    }
}

project(':first') {
    configurations.all {
        resolutionStrategy.activateDependencyLocking()

        root.file("src/main/groovy/org/gradle/Class1.groovy") << "package org.gradle; class Class1 { }"
        root.file('build.gradle') << """

            allprojects {
                ${mavenCentralRepository()}
            }

            allprojects {
                apply plugin: 'groovy'

                dependencies {
                    implementation $groovyVersion
                }
            }

        given:
        settingsFile << """
            rootProject.name = 'multi'
            include 'a', 'b'
        """
        buildFile << """
            allprojects { apply plugin: 'java' }

            evaluationDependsOn(':a')
"""
        file("a/build.gradle") << """
            evaluationDependsOn(':b')
"""

        when:
        def events = ProgressEvents.create()

        mavenRepo.module("org", "foo", '1.4.4').publish()

        createDirs("api", "impl", "tool")
        settingsFile << "include 'api', 'impl', 'tool'"

        buildFile << """
allprojects {
	apply plugin: 'java'
	repositories { maven { url "${mavenRepo.uri}" } }
}

project(':api') {
	dependencies {
		implementation (group: 'org', name: 'foo', version:'1.4.4')
	}
}