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 {

    @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

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

    def setup() {
        requireIsolatedTestKitDir = true
        executer.beforeExecute {
            usingInitScript(file("tempDirInit.gradle") << """
                allprojects {
                    tasks.withType(Test) {
                        systemProperty "$DefaultGradleRunner.TEST_KIT_DIR_SYS_PROP", "${TextUtil.normaliseFileSeparators(testKitDir.absolutePath)}"

    def "Applies idea module name compatibility mapping"() {
        given:
        settingsFile << """
            include 'a'
            include 'b'
        """
        buildFile << """
            allprojects {
                apply plugin: 'java'
            }
            project(':a') {
                dependencies {
                    ${implementationConfiguration} project(':b')
                }
            }

            }
        """

        settingsFile << """
            rootProject.name = 'root'
            include 'api'
            include 'util'

        """

        buildFile << """
            allprojects {
                apply plugin: 'java'
                apply plugin: 'eclipse'
            }

            project(':util') {
                dependencies {
                    implementation project(':api')

    tasks.register("resolveAllDependencies") {
        val npmInstall = tasks.findByName("kotlinNpmInstall")
        if (npmInstall != null) {
            dependsOn(npmInstall)
        }
        doLast {
            allprojects {
                configurations.forEach { c ->
                    if (c.isCanBeResolved) {
                        println("Downloading dependencies for '$path' - ${c.name}")