A key concept in dependency management with Gradle is the difference between consumers and producers.

When you _build_ a library, you are effectively on the _producer_ side: you are producing _artifacts_ which are going to be _consumed_ by someone else, the _consumer_.

A lot of problems with traditional build systems is that they don't make the difference between a producer and a consumer.

include::{snippetsPath}/native-binaries/variants/groovy/build.gradle[tag=build-types]
----

If no build types are defined in a project, then a single, default build type called 'debug' is added.

For a build type, a Gradle project will typically define a set of compiler/linker flags per tool chain.

=== Example: Configuring debug binaries

[source.multi-language-sample,groovy]
.build.gradle
----

        }

        buildD = singleProjectBuild('buildD') {
            buildFile << javaProject()
            file('src/test/java/SampleTestD.java') << junitTestClass('SampleTestD')
        }
    }

    def "can collect build failures from multiple included builds"() {
        when:
        includedBuilds << buildB << buildC << buildD

        buildA.buildFile << """
            task testAll {

        // Wait for each build to list versions
        httpServer.expectConcurrent(repo.listVersions(), repo.listVersions())

        executer.withTasks('resolve')
        def build3 = executer.start()

        executer.withTasks('resolve')
        def build4 = executer.start()

        build3.waitForFinish()
        build4.waitForFinish()
    }

    @ToBeFixedForConfigurationCache
    def "builds IDE metadata artifacts in parallel"() {
        given:
        server.start()
        buildTestFixture.withBuildInSubDir()
        def buildA = singleProjectBuild("buildA") {
            buildFile << """
                apply plugin: 'java'
                apply plugin: 'idea'
            """
        }

        def included = ['buildB', 'buildC', 'buildD']

    def "can query the included builds defined by the root build"() {
        given:
        def buildB = singleProjectBuild("buildB") {
        }
        includeBuild(buildB)
        def buildC = singleProjectBuild("buildC") {
        }
        includeBuild(buildC)
        buildA.buildFile << """
            assert gradle.includedBuild("buildB").name == "buildB"

                }
"""
        }
        buildC = singleProjectBuild("buildC") {
            buildFile << """
                task succeeds
"""
        }
        includedBuilds << buildB << buildC
    }

    def "aborts build when delegated task in same build fails"() {
        when:
        buildA.buildFile << """
    task delegate {
        dependsOn gradle.includedBuild('buildB').task(':fails')

        def workspace = eclipseWorkspace([project("buildA", buildA),
                                          project("buildB", buildB),
                                          project("buildC", buildC, false),
                                          project("b1", buildB.file("b1")),
                                          project("b2", buildB.file("b2"))])

        when:
        withConnection { connection ->

        workspace.assertContains(project(buildA, "ide"))
        workspace.assertContains(project(buildB, "buildB"))
        workspace.assertContains(project(buildB.file("p1"), "p1"))
        workspace.assertContains(project(buildB.file("p2"), "p2"))
    }

    @ToBeFixedForConfigurationCache(because = "ide plugins")
    def "workspace includes projects from nested included builds"() {

            .assertHasLineNumber(13)
        failure.assertHasDescription("build C broken")
            .assertHasFileName("Build file '${buildC.buildFile}'")
            .assertHasLineNumber(9)
    }

    @ToBeFixedForConfigurationCache(because = "build listener")
    def "fires build finished events for all builds when other builds fail"() {
        given:
        disableProblemsApiCheck()