*/
    @Internal
    public String getBuildName() {
        return buildName;
    }

    /**
     * Sets build name to use for the nested build.
     *
     * @param buildName the build name to use for the nested build
     * @since 6.0
     */
    public void setBuildName(String buildName) {
        this.buildName = buildName;
    }

    @TaskAction
    void build() {

        given:
        def createBuild = { String buildName, String dir ->
            createDir(dir) {
                file("gradle.properties") << """
                    theProperty=$buildName
                """
                file("settings.gradle") << """
                    println("$buildName settings script: " + theProperty)
                """
                file("build.gradle") << """

            }
            String buildName = buildDefinition.getName();
            if (buildName == null) {
                throw new IllegalStateException("build name is required");
            }
            validateNameIsNotBuildSrc(buildName, buildDir);
            Path idPath = buildPath != null ? buildPath : assignPath(rootBuild, buildName, buildDir);
            BuildIdentifier buildIdentifier = idFor(idPath);

        def included = ['buildB', 'buildC', 'buildD']
        included.each { buildName ->
            def build = singleProjectBuild(buildName) {
                buildFile << """
                    apply plugin: 'java'
                    apply plugin: 'idea'

                    ideaModule.doLast {
                        ${server.callFromBuild(buildName)}
                    }
                """
            }

        buildFile << """
            task b1(type:GradleBuild) {
                tasks = ["t"]
                buildName = 'bp'
            }
            task b2(type:GradleBuild) {
                tasks = ["t"]
                buildName = 'bp'
            }
            task t
        """

        when:
        fails 'b1', 'b2'

        then:

                    println "flowAction from \${parameters.buildName.get()}"
                }
            }
        """
    }

    static String buildFinishedRegistrationFor(String buildName) {
        """
            gradle.buildFinished {
                println "buildFinished from $buildName"
            }
        """
    }

        and:
        failure.assertHasDescription("A problem occurred evaluating project ':buildC'.")
        failure.assertHasCause("Included build '${buildName}' not found in build 'buildC'.")

        where:
        scenario  | buildName
        "sibling" | "buildB"
        "parent"  | "buildA"
    }

    val summarizer = ConfigurationCacheProblemsSummary()

    private
    val buildNameHandler = BuildNameHandler()

    private
    val postBuildHandler = PostBuildProblemsHandler()

    private
    var buildName: String? = null

    private
    var isFailOnProblems = startParameter.failOnProblems

    private
    var isFailingBuildDueToSerializationError = false

    private
    var reusedProjects = 0

        then:
        assert !matches
    }

    def "matches id (#buildName #projectPath)"() {
        expect:
        def selector = new DefaultProjectComponentSelector(Stub(BuildIdentifier), Path.path(":id:path"), Path.path(":project:path"), "projectName", ImmutableAttributes.EMPTY, [])

        def b = file("b")
        b.file("build.gradle") << ""
        buildFile << """
            task t(type: GradleBuild) {
                dir = "b"
                buildName = "buildSrc"
            }
        """

        when:
        fails "t"

        then:
        failure.assertHasDescription("Execution failed for task ':t'.")