then:
        action.execute(_) >> { XmlProvider provider ->
            provider.asNode().appendNode('child\u03b1')
        }
        looksLike '<root>\n  <child\u03b1/>\n</root>\n', file.bytes
    }

    def "can use a closure as an action"() {
        transformer.addAction { provider ->
            provider.asNode().appendNode('child1')
        }
        StringWriter writer = new StringWriter()

        version | withXmlDescription | withXmlClosure
        '1.3'   | 'asNode'           | { it.asNode() }
        '1.4'   | 'asNode'           | { it.asNode() }
        '1.4'   | 'asElement'        | { it.asElement() }
        '5'     | 'asNode'           | { it.asNode() }
        '5'     | 'asElement'        | { it.asElement() }
        '6'     | 'asNode'           | { it.asNode() }
        '6'     | 'asElement'        | { it.asElement() }

    void enablesCustomizationOfIws() {
        //when
        runIdeaTask '''
apply plugin: "java"
apply plugin: "idea"

idea.workspace.iws.withXml { it.asNode().appendNode('foo', 'bar') }

idea {
    workspace {
        iws {
            withXml {
                it.asNode().appendNode('stay', 'happy')
            }
        }
    }
}
'''

        //then
        String content = getFile([:], "root.iws").text

                            extraInfo 'http://my.extra.info1', 'foo', 'fooValue'
                            extraInfo 'http://my.extra.info2', 'bar', 'barValue'
                            withXml {
                                asNode().info[0].@resolver = 'test'
                            }
                        }
                    }
                }
            }
        """
        succeeds 'publish'

        then:

                                "prop.with.dots": "anotherValue"
                            ]
                            withXml {
                                def dependency = asNode().appendNode('dependencies').appendNode('dependency')
                                dependency.appendNode('groupId', 'junit')
                                dependency.appendNode('artifactId', 'junit')

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

    /**
     * Returns the XML document as a DOM {@link org.w3c.dom.Element}. Changes to the returned instance will be applied

        when:
        buildFile << """
    model {
        visualStudio {
            projects.all { project ->
                projectFile.withXml { xml ->
                    Node globals = xml.asNode().PropertyGroup.find({it.'@Label' == 'Globals'}) as Node
                    globals.appendNode("ExtraInfo", "Some extra info")
                    globals.appendNode("ProjectName", project.name)
                }

//      webModule("my.war", "/")  // won't deploy as my.war isn't deploy dependency
        securityRole "admin"
        securityRole "superadmin"
        withXml { provider -> // add a custom node to the XML
            provider.asNode().appendNode("data-source", "my/data/source")
        }
    }

eclipse.project.file.beforeMerged { project ->
    project.natures.clear()
}
// end::project-before-merged[]

// tag::wtp-with-xml[]
eclipse.wtp.facet.file.withXml { provider ->
    provider.asNode().fixed.find { it.@facet == 'jst.java' }.@facet = 'jst2.java'
}
// end::wtp-with-xml[]

sourceSets {
    integTest
}

configurations {
    functional
}

eclipse {
    classpath {

 *  }
 *
 *  model {
 *      visualStudio {
 *          projects.all {
 *              projectFile.location = "vs/${name}.vcxproj"
 *              projectFile.withXml {
 *                  asNode().appendNode('PropertyGroup', [Label: 'Custom'])
 *                          .appendNode('ProjectDetails', "Project is named ${project.name}")
 *              }
 *          }
 *      }
 *  }
 * </pre>
 */