"""

        expect:
        succeeds "clean"
    }

    @ToBeFixedForIsolatedProjects(because = "subprojects, configure projects from root")
    def "clean build and build clean work reliably"() {
        settingsFile << "include 'a', 'b'"
        buildFile << """
            subprojects {
                apply plugin: 'java-library'
            }
            project(':b') {
                dependencies {

    }

    TestFile multiProjectBuildInSubFolder(String projectName, List<String> subprojects, @DelegatesTo(BuildTestFile) Closure cl = {}) {
        new BuildTestFixture(projectDir).withBuildInSubDir().multiProjectBuild(projectName, subprojects, cl)
    }

    void multiProjectBuildInRootFolder(String projectName, List<String> subprojects, @DelegatesTo(BuildTestFile) Closure cl = {}) {

plugins {
    id("gradlebuild.distribution.api-java")
    id("gradlebuild.instrumented-project")
}

description = "Public and internal 'core' Gradle APIs that are required by other subprojects"

errorprone {
    disabledChecks.addAll(
        "EmptyBlockTag", // 5 occurrences
        "InlineMeSuggester", // 1 occurrences
        "MalformedInlineTag", // 3 occurrences
        "MixedMutabilityReturnType", // 3 occurrences

        testFile('settings.gradle') << ''' apply { from 'other.gradle' } '''
        createDirs("child")
        testFile('other.gradle') << ''' include 'child' '''
        testFile('build.gradle') << ''' assert ['child'] == subprojects*.name '''

        inTestDirectory().withTasks("help").run()
    }

    @Test
    @ToBeFixedForIsolatedProjects(because = "Investigate")
    void canExecuteExternalScriptFromInitScript() {

 */

package org.gradle.internal.cc.impl

import org.gradle.api.internal.project.ProjectInternal


internal
enum class CrossProjectModelAccessPattern {
    DIRECT,
    CHILD,
    SUBPROJECT,
    ALLPROJECTS
}


internal
data class CrossProjectModelAccessInstance(
    val pattern: CrossProjectModelAccessPattern,
    val relativeTo: ProjectInternal,

/*/*/*/*.iml
/*/*/*/*/*.iml
/out
/*/out
/*/*/out
/*/*/*/out
/*/*/*/*/out
/.teamcity/target
/gradle.ipr
/gradle.iws

# Eclipse
# -------
*.classpath
*.project
*.settings
/bin
/subprojects/*/bin
atlassian-ide-plugin.xml
.metadata/

# NetBeans
# --------
.nb-gradle
.nb-gradle-properties

# Vim
# ---
*.sw[nop]

# Emacs
# -----
*~
\#*\#
.\#*

# Textmate

        eclipseProject.projectDependencies.collect {it.path}  == ['b1']
    }

    def "EclipseProject model honours custom project name"() {
        when:
        buildB.buildFile << """
            subprojects {
                apply plugin: 'eclipse'
                eclipse {
                    project.name = project.name + "-renamed"
                }
            }
            project(":b1") {

    def "can use compile classpath for API and implementation separation"() {
        given:
        createDirs("a", "b", "c", "d")
        settingsFile << "include('a', 'b', 'c', 'd')"
        buildFile << """
            subprojects {
                apply plugin: 'java-library'
                apply plugin: 'eclipse'

                configurations {
                    compileClasspath {
                        attributes {

        then:
        failureDescriptionContains "Cannot generate project dependency accessors because project '1library' doesn't follow the naming convention: [a-zA-Z]([A-Za-z0-9\\-_])*"
    }

    def "fails if two subprojects have the same java name"() {
        given:
        createDirs("super-cool", "super--cool")
        settingsFile << """
            include 'super-cool'
            include 'super--cool'
        """

    @TargetGradleVersion(">=3.0")
    def "makes sure module names are unique in gradle"() {
        given:
        file('build.gradle').text = """
subprojects {
    apply plugin: 'java'
}

project(':impl') {
    dependencies {
        ${implementationConfiguration} project(':api')
    }
}

project(':contrib:impl') {
    dependencies {