"""

        when:
        runBuild('run')

        then:
        task(':included:a').dependencies.empty
        task(':included:b').dependencies == tasks(':included:a')
        task(':included:c').dependencies == tasks(':included:b')
        task(':included:d').dependencies == tasks(':included:b', ':included:c')
    }

    def "reports task dependencies for tasks in multi-project builds"() {
        given:

        def included1 = model.includedBuilds[0]
        included1.buildIdentifier.rootDir == file("child1")
        included1.includedBuilds.size() == 1
        included1.editableBuilds.empty

        model.editableBuilds.size() == 2

        model.editableBuilds[0].is(included1)

        def included2 = model.editableBuilds[1]
        included2.buildIdentifier.rootDir == file("child2")

    }

    def "can fetch GradleProject model for an included build project"() {
        settingsFile << """
            rootProject.name = 'root'
            includeBuild("included1")
            include("lib1")
        """

        file("included1/settings.gradle") << """
            rootProject.name = 'included1'
            include("lib2")
        """

        exec().groovy               | "included/settings.gradle"
        javaexec().groovy           | "included/settings.gradle"
        processBuilder().groovy     | "included/settings.gradle"
        stringArrayExecute().groovy | "included/settings.gradle"
        runtimeExec().groovy        | "included/settings.gradle"
        exec().kotlin               | "included/settings.gradle.kts"

public class IncludeFileEdge {
    private final String includePath;
    @Nullable
    private final HashCode includedBy;
    private final HashCode resolvedTo;

    public IncludeFileEdge(String includePath, @Nullable HashCode includedBy, HashCode resolvedTo) {
        this.includePath = includePath;
        this.includedBy = includedBy;
        this.resolvedTo = resolvedTo;
    }

    public String getIncludePath() {

        outputContains('system_property_available in included buildSrc:        true')
        outputContains('project_property_available in included buildSrc:       false')
        outputContains('system_property_available in included root:            true')
        outputContains('project_property_available in included root:           false')

        output.contains('system_property_available in included buildSrc:        true')
        output.contains('project_property_available in included buildSrc:       false')
        output.contains('overridden_by_includedBuild in included buildSrc:      null')
        output.contains('system_property_available in included root:            true')
        output.contains('project_property_available in included root:           false')

        e.message == 'No test for task :included-build:test declared for execution.'
    }

    def "can target specific test task and classes from included build"() {
        when:
        launchTests { TestLauncher launcher ->
            launcher.withTaskAndTestClasses(':included-build:test', ["example.IncludedTest2"])
        }
        then:
        assertTaskExecuted(":included-build:test")

                project(':').apply from: 'buildSrcWhenReady.gradle'
            }
        """

        file('included-build/settings.gradle') << """
            rootProject.name = 'included-build'
        """

        file('included-build/includedWhenReady.gradle') << ""
        file('included-build/build.gradle') << """
            apply plugin: AcmePlugin

            class AcmePlugin implements Plugin<Project> {

    def setup() {
        createDirs("sub", "included", "included/sub")
        settingsFile << """
            rootProject.name = 'root'
            include('sub')
            includeBuild('included')
        """
        file('included/settings.gradle') << """
            include('sub')
        """
        buildFile << """