*
     * @param closure The closure to execute when the XML has been created.
     */
    public void withXml(@DelegatesTo(XmlProvider.class) Closure closure) {
        xmlTransformer.addAction(closure);
    }

    /**
     * Adds an action to be called when the file has been created.
     * <p>
     * See {@link #withXml(Closure)}
     *

        delegate.matching(spec)

    override fun matching(closure: Closure<Any>): TaskCollection<Task> =
        delegate.matching(closure)

    override fun clear() =
        delegate.clear()

    override fun addRule(rule: Rule): Rule =
        delegate.addRule(rule)

    override fun addRule(description: String, ruleAction: Closure<Any>): Rule =
        delegate.addRule(description, ruleAction)

            if (property instanceof Closure) {
                Closure closure = (Closure) property;
                closure.setResolveStrategy(Closure.DELEGATE_FIRST);
                BeanDynamicObject dynamicObject = new BeanDynamicObject(closure);
                result = dynamicObject.tryInvokeMethod("doCall", arguments);
                if (!result.isFound() && !(closure instanceof GeneratedClosure)) {

    /**
     * Adds a closure to be called when a task is added to this collection. The task is passed to the closure as the
     * parameter.
     *
     * @param closure The closure to be called
     * @see #whenTaskAdded(Action)
     */
    @SuppressWarnings("UnusedDeclaration")
    void whenTaskAdded(Closure closure);

    /**
     * {@inheritDoc}
     */
    @Override

import groovy.lang.Closure;
import org.gradle.api.Transformer;

public class ClosureBackedTransformer implements Transformer<String, String> {
    private final Closure closure;

    public ClosureBackedTransformer(Closure closure) {
        this.closure = closure;
    }

    @Override
    public String transform(String s) {
        Object val = closure.call(s);

    StubResponse response

    static stubInteraction(Closure<?> closure) {
        ConfigureUtil.configure(closure, new HttpStub())
    }

    def request(Closure<?> closure){
        request = new StubRequest()
        ConfigureUtil.configure(closure, request)
    }

    def response(Closure<?> closure){
        response = new StubResponse()
        ConfigureUtil.configure(closure, response)
    }

    private boolean hasModuleMetadata
    private Closure<?> onEveryFile

    Map<String, String> attributes = [:]

    /**
     * @param cl A closure that is passed a writer to use to generate the content.
     */
    protected void publish(TestFile file, @DelegatesTo(value=Writer, strategy=Closure.DELEGATE_FIRST) Closure cl, byte[] content = null) {
        file.parentFile.mkdirs()

     * @param spec
     */
    void buildSpec(@DelegatesTo(value=MultiProjectBuilder, strategy = Closure.DELEGATE_FIRST) Closure<?> spec) {
        Closure<?> clone = (Closure<?>) spec.clone()
        clone.delegate = projectBuilder
        clone.resolveStrategy = Closure.DELEGATE_FIRST
        clone.call(projectBuilder)
    }

    /**
     * Configures a build spec and finally generates the files

    public void create(Closure<?> closure) {
        create(ClosureBackedAction.of(closure));
    }

    public void afterEach(Closure<?> closure) {
        afterEach(ClosureBackedAction.of(closure));
    }

    public void beforeEach(Closure<?> closure) {
        beforeEach(ClosureBackedAction.of(closure));
    }

    public CopySpec into(Object destPath, Action<? super CopySpec> copySpec) {
        return delegate.into(destPath, copySpec);
    }

    @Override
    public CopySpec rename(final Closure closure) {
        delegate.rename(new ClosureBackedTransformer(closure));
        return this;
    }

    @Override
    public CopySpec rename(Transformer<String, String> renamer) {
        delegate.rename(renamer);
        return this;