subprojects {

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'

repositories {
<% if (repository) { %>
    maven {
        url rootProject.file("${repository.rootDir.name}").toURI().toURL()
    }
<% } %>
    mavenCentral()
}

dependencies {
    implementation 'commons-lang:commons-lang:2.5'
    implementation "commons-httpclient:commons-httpclient:3.0"
    implementation "commons-codec:commons-codec:1.2"

There are now two ways to collect test results across multiple subprojects:

1. From the distribution's project, such as an application or WAR subproject -> link:../samples/sample_jvm_multi_project_with_test_aggregation_distribution.html[distribution sample]
2. Using a standalone project to specify subprojects -> link:../samples/sample_jvm_multi_project_with_test_aggregation_standalone.html[standalone sample]

            include(":libA")
            include(":libB")
            include(":libC")

        """.stripIndent()

        if (config.subProjects != 0) {
            includedProjects += """${(0..config.subProjects - 1).collect { "include(\"project$it\")" }.join("\n")}"""
        }

        return includedProjects
    }

    static String generateBuildGradle(Integer subProjectNumber) {

import org.gradle.api.Action;
import org.gradle.api.Project;

public interface CrossProjectConfigurator {

    void project(ProjectInternal project, Action<? super Project> configureAction);

    void subprojects(Iterable<? extends ProjectInternal> projects, Action<? super Project> configureAction);

    void allprojects(Iterable<? extends ProjectInternal> projects, Action<? super Project> configureAction);

import org.junit.Test

class AutoTestedSamplesCoreApiIntegrationTest extends AbstractAutoTestedSamplesTest {

    @Test
    void runSamples() {
        // for example in Settings.java
        file('subprojects/abc').createDir()

        // for example in DependencySubstitutions.java
        file("settings.gradle") << """
            include 'api', 'util'
        """

        runSamplesFrom("src/main")
    }

            " -Porg.gradle.java.installations.auto-download=false"
    )

    features {
        publishBuildStatusToGithub(model)
    }

    artifactRules = """$artifactRules
        subprojects/distributions-full/build/distributions/*.zip => distributions
        platforms/core-runtime/base-services/build/generated-resources/build-receipt/org/gradle/build-receipt.properties
    """.trimIndent()

        buildType(stagePasses)
        subProject(stageProject)

        prevStage = stage
        previousPerformanceTestPasses.addAll(stageProject.performanceTests)
    }

    buildType(GitHubMergeQueueCheckPass(model))

    buildTypesOrder = buildTypes
    subProjectsOrder = subProjects

    cleanupRule(
        historyDays = 14,
        artifactsDays = 7,

- `include("${subprojectName.raw}")` defines that the build consists of one subproject called `${subprojectName.raw}` that contains the actual code and build logic.
  More subprojects can be added by additional `include(...)` statements.

Our build contains one subproject called `${subprojectName.raw}` that represents the ${language.raw} ${componentType.raw} we are building.

        buildTestFixture.singleProjectBuild(projectName, cl)
    }

    def multiProjectBuild(String projectName, List<String> subprojects, @DelegatesTo(BuildTestFile) Closure cl = {}) {
        buildTestFixture.multiProjectBuild(projectName, subprojects, cl)
    }

    }

    def "can depend back on root build"() {
        given:
        def rootBuild = multiProjectBuild('rootBuild', ['root1', 'root2']) {
            buildFile << """
                subprojects { apply plugin: 'java-library'}
                project(':root1') {
                    dependencies { implementation 'org.test:theNameOfBuildA' }
                }
            """
            settingsFile << """