}

        buildD = singleProjectBuild('buildD') {
            buildFile << javaProject()
            file('src/test/java/SampleTestD.java') << junitTestClass('SampleTestD')
        }
    }

    def "can collect build failures from multiple included builds"() {
        when:
        includedBuilds << buildB << buildC << buildD

        buildA.buildFile << """
            task testAll {

 * under the License.
 */
package org.apache.maven.toolchain;

import java.io.File;

import org.apache.maven.toolchain.model.PersistedToolchains;

/**
 * Builds the toolchains model from a previously configured filesystem path to the toolchains file.
 * <strong>Note:</strong> This is an internal component whose interface can change without prior notice.
 *

     */
    void registerWatchableHierarchy(File rootDirectoryForWatching);

    /**
     * Returns if anything is being watched.
     */
    boolean isWatchingAnyLocations();

    /**
     * Called when the build is finished.
     *
     * This operation happens in the context of executing the build from the client's perspective.
     */

...

> Task :hello SKIPPED
Skipping task ':hello' as task onlyIf 'there is no property skipHello' is false.
:hello (Thread[included builds,5,main]) completed. Took 0.018 secs.

/**
 * A listener that is notified when a session is started and completed. No more than one session may be active at any time.
 *
 * One or more builds may be run during a session. For example, when running in continuous mode, multiple builds are run during a single session.
 */
@EventScope(Scope.BuildSession.class)
public interface BuildSessionLifecycleListener {
    /**

     * These services are closed at the end of the build invocation.
     *
     * <p>{@link Build} and parent scope services are visible to {@link Gradle} scope services, but not vice versa.</p>
     */
    interface Gradle extends Build {}

    /**
     * These services are created once per project per build invocation.
     * These services are closed at the end of the build invocation.
     *

import org.gradle.initialization.IncludedBuildSpec;
import org.gradle.initialization.SettingsLoader;
import org.gradle.initialization.SettingsState;
import org.gradle.internal.build.BuildIncluder;
import org.gradle.internal.build.CompositeBuildParticipantBuildState;

import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

== Finding problems with task output caching

Below we describe a step-by-step process that should help shake out any problems with caching in your build.

=== Ensure incremental build works

First, make sure your build does the right thing without the cache.
Run a build twice without enabling the Gradle build cache.
The expected outcome is that all actionable tasks that produce file outputs are up-to-date.

                buildFile << """
                    apply plugin: 'java'
"""
            }
            dependency previousBuild, "org.test:${buildName}:1.0"
            includedBuilds << build
            previousBuild = build
        }

        expect:
        execute(buildA, "jar", "--max-workers=1")
    }

    def "constructs included build artifacts in parallel"() {

 *    connection.close();
 * }
 * </pre>
 *
 * <p>The connection will use the version of Gradle that the target build is configured to use, for example in the Gradle wrapper properties file. When no Gradle version is defined for the build, the connection will use the tooling API's version as the Gradle version to run the build.
 *  Generally, you should avoid configuring a Gradle distribution or version and instead use the default provided by the tooling API.