As an example, let's use a multi-project build with the following structure:
----
> gradle -q projects
----
----
include::{snippetsPath}/java/multiproject/tests/listProjects.out[]
----

Multi-project builds are collections of tasks you can run.
The difference is that you may want to control _which_ project's tasks get executed.

    @ToBeFixedForIsolatedProjects(because = "Access to root project from sub projects")
    def "can visit and edit zip archive differently from two different projects in a multiproject build"() {
        given: "an archive in the root of a multiproject build"
        createZip('test.zip') {
            subdir1 {
                file ('file1.txt').text = 'original text 1'
            }
            subdir2 {

 defined the maven.multiproject.includes property in any of his properties
 files for the current project. if yes. then I'm able to find projects that
 can be offered to be opened together with the current project.
 problems with the current solution are:
 1. information is duplicate. once in POM's dependencies and once in the
 maven.multiproject.includes property.

    val capKind = kind.capitalize().replace("y", "ie") + "s"
    val languageDisplayName = language.toString().replace("C++", "{cpp}")
    val sampleName = "building$capName$capKind" + if (modularizationOption.isMulti()) "MultiProject" else ""
    val multiProjectSuffix = if (modularizationOption.isMulti()) " with libraries" else ""
    val generateSampleTask = project.tasks.register<GenerateSample>("generateSample${sampleName.capitalize()}") {

    def "canonicalizes working directory"() {
        given:
        testProject()

        when:
        def relativeDir = new File(testDirectory, 'java/multiproject/../quickstart')
        executer.inDirectory(relativeDir).run()

        then:
        noExceptionThrown()
    }

    @Requires(UnitTestPreconditions.CaseInsensitiveFs)

This sample shows how 2 Gradle builds that are normally developed separately and combined using binary integration can be wired together into a composite build with source integration. The `my-utils` multiproject build produces 2 different java libraries, and the `my-app` build produces an executable using functions from those libraries.

        dslDir.file('build/dist/org/example/app/HelloApp.html').isFile()

        where:
        dsl << ['groovy', 'kotlin']
    }

    @UsesSample("antMigration/multiProject")
    @ToBeFixedForConfigurationCache
    def "can link projects in a multi-project build via task dependencies (#dsl)"() {
        given: "A sample multi-project build"
        def dslDir = sample.dir.file(dsl)

class LoadBuildStructureBuildOperationIntegrationTest extends AbstractIntegrationSpec {

    final buildOperations = new BuildOperationsFixture(executer, temporaryFolder)

    def "multiproject settings with customizations are exposed correctly"() {
        createDirs("b", "a", "a/c", "d")
        settingsFile << """
        include "b"
        include "a"
        include "a:c"
        include "a:c:d"

.Custom buildSrc build script
====
include::sample[dir="snippets/java/multiproject/kotlin",files="buildSrc/build.gradle.kts[]"]
include::sample[dir="snippets/java/multiproject/groovy",files="buildSrc/build.gradle[]"]
====

A typical project including `buildSrc` has the following layout.

== Using composite builds in a hierarchical multirepo project

This sample demonstrates how composite builds can be used to develop a hierarchical project that is composed from different Git repositories. Instead of Gradle subprojects in a multiproject build, this example uses separate Gradle builds included into a composite.