case ScriptType.SETTINGS:
                    return "settings"
                case ScriptType.BUILDSRC_PROJECT:
                    return "buildSrc/build"
                case ScriptType.BUILDSRC_SETTINGS:
                    return "buildSrc/settings"
                case ScriptType.INIT:
                    return "gradle/my.init"
            }
        }
    }

    enum ScriptDiscovery {

        withKotlinBuildSrc()
        withFile(
            "buildSrc/src/main/java/some/Some.java",
            """
            package some;
            public interface Some {
                default void something() {
                    System.out.println("original");
                }
            }
            """
        )
        withFile(
            "buildSrc/src/main/kotlin/some-plugin.gradle.kts",
            """

        succeeds "build"
    }

    def treatsBuildSrcProjectAsANestedBuild() {
        when:
        buildFile << '''
            assert gradle.parent == null
            task build
'''

        file('buildSrc/build.gradle') << '''
            apply plugin: 'java'
            assert gradle.parent != null
            classes {
                doLast {
                    assert gradle.parent != null
                }

        """
        executer.gradleUserHomeDir.file("gradle.properties") << "systemProp.foo=bar"
        // Add something to buildSrc to have it evaluated
        file("buildSrc/settings.gradle") << """
            assert System.getProperty('foo') == 'bar'
            rootProject.name = 'myBuildSrc'
        """

        expect:
        succeeds 'help'
    }

// tag::plugins[]
plugins {
    id 'myproject.java-conventions'
    // myproject.greeting is implemented in the buildSrc project that has myproject.java-conventions applied as well
    id 'myproject.greeting'
    id 'application'
}
// end::plugins[]

dependencies {
    implementation project(':utilities')
}

application {
    mainClass = 'org.gradle.sample.app.Main'

     *
     * <p>Note that this set does not include builds that are added in other ways, such as a `buildSrc` build.
     * Also note that a build may be included by multiple builds, so that the inclusions form a graph of builds rather than a tree of builds. There may be cycles in this graph.</p>
     *

.JavaToolchainResolverImplementation.java
[source,java]
----
include::{snippetsPath}/java/toolchain-management/groovy/buildSrc/src/main/java/org/myorg/JavaToolchainResolverImplementation.java[tags=java-toolchain-resolver-implementation]
----

        then:
        output.count("EVENT:") == 2

        when:
        run("a", "b")

        then:
        output.count("EVENT:") == 2
    }

    def "init script listener receives events from buildSrc and main build"() {
        def initScript = initScriptFile
        loggingListener(initScript)
        initScript << """
            if (gradle.parent == null) {

plugins {
    id 'base'
}

// This is defined in buildSrc
import org.gradle.distribution.DownloadGradle

version = '0.1'

tasks.register('downloadGradle', DownloadGradle) {
    description = 'Downloads the Gradle distribution with a given version.'
    gradleVersion = '4.6'
}

tasks.register('createCustomGradleDistribution', Zip) {
    description = 'Builds custom Gradle distribution and bundles initialization scripts.'

    def "#method is instrumented in Java"() {
        def configurationCache = newConfigurationCacheFixture()

        given:
        file("buildSrc/src/main/java/SomePlugin.java") << """
            import ${Plugin.name};
            import ${Project.name};

            public class SomePlugin implements Plugin<Project> {