}

    /**
     * Returns source directories from buildSrc if any.
     */
    fun buildSrcRootsOf(projectRoot: File): Collection<File> =
        projectRoot.resolve("buildSrc/$buildSrcSourceRootsFilePath")
            .takeIf { it.isFile }
            ?.readLines()
            ?.map { projectRoot.resolve("buildSrc/$it") }
            ?: buildSrcRootsFallbackFor(projectRoot)

    private

        model3.message == "this is the root project"

        and:
        fixture.assertStateUpdated {
            fileChanged("build.gradle")
            projectConfigured(":buildSrc")
            modelsCreated(":")
            modelsReused(":buildSrc")
        }
        outputContains("creating model for root project 'root'")

        when:
        executer.withArguments(ENABLE_CLI)
        def model4 = fetchModel()

        def originalClassName = "LambdaOriginal"
        def changedClassName = "LambdaChanged"
        file("buildSrc/src/main/java/${originalClassName}.java") << javaClass(originalClassName, serializableConsumerLambdaWritingFile("ACTION", "original"))
        file("buildSrc/src/main/java/${changedClassName}.java") << javaClass(changedClassName, serializableConsumerLambdaWritingFile("ACTION", "changed"))
        buildFile << """

        and:
        fixture.assertStateUpdatedWithProblems {
            fileChanged("build.gradle")
            projectConfigured(":buildSrc")
            modelsCreated(":a", ":b")
            modelsQueriedAndNotPresent(":")
            modelsReused(":c", ":buildSrc")
            problem("Build file 'build.gradle': line 10: Project ':' cannot access 'Project.afterEvaluate' functionality on another project ':a'")

 */

package org.gradle.initialization.buildsrc

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.ToBeFixedForIsolatedProjects
import spock.lang.Issue

class BuildSrcTaskExecutionIntegrationTest extends AbstractIntegrationSpec {
    def "can execute a task from buildSrc from the command line"() {
        file("buildSrc/build.gradle") << """
            task something {

    @Test
    fun `given a script file in buildSrc it should return the buildSrc project root`() {

        withFolders {
            "root" {
                "buildSrc" {
                    withFile("build.gradle.kts")
                }
            }
        }

        assertThat(
            projectRootOf(
                scriptFile = file("root/buildSrc/build.gradle.kts"),

            sourcePathFor(settings),
            matchesProjectsSourceRoots(withMainSourceSetJavaKotlinIn("buildSrc")))
    }

    @TargetGradleVersion(">=5.4 <7.5")
    @LeaksFileHandles("Kotlin compiler daemon on buildSrc jar")
    @Flaky(because = "https://github.com/gradle/gradle-private/issues/3708")
    def "sourcePath includes buildSrc project dependencies source roots"() {

        given:

        events.assertIsABuild()

        def buildSrc = events.operation("Build buildSrc")
        def groovyPlugin = buildSrc.descendant("Apply plugin org.gradle.api.plugins.GroovyPlugin to project ':buildSrc'")
        def configureBuildSrcBuild = buildSrc.child({ it.startsWith("Configure build") })

        def configureBuildSrcRoot = configureBuildSrcBuild.child("Configure project :buildSrc")

 */

package org.gradle.initialization.buildsrc;

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

/**
 * Can be implemented by plugins to auto-configure the buildSrc root project.
 *
 * <p>Implementations are discovered using the JAR service locator mechanism (see {@link org.gradle.internal.service.ServiceLocator}).

        then:
        fixture.assertStateUpdated {
            fileChanged("a/build.gradle")
            projectsConfigured(":buildSrc", ":")
            modelsCreated(":a", SomeToolingModel)
            modelsReused(":buildSrc", ":", ":b")
        }

        outputContains("configuring root")
        outputContains("configuring project ':a'")