== Step 1. Understanding Incremental Builds
It's important to know that Gradle optimizes your build in a variety of ways.
One such optimization is called _incremental builds_.

An _incremental build_ is a build that avoids running tasks whose inputs did not change since the previous build, making the execution of such tasks unnecessary.

        notifications.started(EvaluateSettingsBuildOperationType.Details, [settingsDir: file('a').absolutePath, settingsFile: file('a/settings.gradle').absolutePath, buildPath: ":a"])
        notifications.started(EvaluateSettingsBuildOperationType.Details, [settingsDir: file('a/buildSrc').absolutePath, settingsFile: file('a/buildSrc/settings.gradle').absolutePath, buildPath: ":a:buildSrc"])

    }

    def "can depend on task from subproject of composing build"() {
        given:
        createDirs("buildA", "buildA/a1")
        buildA.settingsFile << """
    include 'a1'
"""
        buildA.buildFile << """
    task("top-level") {
        dependsOn ':a1:delegate'
    }

    project(':a1') {
        task delegate {

    @Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = "classloader isolation does not work here in embedded mode")
    @InspectsExecutedTasks
    def "buildSrc classes are not visible to injected classes"() {
        plugin.build()
        def buildSrcSrcDir = file("buildSrc/src/main/groovy/org/gradle/test")

        // these class names intentionally clash with what we are injecting

        given:
        def pluginBuilder = new PluginBuilder(file("plugin"))
        pluginBuilder.addSettingsPlugin """
            settings.gradle.allprojects {
                println "Hello from root build's plugin"
            }
        """, "org.gradle.test.MyPlugin", "MyPlugin"

        pluginBuilder.prepareToExecute()

        settingsFile << """
            includeBuild("plugin")
        """

* The build's output;
* The build's logging (i.e. console output);
* The set of tasks executed by the build and their results (e.g. FAILED, UP-TO-DATE etc.).

Paul Merlin <******@****.***> 1690890212 +0200

        when:
        run 'otherBuild'

        then:
        result.assertTaskExecuted(":other:buildSrc:jar")
    }

    def "buildSrc can have nested build"() {
        given:
        file('buildSrc/src/main/java/Thing.java') << "class Thing { }"
        file('buildSrc/build.gradle') << """
            task otherBuild(type:GradleBuild) {
                dir = '../other'
                tasks = ['build']

 */

package org.gradle.initialization.buildsrc

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

class DisallowBuildSrcAsNameIntegTest extends AbstractIntegrationSpec {

    def "fails when trying to include buildSrc as project"() {
        buildFile << """
            task t
        """
        settingsFile << """
            include 'buildSrc'
        """

        when:
        fails "t"

The plugin could be in the same repository (only used by this build) or it could be in a different repository (used by many other builds).

This removes the need for the special `buildSrc` project and makes prototyping plugins even easier.

== Buildscript dependencies are substituted