}

    private void applyIdeaPluginToBuildTree(ProjectInternal root, List<GradleInternal> alreadyProcessed) {
        Set<Project> allProjects = root.getAllprojects();
        for (Project p : allProjects) {
            p.getPluginManager().apply(IdeaPlugin.class);
        }
        for (IncludedBuildInternal reference : root.getGradle().includedBuilds()) {

        mavenRepo.module("org.example", "example-lib", "1.0").publish()

        settingsFile << "rootProject.name = 'root'; include 'sub'"
        buildFile << """allprojects { apply plugin: 'java' }
repositories { maven { url '${mavenRepo.uri}' } }
dependencies {
    ${implementationConfiguration} project(':sub')
    ${implementationConfiguration} 'org.example:example-lib:1.0'
}"""

    override fun getRootProject(): Project =
        delegate.rootProject

    override fun rootProject(action: Action<in Project>) =
        delegate.rootProject(action)

    override fun allprojects(action: Action<in Project>) =
        delegate.allprojects(action)

    override fun getTaskGraph(): TaskExecutionGraph =
        delegate.taskGraph

    override fun getStartParameter(): StartParameter =
        delegate.startParameter

        '''
            def flavor = Attribute.of('flavor', String)
            def buildType = Attribute.of('buildType', String)
            def extra = Attribute.of('extra', String)

            allprojects {
               dependencies {
                   attributesSchema {
                      attribute(flavor)
                      attribute(buildType)
                      attribute(extra)
                   }

        buildFile << """
import ${javax.inject.Inject.name}
// TODO: Default imports should work for of inner classes
import ${org.gradle.api.artifacts.transform.TransformParameters.name}

allprojects {
    task producer(type: ${builder.producerTaskClassName}) {
        ${builder.producerConfig}
    }
    afterEvaluate {
        ${builder.producerConfigOverrides}
    }
    artifacts {

        resolve = new ResolveTestFixture(buildA.buildFile).expectDefaultConfiguration("runtime")

        buildB = multiProjectBuild("buildB", ['b1', 'b2']) {
            buildFile << """
                allprojects {
                    apply plugin: 'java-library'
                    version "2.0"

                    repositories {
                        maven { url "${mavenRepo.uri}" }
                    }

public class MyClass {
    public static void main(String[] args) {
        System.out.println("Hello world!");
    }
}
"""

        buildFile << """
def artifactType = Attribute.of('artifactType', String)

allprojects {
    repositories {
        maven { url "${mavenRepo.uri}" }
    }
}
project(':lib') {
    apply plugin: 'java-library'
}

project(':app') {
    apply plugin: 'java'

    dependencies {

    def setup() {
        settingsFile << """
rootProject.name = 'test'
"""
        buildFile << """
def usage = Attribute.of('usage', String)
allprojects {
    dependencies {
        attributesSchema {
           attribute(usage)
        }
    }
    configurations {
        compile {
            attributes.attribute(usage, 'compile')
        }
    }
}

    @ToBeFixedForConfigurationCache(because = "Task.getProject() during execution")
    def "check scope when closure in ext"() {
        given:
        file('closure_in_ext.gradle') << """
allprojects {
    ext.someClosure = {
        project.name
    }

    task someTask {
        doLast {
            println someClosure()
            assert someClosure() == project.name
        }
    }
}
"""

    @Ignore
    def "GradleBuild corrupts cache"() {
        settingsFile << """
            rootProject.name = "root"
            include 'a', 'b'
        """
        buildFile << """
            allprojects {
                apply plugin: 'java'
            }
            subprojects {
                task breakBuild(type: GradleBuild) {
                    dir = rootDir
                    tasks = ["jar"]