when:
        succeeds "build"

        then:
        def plugins = operations.all(ApplyPluginBuildOperationType) {
            it.details.targetType == "project" &&
                it.details.targetPath == ":" &&
                it.details.buildPath == ":"
        }

        def pluginIdByClass = plugins.details.collectEntries ( { [it.pluginClass, it.pluginId ] })

            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) {
        def isRoot = subProjectNumber == null

Consult the <<directory_layout.adoc#dir:gradle_user_home,Gradle Directories reference>> to learn more.

[[project_root]]
== Project Root directory

The project root directory contains all source files from your project.

It also contains files and directories Gradle generates, such as `.gradle` and `build`.

class SettingsIncludeManyIntegrationTest extends AbstractIntegrationSpec {
    // A list of project paths: project000, project001, ..., project300
    private def projectNames = (0..300).collect {
        "project${it.toString().padLeft(3, "0")}"
    }
    private def projectNamesCommaSeparated = projectNames.collect {
        "\"$it\""
    }.join(", ")

    private def createProjectDirectories(int count, String includeFunction) {

import java.util.stream.Stream;

/**
 * Generates an HTML dependency report. This report
 * combines the features of the ASCII dependency report and those of the ASCII
 * dependency insight report. For a given project, it generates a tree of the dependencies
 * of every configuration, and each dependency can be clicked to show the insight of
 * this dependency.
 * <p>

            alwaysPasses = true
        }

        /**
         * Allows passing a predicate which tells if a plugin is supposed to
         * pass or not.
         * Because a plugin validation is independent of _which_ project it is
         * applied to, it doesn't care about the project path.
         */
        void passing(Closure<Boolean> pluginIdPredicate) {
            passingPluginsPredicate = pluginIdPredicate
        }

        given:
        executer.requireOwnGradleUserHomeDir()
        10.times {
            createDirs("project-" + it)
        }
        settingsFile << """
            rootProject.name = 'root'
            10.times {
                include "project-\${it}"
            }
        """
        file("build.gradle") << """
            import java.util.concurrent.CountDownLatch

        return address
    }

    private
    fun displayNameFor(key: K): DisplayName {
        val unitDescription = projectPathForKey(key)?.let { "for project $it" } ?: "for build"
        return Describables.of(valueDescription, unitDescription)
    }

    private
    fun readValue(key: K, addressOfCached: BlockAddress): V {
        try {

# History, Design and Future

Some time ago, <a href="https://github.com/tiangolo/fastapi/issues/3#issuecomment-454956920" class="external-link" target="_blank">a **FastAPI** user asked</a>:

> What’s the history of this project? It seems to have come from nowhere to awesome in a few weeks [...]

Here's a little bit of that history.

## Alternatives

        jarsNotBuilt 'a', 'b', 'c'
    }

    def projectDependency(def link) {
        def from = link['from']
        def to = link['to']

        def dependencies = to.collect {
            "api project(':${it}')"
        }.join('\n')

        buildFile << """
project(':$from') {
    dependencies {
        ${dependencies}
    }
}
"""
    }

    def failingBuild(def project) {