given:
        def snippets = snippetsFactory.newSnippets(execOperationsFixture)
        testDirectory.file("included/settings.gradle") << """
            rootProject.name="included"
        """

        testDirectory.file("included/build.gradle") << """
            plugins {
                id 'java-gradle-plugin'
            }

            gradlePlugin {

    /**
     * Returns the included builds that were referenced by this build. This is the set of builds that were directly included by this build via its {@link org.gradle.api.initialization.Settings} instance.
     *
     * <p>Note that this set does not include builds that are added in other ways, such as a `buildSrc` build.

            buildFile << """
                apply plugin: 'java'
                apply plugin: 'idea'
            """
        }

        def included = ['buildB', 'buildC', 'buildD']
        included.each { buildName ->
            def build = singleProjectBuild(buildName) {
                buildFile << """
                    apply plugin: 'java'
                    apply plugin: 'idea'

    }

    def "can execute task from included build"() {
        setup:
        settingsFile << '''
            rootProject.name = 'root'
            includeBuild 'included'
        '''
        file('included/settings.gradle') << '''
            rootProject.name = 'included'
        '''
        file('included/build.gradle') << '''
            tasks.register('foo')
        '''

	// the encapsulated content should come from a trusted source,
	// as it will be included verbatim in the template output.
	HTML string

	// HTMLAttr encapsulates an HTML attribute from a trusted source,
	// for example, ` dir="ltr"`.
	//
	// Use of this type presents a security risk:
	// the encapsulated content should come from a trusted source,
	// as it will be included verbatim in the template output.
	HTMLAttr string

 * is passed a {@link org.gradle.api.file.FileTreeElement}, and must return a boolean value.</p>
 *
 * <p>If no include patterns or specs are specified, then all files in this container will be included. If any include
 * patterns or specs are specified, then a file is included if it matches any of the patterns or specs.</p>
 *
 * <p>If no exclude patterns or spec are specified, then no files will be excluded. If any exclude patterns or specs are

            this.file = file;
            this.result = result;
            this.includeDirectives = includeDirectives;
            this.included = included;
            this.edges = edges;
            this.includeFileDirectives = dependentIncludeDirectives;

        def node1 = Mock(Node)
        root.file("sub/included").createDir()

        hierarchy.recordNodeAccessingFileTree(node1, root.absolutePath, includes("sub/included/*"))

        expect:
        nodesRelatedTo(root.file("sub/included")) == ([node1] as Set)
        nodesRelatedTo(root.file("sub/included/within")) == ([node1] as Set)
        nodesRelatedTo(root.file("sub/included/within/notMatched")) == Collections.emptySet()
    }

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

        when:
        def model = withConnection { getModel(HierarchicalEclipseProject) }

        then:
        model.name == 'module-root'
    }

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

        when:
        run ":projects"

        then:
        outputContains """
Root project 'my-root-project'
No sub-projects

Included builds:

+--- Included build ':another'
\\--- Included build ':third'"""
    }

    def "included builds are only shown in the context of the root project"() {
        given:
        createDirs("p1", "p1/p11", "another")