}

    def "substitutes external dependency for a subproject of the root build - #rootIsIncluded"() {
        given:
        def empty = file('empty').tap {
            it.mkdir()
        }
        mavenRepo.module("org.test", "subproject1", "2.0").publish()
        buildA.buildFile << """
            subprojects {
                apply plugin: 'java-library'
                group = 'org.test'

    "functionalTests": false,
    "crossVersionTests": false
  },
  {
    "name": "core",
    "path": "subprojects/core",
    "unitTests": true,
    "functionalTests": true,
    "crossVersionTests": true
  },
  {
    "name": "core-api",
    "path": "subprojects/core-api",
    "unitTests": true,
    "functionalTests": true,
    "crossVersionTests": false
  },
  {

This is sometimes referred to as a multi-module project.
Gradle refers to modules as subprojects.

A multi-project build consists of one root project and one or more subprojects.

[[sec:project_structure]]
== Multi-Project structure

The following represents the structure of a multi-project build that contains two subprojects:

image::multi-project-structure.png[]

The directory structure should look as follows:

An improper way to share build logic between subprojects is _cross-project configuration_ via the link:{javadocPath}//org/gradle/api/Project.html#subprojects-groovy.lang.Closure-[`subprojects {}`] and link:{javadocPath}/org/gradle/api/Project.html#allprojects-groovy.lang.Closure-[`allprojects {}`] DSL constructs.

TIP:  Avoid using `subprojects {}` and `allprojects {}`.

<3> Gradle wrapper start scripts
<4> Settings file to define build name and subprojects
<5> Build script for `app` subproject
<6> Default Java source folder for `app` subproject
<7> Default Java test source folder for `app` subproject
=====

The `authoring-tutorial` folder is the *root project directory*.
Inside the root project directory are one or more subprojects, build scripts, and the Gradle wrapper.

- `settings.gradle(.kts)` file representing your Gradle build including required subprojects e.g. include("app", "model", "service")
- `build.gradle(.kts)` and source code for each subproject in corresponding subdirectories

Our build currently consists of a root project called `authoring-tutorial`, which has a single `app` subproject:

[.multi-language-sample]
=====
[source, kotlin]
----
.   // <1>
├── app // <2>

```

Note that the samples are also used in `samples` subproject, see [`@UsesSample`](https://github.com/gradle/gradle/blob/9ade1a05427aaf04c976a0e85814b44b3435f9f9/subprojects/internal-integ-testing/src/main/groovy/org/gradle/integtests/fixtures/UsesSample.java#L25) and [`Sample`](https://github.com/gradle/gradle/blob/903c5f2cee88c9768077d46025eaafdf65862fc8/subprojects/internal-integ-testing/src/main/groovy/org/gradle/integtests/fixtures/Sample.java#L37).

}

rootProject.name = 'tutorial'
include('app')
----
=====

The `tutorial` root project includes the `app` subproject.
The presence of the `include` call turns the `app` directory into a subproject.

== Step 7. Understanding the Build script
Each subproject contains its own `build.gradle(.kts)` file.

    @IntegrationTestTimeout(value = 60, onlyIf = { GradleContextualExecuter.embedded })
    def "can query dependencies with configure on demand enabled"() {
        def subprojects = ["a", "b"]
        multiProjectBuild("outputRegistry", subprojects)
        subprojects.each { projectName ->
            file("${projectName}/build.gradle") << """
                plugins {
                    id("java-library")
                }

        subproject("base-asm")
        subproject("base-services")
        subproject("build-configuration")
        subproject("build-operations")
        subproject("build-option")
        subproject("build-process-services")
        subproject("build-profile")
        subproject("build-state")
        subproject("cli")
        subproject("client-services")
        subproject("concurrent")
        subproject("daemon-main")