assert gradle.includedBuilds.empty
            """
        }
        validationTask(buildB.buildFile, "broken1", """
            assert gradle.includedBuilds.empty
            gradle.includedBuild("buildA")
        """)
        validationTask(buildB.buildFile, "broken2", """
            assert gradle.includedBuilds.empty
            gradle.includedBuild("buildC")
        """)

        when:
        def result = registry.addIncludedBuild(buildDefinition)
        then:
        1 * buildAddedListener.buildAdded(includedBuild)
        0 * _

        result.is includedBuild

        registry.includedBuilds as List == [includedBuild]

        registry.getBuild(buildIdentifier).is(includedBuild)

        List<IncludedBuildSpec> includedBuilds = state.getSettings().getIncludedBuilds();
        if (!includedBuilds.isEmpty()) {
            Set<IncludedBuildInternal> children = new LinkedHashSet<>(includedBuilds.size());
            for (IncludedBuildSpec includedBuildSpec : includedBuilds) {
                CompositeBuildParticipantBuildState includedBuild = buildIncluder.includeBuild(includedBuildSpec);

        expect:
        def model = builder.create(rootBuildState)
        model.includedBuilds.size() == 1

        def model1 = model.includedBuilds[0]
        model1.rootDir == dir1
        model1.includedBuilds.size() == 1

        def model2 = model1.includedBuilds[0]
        model2.rootDir == dir2
        model2.includedBuilds.empty

        model.editableBuilds.size() == 2

        expect:
        model.includedBuilds.size() == 1

        def included = model.includedBuilds[0]
        included.buildIdentifier.rootDir == file("child")
        included.includedBuilds.size() == 1
        included.editableBuilds.empty

        model.editableBuilds.size() == 1

        model.editableBuilds[0].is(included)

        included.includedBuilds[0].is(model)
    }

        then:
        model.rootProject.name == "root"
        model.includedBuilds.size() == 1
        def includedBuild = model.includedBuilds[0]
        includedBuild.rootProject.name == "includedBuild"
        includedBuild.projects.size() == 4
    }

    @TargetGradleVersion(">=3.1 <3.3")
    def "No included builds for old Gradle versions"() {
        singleProjectBuildInRootFolder("root") {
            settingsFile << """

                assert gradle.includedBuilds.empty
            """
            validationTask(buildFile, "broken1", """
                assert gradle.includedBuilds.empty
                gradle.includedBuild("buildA")
            """)
            validationTask(buildFile, "broken2", """
                assert gradle.includedBuilds.empty
                gradle.includedBuild("buildB")
            """)
        }

        rootBuild.rootProject.name == "root"
        rootBuild.includedBuilds.size() == 1

        def buildB = rootBuild.includedBuilds[0]
        buildB.buildIdentifier.rootDir == buildBDir
        buildB.rootProject.name == "buildB"
        buildB.projects.size() == 4
        buildB.includedBuilds.size() == 1

        def buildC = buildB.includedBuilds[0]
        buildC.buildIdentifier.rootDir == buildCDir

            includedBuilds[includedBuildName] = b
        }
        applyConfiguration(spec, b)
        this
    }

    void generate() {
        settingsBuilder.generate(dsl, rootProjectDirectory)
        projects.each { name, builder ->
            builder.generate()
        }
        includedBuilds.each { name, builder ->
            builder.generate()
        }
    }

                    apply plugin: 'java-library'
                }
            """
        }
        includedBuilds << buildB

        buildC = singleProjectBuild("buildC") {
            buildFile << """
                apply plugin: 'java-library'
            """
        }
        includedBuilds << buildC
    }

    def "direct dependency cycle between included builds"() {
        given: