latch.countDown()
            latch.await()
            println path + " go"
        }

        executable = "$java"
    }
}
"""
        subprojects.each { subproject ->
            settingsFile << "include '$subproject'\n"
            file("${subproject}/src/test/java/ThingTest.java") << """
import org.junit.Test;
import static org.junit.Assert.*;

public class ThingTest {
    @Test
    public void verify() {

                FunctionalTestBucket(it as JSONObject).toBuildTypeBucket(model.subprojects)
            }

            // Sometimes people may add new subproject into `subprojects.json`
            // in this case we have no historical test running time, so we simply add these subprojects into first available bucket
            val allSubprojectsInBucketJson = buckets.flatMap { it.subprojects.map { it.name } }.toSet()

Gradle can build the root project and any number of the subprojects in a single execution.

[[sub:project_locations]]
== Project locations

Multi-project builds contain a single root project in a directory that Gradle views as the root path: `.`.

Subprojects are located physically under the root path: `./subproject`.

        }

        when:
        buildFile << '''
            subprojects {
                java { withSourcesJar() }
            }
        '''
        then:
        succeeds(':a:sourcesJar')
    }

    def "project packages own and runtime dependency sources if requested"() {
        given:
        buildFile << '''
            subprojects {
                java {
                    withSourcesJar()

│   │   └──...
│   └── build.gradle
└── settings.gradle
----
=====

In this example, there are three subprojects called `shared`, `api`, and `person-service`:

1. The `person-service` subproject depends on the other two subprojects, `shared` and `api`.
2. The `api` subproject depends on the `shared` subproject.

<project>
    <property name="lib.dir" location="lib/test"/>

<% ['clean', 'jar', 'build'].each { target -> %>
    <target name="$target">
        <% subprojects.each { subproject -> %>
            <ant dir="$subproject" target="$target">
                <property name="lib.dir" location="\${lib.dir}"/>
            </ant>
        <%  } %>
    </target>
<% } %>

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 {}`.

rootProject.name = '${rootProjectName}'
<%
subprojects.each { subproject ->
    out.println "include '$subproject'"
}
%>

<3> Gradle wrapper scripts
<4> Gradle settings file to define a root project name and subprojects
<5> Gradle build scripts of the two subprojects - `subproject-a` and `subproject-b`
<6> Source code and/or additional files for the projects

== Invoking Gradle

=== IDE

<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.