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()

            .filter { model.subprojects.getSubprojectByName(it.key) != null }
            .map { SubprojectTestClassTime(model.subprojects.getSubprojectByName(it.key)!!, it.value.filter { it.testClassAndSourceSet.sourceSet != "test" }) }
            .sortedBy { -it.totalTime }
            .filter { onlyNativeSubprojectsForIntelMacs(testCoverage, it.subProject.name) }

            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() {

    private val nameToSubproject = subprojects.map { it.name to it }.toMap()
    override fun getSubprojectsForFunctionalTest(testConfig: TestCoverage) =
        subprojects.filter { it.hasTestsOf(testConfig.testType) }

    override fun getSubprojectByName(name: String) = nameToSubproject[name]

    private
    fun toSubproject(subproject: Map<String, Any>): GradleSubproject {
        val name = subproject["name"] as String

        buildScanTags = listOf("Check"),
        subprojects = JsonBasedGradleSubprojectProvider(File("./subprojects.json"))
    )
    val gradleBuildBucketProvider = DefaultFunctionalTestBucketProvider(model, File("./test-buckets.json"))
    subProject(CheckProject(model, gradleBuildBucketProvider))

    if (!isSecurityFork()) {
        subProject(PromotionProject(model.branch))
        subProject(UtilProject)

        return project
    }

    def multiProjectBuild(String projectName, List<String> subprojects, @DelegatesTo(value = BuildTestFile, strategy = Closure.DELEGATE_FIRST) Closure cl = {}) {
        multiProjectBuild(projectName, subprojects, CompiledLanguage.JAVA, cl)
    }

        }

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

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

        if (!subprojects.isEmpty() && modularizationOption == ModularizationOption.SINGLE_PROJECT) {
            return singletonList(subprojects.get(0));
        }
        return subprojects;
    }

    public String getProjectName() {
        return projectName;
    }

    public List<String> getSubprojects() {
        return subprojects;
    }

* Create a modular software project by combining multiple subprojects
* Share build configuration logic between subprojects using convention plugins in `buildSrc`
* Run similar named tasks in all subprojects
* Run a task in a specific subproject
* Build, bundle and run the application

== Next steps

When your project grows, you might be interested in more details how to configure JVM projects, structuring multi-project builds and dependency management:

image::gradle-basic-3.png[]

The primary purpose of the _settings file_ is to add subprojects to your build.

Gradle supports single and multi-project builds.

- For single-project builds, the settings file is optional.
- For multi-project builds, the settings file is mandatory and declares all subprojects.

[[sec:settings_file_script]]
== Settings script

The settings file is a script.