'1.4'   | 'asElement'        | { it.asElement() }
        '5'     | 'asNode'           | { it.asNode() }
        '5'     | 'asElement'        | { it.asElement() }
        '6'     | 'asNode'           | { it.asNode() }
        '6'     | 'asElement'        | { it.asElement() }
        '7'     | 'asNode'           | { it.asNode() }
        '7'     | 'asElement'        | { it.asElement() }

        when:
        def result = transformer.transform('<root/>')

        then:
        action.execute(_) >> { XmlProvider provider ->
            def document = provider.asElement().ownerDocument
            provider.asElement().appendChild(document.createElement('child1'))
        }
        looksLike '<root>\n  <child1/>\n</root>\n', result
    }

    def "can transform String to a Writer"() {

            childNodes
                .run { (0 until length).map(::item) }
                .filterIsInstance<Element>()
                .first { it.predicate() }

        asElement()
            .firstElement { tagName == "component" && getAttribute("name") == "VcsDirectoryMappings" }
            .firstElement { tagName == "mapping" }
            .setAttribute("vcs", "Git")
    })
}

//      webModule("my.war", "/")  // won't deploy as my.war isn't deploy dependency
        securityRole("admin")
        securityRole("superadmin")
        withXml { // add a custom node to the XML
            asElement().apply {
                appendChild(ownerDocument.createElement("data-source").apply { textContent = "my/data/source" })
            }
        }
    }

     * to the XML. The returned instance is only valid until one of the other methods on this interface are called.
     *
     * @return An {@code Element} representation of the XML.
     */
    Element asElement();

            void recurse(Element annotatedElement) {
                annotatedElement.getAnnotationMirrors().forEach(annotationMirror -> {
                    Element element = annotationMirror.getAnnotationType().asElement();
                    if (element instanceof TypeElement && result.add(annotationMirror)) {
                        recurse(element);
                    }
                });
            }
        }

    fun Element.firstElement(predicate: Element.() -> Boolean) =
        childNodes
            .run { (0 until length).map(::item) }
            .filterIsInstance<Element>()
            .first { it.predicate() }

    asElement()
        .firstElement { tagName === "fixed" && getAttribute("facet") == "jst.java" }
        .setAttribute("facet", "jst2.java")
})
// end::wtp-with-xml[]

val integTest by sourceSets.creating

    }

    @Override
    public Type visitDeclared(DeclaredType t, Void unused) {
        List<Element> typeNesting = new ArrayList<>();
        Element current = t.asElement();
        while (current != null) {
            typeNesting.add(current);
            current = current.getEnclosingElement();
        }
        Collections.reverse(typeNesting);

                descriptor.withXml(new Action<XmlProvider>() {
                    @Override
                    public void execute(XmlProvider xmlProvider) {
                        Element root = xmlProvider.asElement();
                        Document document = root.getOwnerDocument();
                        Node dependencies = root.getElementsByTagName("dependencies").item(0);

        publication.getPom().withXml(new Action<XmlProvider>() {
            @Override
            public void execute(XmlProvider xmlProvider) {
                Element root = xmlProvider.asElement();
                Document document = root.getOwnerDocument();
                Node dependencies = root.appendChild(document.createElement("dependencies"));