val buildScan = extensions.findByType<DevelocityConfiguration>()?.buildScan
inline fun buildScan(configure: BuildScanConfiguration.() -> Unit) {
    buildScan?.apply(configure)
}

extractCiData()

if (project.testDistributionEnabled) {
    buildScan?.tag("TEST_DISTRIBUTION")
}

if (project.predictiveTestSelectionEnabled.orNull == true) {
    buildScan?.tag("PTS")
}

extractWatchFsData()

org.gradle.initialization.buildsrc.GroovyBuildSrcProjectConfigurationAction

        def buildSrc = model.editableBuilds[0]
        buildSrc.buildIdentifier.rootDir == file("buildSrc")
        buildSrc.includedBuilds.empty
        buildSrc.editableBuilds.empty

        model.editableBuilds[1].is(included)

        def includedBuildSrc = model.editableBuilds[2]
        includedBuildSrc.buildIdentifier.rootDir == file("child/buildSrc")
        includedBuildSrc.includedBuilds.empty

        dependency "org.test:buildB:1.0"

        createDirs("buildB", "buildB/buildSrc", "buildB/buildSrc/b1", "buildB/buildSrc/b2")
        buildB.file("buildSrc/settings.gradle") << """
            $settings
            include 'b1', 'b2'
        """
        buildB.file("buildSrc/build.gradle") << """
            allprojects { apply plugin: 'java' }

    def "does not warn for each nested build if --scan used"() {
        given:
        scanPlugin.collectConfig = false
        file("buildSrc/build.gradle") << ""
        file("a/buildSrc/build.gradle") << ""
        file("a/build.gradle") << ""
        file("a/settings.gradle") << ""
        file("b/buildSrc/build.gradle") << ""
        file("b/build.gradle") << ""
        file("b/settings.gradle") << ""
        settingsFile << """

                    phaseHasMoreProgress(startEvent);
                } else if (startEvent.getBuildOperationCategory() == BuildOperationCategory.CONFIGURE_PROJECT && currentPhase == Phase.Configuring) {
                    // Any configuring event received from nested or buildSrc builds before the root build starts configuring is ignored

For more details about included builds, see link:{userManualPath}/composite_builds.html[Composing Builds] chapter.

The `myproject.java-conventions` plugin is then applied to the `buildSrc` build:
====
include::sample[dir="kotlin",files="buildSrc/build.gradle.kts[tags=plugins]"]
include::sample[dir="groovy",files="buildSrc/build.gradle[tags=plugins]"]
====

        includeBuild(buildB)

        buildA.buildFile << """
            task broken {
                dependsOn gradle.includedBuild("buildB").task(":broken")
            }
        """

        when:
        fails(buildA, "buildC:broken1")

        then:
        failure.assertHasCause("Included build 'buildA' not found in build 'buildC'.")

        when:
        fails(buildA, "buildC:broken2")

        then:

        when:
        execute(buildA, "assemble")

        then:
        result.assertTaskExecuted(":buildC:jar")
        result.assertTaskExecuted(":buildB:jar")
        result.assertTaskExecuted(":jar")
    }

    def "a nested included build is substituted into all other builds"() {
        given:
        dependency(buildA, "org.test:buildB:1.2")
        dependency(buildA, "org.test:buildC:1.2")

        """
        validationTask(buildA.buildFile, "broken", """
            assert gradle.includedBuilds.name == ["b1", "c1"]
            gradle.includedBuild("buildB")
        """)

        when:
        fails(buildA, "broken")

        then:
        failure.assertHasCause("Included build 'buildB' not found in build 'buildA'.")
    }