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

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 {

    @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"]

        file("gradle.properties") << "org.gradle.configureondemand=false"

        createDirs("api", "impl")
        settingsFile << "include 'api', 'impl'"
        buildFile << """
            allprojects { task foo };
            assert gradle.startParameter.configureOnDemand
        """

        when:
        run("--configure-on-demand", ":api:foo")

        then:

    abstract TestFile getBuildFile()

    def setupBuildWithColorVariants(TestFile buildFile = getBuildFile()) {
        buildFile << """
            def color = Attribute.of('color', String)
            allprojects {
                configurations {
                    implementation {
                        // TODO: Make this a dependency scope
                        // canBeResolved = false

    def setup() {
        settingsFile << """
            rootProject.name = 'test'
            include 'consumer'
            include 'producer'
        """
        buildFile << """
            allprojects {
               apply plugin: 'java-library'

                group = 'com.maven.snapshot'
                version = '1.0-SNAPSHOT'

                repositories {

    @Issue('GRADLE-3534')
    def "configures only requested projects when the #plugin plugin is applied"() {
        given:
        multiProjectBuild('multi', ['a', 'b']) {
            buildFile << """
                allprojects {
                    apply plugin: '${plugin}'
                }
                subprojects {
                    apply plugin: 'java'
                }
            """.stripIndent()

    }

    @Test
    @ToBeFixedForIsolatedProjects(because = "allprojects, access to root project")
    void cachesScriptClassForAGivenScript() {
        createDirs("a", "b")
        testFile('settings.gradle') << 'include \'a\', \'b\''
        testFile('external.gradle') << 'ext.appliedScript = this'
        testFile('build.gradle') << '''
allprojects {
   apply from: "$rootDir/external.gradle"
}
subprojects {

    @Test
    void resumeFromSelectorIsSuggestedWithoutGroupId() {
        List<MavenProject> allProjects =
                asList(createMavenProject("group", "module-a"), createMavenProject("group", "module-b"));
        MavenProject failedProject = allProjects.get(0);

        String selector = cli.getResumeFromSelector(allProjects, failedProject);

        assertThat(selector, is(":module-a"));
    }

    @Test