def child1 = root.child(root.name)
        def child2 = root.child(root.name)
        def grandChild1 = child1.child(root.name)
        def grandChild2 = child2.child(root.name)

        expect:
        equivalent(child1, child2)
        equivalent(grandChild1, grandChild2)
    }

    def "children from different parents with same name are not equal"() {
        def parent1 = root.child("parent1")

    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:

<project>
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>grandchildtest</groupId>
    <artifactId>child</artifactId>
    <version>1</version>
  </parent>
  <artifactId>grandchild</artifactId>

  <parent>
    <groupId>grandchildtest</groupId>
    <artifactId>root-pom</artifactId>
    <version>1</version>
  </parent>
  <artifactId>child</artifactId>
  <packaging>pom</packaging>
  <modules>
    <module>grandchild</module>
  </modules>