@TargetGradleVersion(">=3.1")
class PersistentCompositeDependencySubstitutionCrossVersionSpec extends ToolingApiSpecification implements WithOldConfigurationsSupport {
    TestFile buildA
    TestFile buildB
    TestFile buildC

    def setup() {

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

{"Action":"output","Test":"TestTags/testtag","Output":"=== CONT  TestTags/testtag\n"}
{"Action":"run","Test":"Test☺☹Dirs/buildtag"}
{"Action":"output","Test":"Test☺☹Dirs/buildtag","Output":"=== RUN   Test☺☹Dirs/buildtag\n"}
{"Action":"output","Test":"Test☺☹Dirs/buildtag","Output":"=== PAUSE Test☺☹Dirs/buildtag\n"}
{"Action":"pause","Test":"Test☺☹Dirs/buildtag"}
{"Action":"cont","Test":"Test☺☹/0"}
{"Action":"output","Test":"Test☺☹/0","Output":"=== CONT  Test☺☹/0\n"}

            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:

        when:
        includedBuilds << buildB << buildC << buildD

        buildA.buildFile << """
            task testAll {
                dependsOn gradle.includedBuilds*.task(':test')
            }
        """

        and:
        fails(buildA, 'testAll', [CONTINUE_COMMAND_LINE_OPTION])

        then:
        assertTaskExecuted(':buildB', ':test')

            .assertHasFileName("Settings file '${buildA.settingsFile}'")
            .assertHasLineNumber(6)
    }

    @ToBeFixedForConfigurationCache(because = "build listener")
    def "fires build finished events for all builds when build script for child build fails"() {
        given:
        disableProblemsApiCheck()
        buildA.settingsFile << """
            gradle.buildFinished {

        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:

 */
abstract class AbstractCompositeBuildIntegrationTest extends AbstractIntegrationSpec {
    BuildTestFile buildA
    List<File> includedBuilds = []
    def operations = new BuildOperationsFixture(executer, temporaryFolder)

    def setup() {
        buildTestFixture.withBuildInSubDir()
        buildA = singleProjectBuild("buildA") {
            buildFile << """
                apply plugin: 'java'
                repositories {

        }
        includedBuilds << buildC
        buildA.buildFile.prepend("""
            buildscript {
                dependencies {
                    classpath 'org.test:buildB:1.0'
                    classpath 'org.test:buildC:1.0'
                }
            }
        """)
        buildA.buildFile << registration("buildA")
        dependency buildB, "org.test:buildC:1.0"

            """
        }
        buildA.buildFile << """
            // add lifecycle task here since we can not call the task of buildB directly yet - https://github.com/gradle/gradle/issues/2533
           tasks.register("buildBJar") {
                dependsOn(gradle.includedBuild("buildB").task(":jar"))
            }
        """
        buildA.settingsFile << """
            includeBuild('.')
        """

        }
        expect:
        execute(buildA, "delegate", "--parallel", "--max-workers=$maxWorkers")
        operations.assertConcurrentOperationsDoNotExceed(ExecuteTaskBuildOperationType, maxWorkers, maxWorkers != 1)

        where:
        maxWorkers << [ 1, 2, 4 ]
    }

    def "can build transitive dependency chain with --max-workers == 1"() {
        def previousBuild = buildA