@TargetGradleVersion('>=5.6')
class CompositeProjectSubstitutionCrossVersionSpec extends ToolingApiSpecification {

    TestFile buildA
    TestFile buildB
    TestFile buildC

    def setup() {

        buildA = singleProjectBuildInRootFolder("buildA") {
            buildFile << """
                apply plugin: 'java-library'
                dependencies {

    @Requires(IntegTestPreconditions.NotEmbeddedExecutor::class)
    @LeaksFileHandles("Kotlin Compiler Daemon working directory")
    fun `can use accessors for plugins in the buildSrc classpath`() {

        withKotlinBuildSrc()
        withFile(
            "buildSrc/src/main/kotlin/my/plugin-a.gradle.kts",
            """
            package my
            println("*my.plugin-a*")
            """
        )

            )

        val pluginJarV1 = withPluginJar("my-plugin-1.0.jar", "1.0")
        val pluginJarV2 = withPluginJar("my-plugin-2.0.jar", "2.0")

        withDefaultSettingsIn("buildSrc")
        withBuildScriptIn("buildSrc", """
            plugins {
                `kotlin-dsl`
            }

            $repositoriesBlock

            dependencies {

                anyOf(
                    hasItem(folder("project/buildSrc/src/main/foo")),
                    hasItem(folder("project/buildSrc/src/main/bar"))
                )
            )
        )
    }

    @Test
    fun `when setting is parsed, buildSrc sources are not available`() {
        withFolders {
            "project" {
                "buildSrc/src/main" {
                    +"foo"

    def "ignores buildSrc file that is not a directory"() {
        expect:
        !isValidBuildSrcBuild(temp.file("buildSrc"))
        !isValidBuildSrcBuild(temp.createFile("buildSrc"))
    }

    def "ignores empty buildSrc directory"() {
        expect:
        !isValidBuildSrcBuild(temp.createDir("buildSrc"))
    }

    def "ignores buildSrc directory without valid Gradle build"() {
        when:

        file('buildSrc/build.gradle') << """
            plugins {
                id 'java'
            }

            dependencies {
                implementation(gradleApi())
            }

            tasks.withType(JavaCompile) {
                ${javaVersion == null ? '' : forkingOptions(javaVersion)}
            }
        """

    def "reports line numbers for deprecations in builds scripts for buildSrc and included builds"() {
        settingsFile << """
            includeBuild("included")
        """
        buildFile << """
            task broken {
                doLast {
                    ${deprecatedMethodUsage()}
                }
            }
        """
        file("buildSrc/build.gradle") << """
            task broken {

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.initialization.buildsrc

import org.gradle.api.Action
import org.gradle.api.internal.GradleInternal
import org.gradle.api.internal.StartParameterInternal
import org.gradle.api.internal.initialization.DefaultScriptClassPathResolver

            println "configuring \$project.path"
            classes.doLast { t ->
                println "classes of \$t.path"
            }
        """

        when:
        execute(buildA, ":assemble")

        then:
        outputContains("> Configure project :${buildName}")
        result.groupedOutput.task(":${buildName}:classes").output.contains("classes of :classes")

        where:

    }

    def "shows work in progress with buildSrc build"() {
        buildFile << """
            ${server.callFromBuild('root-build-script')}
            task hello
        """
        createDirs("buildSrc", "buildSrc/a", "buildSrc/b")
        file("buildSrc/settings.gradle") << """
            include 'a', 'b'
        """
        file("buildSrc/build.gradle") << """