def child = ProjectBuilder.builder().withName("child").withParent(project).build()
    @Shared
    def grandChild1OfChild = ProjectBuilder.builder().withName("grandChild1").withParent(child).build()
    @Shared
    def grandChild2OfChild = ProjectBuilder.builder().withName("grandChild2").withParent(child).build()

    def setupSpec() {
        // create a project/task tree:
        //   root (t1, t2)
        //   +--- child 1 (t2, t3)

        def child = id.child("child")
        def grandchild = child.child("grandchild")

        child.parent == id
        child.path == Path.path("name:child")
        child.projectScopedName == "nameChild"

        grandchild.parent == child
        grandchild.path == Path.path("name:child:grandchild")
        grandchild.projectScopedName == "nameChildGrandchild"
    }

        DefaultCopySpec childTwo = copySpec()
         childTwo.into("child_two")
        parentSpec.with( childTwo)

        DefaultCopySpec grandchild = copySpec()
        grandchild.into("grandchild")
        childOne.with(grandchild)
        childTwo.with(grandchild)

        List<RelativePath> paths = new ArrayList<RelativePath>()
        parentSpec.buildRootResolver().walk(new Action<CopySpecResolver>() {

        transformer.indentation = "\t"
        transformer.addAction { XmlProvider provider -> provider.asNode().children()[0].appendNode("grandchild") }

        when:
        def result = transformer.transform("<root>\n  <child/>\n</root>\n")

        then:
        looksLike "<root>\n\t<child>\n\t\t<grandchild/>\n\t</child>\n</root>\n", result
    }

    def "can add DOCTYPE along with nodes"() {

        def grandchild = new File(child, "grandchild").absoluteFile

        when:
        def watched = resolveWatchedFiles(watchable, buildHierarchy([
            regularFile(new File(grandchild, "missing.txt").absolutePath)
        ]))
        then:
        rootsOf(watched) == [parent.absolutePath]
        1 * watchable.stream() >> Stream.of(parent, child, grandchild)
    }

        setupTest(vfsSpec)
        def grandChild = Mock(FileSystemLocationSnapshot)

        when:
        FileSystemLocationSnapshot foundSnapshot = initialRoot.getSnapshot(searchedPath, CASE_SENSITIVE).get() as FileSystemLocationSnapshot
        then:
        foundSnapshot == grandChild
        interaction {
            getDescendantSnapshotOfSelectedChild(grandChild)
            noMoreInteractions()
        }

        def child = Mock(Node)
        def grandChild = Mock(Node)
        def ancestor = Mock(Node)
        hierarchy.recordNodeAccessingLocations(child, ["/some/location/child/within"])
        hierarchy.recordNodeAccessingLocations(ancestor, ["/some/location"])
        hierarchy.recordNodeAccessingLocations(grandChild, ["/some/location/child/within/some/grandchild"])

        expect:

     *
     * @throws Exception in case of issue
     */
    @Test
    void testBuildFromMiddlePom() throws Exception {
        File f1 = getTestFile("src/test/resources/projects/grandchild-check/child/pom.xml");
        File f2 = getTestFile("src/test/resources/projects/grandchild-check/child/grandchild/pom.xml");

        getProject(f1);

    Project grandChildProject

    def setup() {
        childProject = TestUtil.createChildProject(project, "child", new File("."))
        grandChildProject = TestUtil.createChildProject(childProject, "grandChild", new File("."))
    }

    def "moduleName controls outputFile"() {
        given:
        applyPluginToProjects()
        assert childProject.idea.module.name == "child"

    }

    def "can build the eclipse project hierarchy for a multi-project build"() {

        projectDir.file('settings.gradle').text = '''
            include "child1", "child2", "child1:grandChild1"
            rootProject.name = 'root'
'''
        projectDir.file('child1').mkdirs()

        when:
        EclipseProject rootProject = loadToolingModel(EclipseProject)

        then: