1. Clean the cache directory to avoid any hits from previous builds (`rm -rf $GRADLE_USER_HOME/caches/build-cache-*`)
2. Run the build (e.g. `./gradlew --build-cache clean assemble`), so that all the results from cacheable tasks get stored in the cache.
3. Run the build again (e.g. `./gradlew --build-cache clean assemble`); depending on your build, you should see many of the tasks being retrieved from the cache.

Gradle uses two main features to reduce build time: *incremental builds* and *build caching*.

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

== Incremental builds

An *incremental build* is a build that avoids running tasks whose inputs have not changed since the previous build.
Re-executing such tasks is unnecessary if they would only re-produce the same output.

For incremental builds to work, tasks must define their inputs and outputs.

    def "builds dependency for nonIdea project"() {
        when:
        def dependency = builder.create(projectId, 'compile')

        then:
        dependency.scope == 'compile'
        dependency.name == "project-name"

        and:
        artifactRegistry.getIdeProject(_, _) >> null
    }

    def "builds dependency for nonIdea root project"() {
        when:

/**
 *
 * <p>A {@code TestLauncher} allows you to execute tests in a Gradle build.</p>
 *
 * <p>If the target Gradle version is &gt;=6.8 then you can use {@code TestLauncher} to execute tests from included builds. Test operation descriptors from included builds work out-of-the-box. You can
 * target tasks from included builds by specifying the task identity path (i.e. {@code ':included-build-name:subproject-name:taskName'}).</p>
 *

        nestedBuildSrc.editableBuilds.empty
    }

    @TargetGradleVersion(">4.9 <7.1")
    // versions 4.9 and older do not like nested included builds or nested buildSrc builds
    def "older versions do not include buildSrc builds in model"() {
        buildsWithBuildSrc()

        given:
        def model = withConnection {
            it.getModel(GradleBuild)
        }

        expect:

     */
    @Nonnull
    SettingsBuilderResult build(@Nonnull SettingsBuilderRequest request);

    /**
     * Builds the effective settings of the specified settings sources.
     *
     * @return the result of the settings building, never {@code null}
     * @throws SettingsBuilderException if the effective settings could not be built
     */
    @Nonnull
    default SettingsBuilderResult build(

/**
 * The persistent ID of a potential build on disk.
 *
 * It is effectively the root dir of a build.
 * That is, two builds with the same root dir share the same workspace.
 *
 * In practice, this generally maps to what users would think of as “checkout” of a project.
 * Builds of the same checkout over time will share the same workspace ID.
 *
 * This ID is persisted in the root build's project cache dir.

                        doLast {
                            def projects = []
                            def builds = []
                            registry.visitBuilds { b ->
                                builds.add(b.identityPath.path)
                                if (b.projectsLoaded) {

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

While `.gradle` is usually checked into source control, the `build` directory contains the output of your builds as well as transient files Gradle uses to support features like incremental builds.

The anatomy of a typical project root directory looks as follows:

[listing,subs=+macros]
----

        given:
        compositeWithRootInvolvingIncludeCycle()

        when:
        def eclipseProjects = withConnection { action(new FetchEclipseProjects()).run() }

        then:
        eclipseProjects.collect { it.name } == ['module-root', 'module-a']
    }

    def "Eclipse model builder can handle cycles between included builds"() {
        given: