settingsFile << """
            rootProject.name = 'root'
            include '1', '2'
        """
        buildFile << """
            subprojects {
                task otherBuild(type:GradleBuild) {
                    dir = "\${rootProject.file('subprojects')}"
                    tasks = ['log']
                    buildName = project.name + "nested"
                    def startEvent = project.name + "-started"

    def "will substitute and run build dependencies for closed projects on startup"() {
        setup:
        multiProjectBuildInRootFolder("parent", ["child1", "child2"]) {
            buildFile << """
            subprojects {
                apply plugin: 'java-library'
            }
            project(":child1") {
                configurations {
                    testArtifacts
                }

    @ToBeFixedForIsolatedProjects(because = "subprojects")
    def "build is not exponentially slower when many tasks are requested"() {
        createDirs((1..30).collect({ "sub" + it }) as String[])
        settingsFile << """
            rootProject.name = "test"
            (1..30).each {
                include "sub" + it
            }
        """
        buildFile << """
            subprojects {
                apply plugin: 'java'

    }

    @Requires(
        value = IntegTestPreconditions.NotIsolatedProjects,
        reason = "accessing `tasks` from subprojects is in violation of Isolated Projects"
    )
    def "lifecycle applied build logic runs before subprojects configuration logic"() {
        given:
        settingsFile """
            include 'sub'

            $beforeProject {

Expand that row to see where the build applied this script.

image::performance/script-b-application.png[title="Showing the application of script-b.gradle to the build"]

You can see that subproject `:app1` applied the script once, from inside of that subproject's `build.gradle` file.

== Profile report

If you prefer not to use build scans, you can generate an HTML report in the

                }
            }
            dependencies {
                runtimeOnly project(":subproject")
            }
        """
        file("buildSrc/settings.gradle") << """
            include 'subproject'
        """
        buildFile << """
            apply plugin: MyPlugin
            apply plugin: MyPluginSub
            // nuke buildSrc classes so we can't use them

testing/internal-performance-testing/       @gradle/bt-developer-productivity
testing/internal-testing/                   @gradle/bt-developer-productivity

# Release coordination
subprojects/core-platform/              @gradle/bt-support
subprojects/distributions-dependencies/ @gradle/bt-support
subprojects/distributions-full/         @gradle/bt-support
testing/performance/                    @gradle/bt-support
testing/smoke-test/                     @gradle/bt-support

        then:
        project.languageLevel.level == "JDK_1_5"
        project.jdkName == '1.6'
    }

    def "provides all modules"() {

        file('build.gradle').text = '''
subprojects {
    apply plugin: 'java'
}
'''
        file('settings.gradle').text = "include 'api', 'impl'"

        when:
        IdeaProject project = loadToolingModel(IdeaProject)

        then:

link:../samples/sample_convention_plugins.html[**Convention plugins**] are plugins used to share build logic between subprojects (modules).
Users can wrap common logic in a convention plugin.
For example, a code coverage plugin used as a convention plugin can survey code coverage for the _entire project_ and _not_ just a specific subproject.

TIP: Gradle highly recommends the use of Convention plugins.

[.text-right]

class ToolingApiIdeaModelCrossVersionSpec extends ToolingApiSpecification implements WithOldConfigurationsSupport {
    def "Provides target module name for module dependencies"() {


        file('build.gradle').text = """
subprojects {
    apply plugin: 'java'
}

project(':impl') {
    apply plugin: 'idea'

    dependencies {
        ${implementationConfiguration} project(':api')
    }
}
"""