}

    @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

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

        mavenBom 'org.springframework.boot:spring-boot-dependencies:1.3.5.RELEASE'
        mavenBom 'io.spring.platform:platform-bom:2.0.5.RELEASE'
    }
}
<% } %>

if(Boolean.getBoolean("slowTasks")) {
    allprojects {
        tasks.withType(JavaCompile) {
            doLast {
                Thread.sleep(100)
            }
        }
    }
}

dependencies {
    implementation 'commons-lang:commons-lang:2.5'

    def setup() {
        // So we can assert on which version of ANTLR is used at runtime
        executer.withArgument("-i")
        buildFile << """
            allprojects {
                apply plugin: 'java'
                ${mavenCentralRepository()}
                tasks.withType(JavaCompile) {
                    options.compilerArgs << "-proc:none"
                }
            }

        buildB.file("bar/.gitkeepdir").touch()
        buildB.settingsFile << """
            rootProject.name = 'B'
            include 'foo', 'bar'
        """
        buildB.buildFile << """
            allprojects {
                apply plugin: 'java'
                group = 'org.test'
                version = '1.0'
            }
        """
        repo.commit('initial')
        buildFile << """

    def setup() {
        file('settings.gradle') << '''
include 'a'
include 'b'
include 'b:c'
rootProject.name = 'test'
'''
        buildFile << """
allprojects {
    description = "project \$name"
    task buildStuff
}
"""
    }

    def "can request GradleBuild model including projectDirectory"() {
        when:

abstract class AbstractCompileAvoidanceWithIncrementalCompilationIntegrationTest extends AbstractJavaGroovyIncrementalCompilationSupport {
    def setup() {
        buildFile << """
            allprojects {
                ${mavenCentralRepository()}
            }
       """
    }

    def "doesn't recompile if implementation dependency changed in ABI compatible way"() {
        given: