}

    @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:

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

        fixture.assertProjectsConfigured(":")
    }

    @ToBeFixedForIsolatedProjects(because = "allprojects")
    def "evaluates only project referenced in the task list"() {
        createDirs("api", "impl", "util", "util/impl")
        settingsFile << "include 'api', 'impl', 'util', 'util:impl'"
        buildFile << "allprojects { task foo }"

        when:
        run(":util:impl:foo")

        then:

        succeeds(tasks)
        createdTasks
    }

    @ToBeFixedForIsolatedProjects(because = "allprojects")
    def "does not create rule based tasks in projects without required tasks"() {
        when:
        createDirs("a", "b", "c")
        settingsFile << "include 'a', 'b', 'c'"
        buildFile << """
            allprojects {
                model {
                    tasks {
                        create("t1") {

            gradle.lifecycle.afterProject { println("lifecycle: gradle.lifecycle.afterProject '\${it.path}'") }

            // register eager callbacks
            gradle.allprojects { println("lifecycle: gradle.allprojects '\${it.path}'") }
            gradle.beforeProject { println("lifecycle: gradle.beforeProject '\${it.path}'") }
            gradle.afterProject { println("lifecycle: gradle.afterProject '\${it.path}'") }

rootProject.name = 'test'
include 'a', 'b'
"""
        buildFile << """
def usage = Attribute.of('usage', String)
def flavor = Attribute.of('flavor', String)
def buildType = Attribute.of('buildType', String)

allprojects {
    dependencies {
       attributesSchema {
          attribute(usage)
          attribute(flavor)
          attribute(buildType)
       }
    }
    configurations {
        compile

        given:
        settingsFile << """
            include('a')
            include('b')
        """
        withSomeToolingModelBuilderPluginInBuildSrc()
        buildFile << """
            allprojects {
                plugins.apply('java-library')
            }
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI)
        fetchModelFails()

        this.features = features;
    }

    @Override
    public void beforeProject(Action<? super Project> action) {
        // Preserve behavior when Isolated Projects is not enabled:
        // - `allprojects` executes eagerly before any project has been evaluated, allowing its effects
        //   to be observable from other eager configuration blocks (e.g., `subprojects { ... }`).

                    project.allprojects.each { p ->
                        p.configurations.compileClasspath.files()
                    }
                    return ["result"]
                }
            }

            project.services.get(ToolingModelBuilderRegistry.class).register(new MyModelBuilder())

            allprojects {
                apply plugin: 'java-library'
            }

    def "jdkName property from idea module model is available in the tooling API"() {
        given:
        settingsFile << "\ninclude 'root', 'child1', 'child2', 'child3'"
        buildFile << """
            allprojects {
                apply plugin: 'idea'
                apply plugin: 'java'
            }

            idea {
                module {
                    jdkName = 'MyJDK1'
                }
            }