given:
        createDirs("project1", "project2")
        settingsFile << """
include "project1", "project2"
"""

        buildFile << """
allprojects {
    apply plugin: 'java-library'
    apply plugin: 'maven-publish'

    group = "org.gradle.test"

    ${mavenCentralRepository()}
}

project(":project1") {
    version = "1.0"

            include 'util'
            include 'app'
        """
        buildFile << resolveTask << """
            import org.gradle.api.artifacts.transform.TransformParameters

            allprojects {
                repositories {
                    maven { url '${mavenHttpRepo.uri}' }
                }
            }
        """
    }

    def "transform is applied to each file once per build"() {

            </tr>
            <tr>
                <td>useLogger</td>
            </tr>
            <tr>
                <td>rootProject</td>
            </tr>
            <tr>
                <td>allprojects</td>
            </tr>
            <tr>
                <td>includedBuild</td>
            </tr>
            <tr>
                <td>beforeSettings</td>
            </tr>
        </table>
    </section>

    void handlesPlusMinusConfigurationsForProjectDeps() {
        //when
        createDirs("foo", "bar", "unwanted")
        runEclipseTask "include 'foo', 'bar', 'unwanted'",
            """
allprojects {
  apply plugin: 'java'
  apply plugin: 'eclipse'
}

configurations {
  someConfig
  someOtherConfig
}

dependencies {
  someConfig project(':foo')
  someConfig project(':bar')

            include("consumer", "producer")
            """
        )

        withBuildScript(
            """
            plugins {
                `java-library`
            }

            allprojects {
                $repositoriesBlock
            }

            dependencies {
                api(project(":consumer"))
            }
            """
        )

        withFolders {

    ZincScalaCompileFixture(GradleExecuter executer, TestDirectoryProvider testDir) {
        super(executer, testDir)
    }

    @Override
    String initScriptContent() {
        return """
            allprojects {
                $disableScalaDocIfInDaemonMode
            }
        """
    }

    static String getDisableScalaDocIfInDaemonMode() {
        return !GradleContextualExecuter.isDaemon() ? "" : """

    }

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

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