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()

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

        private final String className;
        private final Lazy<MethodNode> asNode;
        private final Collection<JvmBytecodeCallInterceptor> externalInterceptors;
        private final BytecodeInterceptorFilter interceptorFilter;

        public InstrumentingMethodVisitor(InstrumentingVisitor owner, MethodVisitor methodVisitor, Lazy<MethodNode> asNode, ClassData classData, JvmBytecodeInterceptorSet externalInterceptors) {

                                    declareScalaSdk(scalaCompilerLibraries.get(project.getPath()), xmlProvider.asNode());
                                } else {
                                    declareScalaFacet(scalaCompilerLibraries.get(project.getPath()), xmlProvider.asNode());
                                }
                            }
                        });
                    }

                .dependsOn("c")
                .withXml({
            asNode().dependencies[0].dependency.each { dep ->
                dep.appendNode("exclude", [module: "d"])
            }
        })
                .publish()
        ivyRepo.module("b")
                .dependsOn("c")
                .withXml({
            asNode().dependencies[0].dependency.each { dep ->

                scope == "runtime"
            }
        }
    }

    def "applies withXml actions"() {
        when:
        pom.withXml {
            asNode().groupId[0].value = "new-group"
        }
        pom.withXml {
            asNode().appendNode("description", "custom-description-ぴ₦ガき∆ç√∫")
        }

        then:
        with (xml) {
            groupId == "new-group"

        when:
        buildFile.text = buildFile.text.replace "projectFile.withXml { }", """
                    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)
                    }

        def pomFile = createPomFile(makeProjectIdentity("group", "artifact", "version"), new Action<XmlProvider>() {
            void execute(XmlProvider xml) {
                xml.asNode().appendNode("parent")
            }
        })
        def publication = new MavenNormalizedPublication("pub-name", projectIdentity, "pom", pomFile, null, emptySet())

        when:

        when:
        descriptor.withXml(new Action<XmlProvider>() {
            void execute(XmlProvider t) {
                t.asNode().info[0].@revision = "3"
            }
        })
        descriptor.withXml(new Action<XmlProvider>() {
            void execute(XmlProvider t) {
                t.asNode().info[0].appendNode("description", "custom-description-ぴ₦ガき∆ç√∫")
            }
        })

        then:

          assert it.deployName == 'coolDeployName'
        }
        whenMerged {
          hooks << 'whenMerged'
          it.deployName = 'betterDeployName'
        }
        withXml { it.asNode().appendNode('be', 'cool') }
      }
    }
  }
}

eclipseWtpComponent.doLast() {
  assert hooks == ['beforeMerged', 'whenMerged']
}

        """

        //when