/**
     * Executes the given action against an Ivy instance. Sets up the Ivy context before the action and cleans up at the end.
     *
     * <p>The Ivy instance of the calling thread is reused if the thread is already executing an action against an Ivy instance.
     */
    void withIvy(Action<? super Ivy> action);

    /**

            println "* GET IVY FILE"
            def ivy = resources.ivy
            provideHeadersForResource(response, ivy)
            ivy.writeContentTo(response.outputStream)
        }

        private void handleHeadIvy(HttpServletResponse response) {
            println "* HEAD IVY FILE"
            provideHeadersForResource(response, resources.ivy)
        }

import org.gradle.api.publish.ivy.IvyExtraInfoSpec;
import org.gradle.api.publish.ivy.IvyModuleDescriptorAuthor;
import org.gradle.api.publish.ivy.IvyModuleDescriptorDescription;
import org.gradle.api.publish.ivy.IvyModuleDescriptorLicense;
import org.gradle.api.publish.ivy.internal.dependency.IvyDependency;
import org.gradle.api.publish.ivy.internal.dependency.IvyExcludeRule;
import org.gradle.api.publish.ivy.internal.publisher.IvyPublicationCoordinates;

        failure.assertHasCause("Could not write to resource '${module.jar.uri}'")
    }

    def expectPublication() {
        module.jar.expectPut()
        module.jar.sha1.expectPut()
        module.jar.sha256.expectPut()
        module.jar.sha512.expectPut()
        module.ivy.expectPut()
        module.ivy.sha1.expectPut()

    @ToBeFixedForConfigurationCache
    def "request an ivy descriptor for an ivy module with a custom ivy pattern"() {
        given:
        httpRepo = server.getRemoteIvyRepo(true, "[module]/[revision]", "alternate-ivy.xml", "[artifact](.[ext])")

        buildFile.text = """
repositories {
    ivy {
        url '${httpRepo.uri}'
        patternLayout {
            artifact '[module]/[revision]/[artifact](.[ext])'

                    ivyPattern 'http://myCompanyBucket/ivyrepo/[organisation]/[module]/ivy-[revision].xml'
                    patternLayout {
                        artifact '[module]/[organisation]/[revision]/[artifact]'
                        artifact '3rd-party/[module]/[organisation]/[revision]/[artifact]'
                        ivy '[module]/[organisation]/[revision]/ivy.xml'
                        m2compatible = true
                    }

        file("build", "publications", "ivyJava", "ivy.xml.asc").text
    }

    def "signs Gradle metadata"() {
        given:
        buildFile << """
            apply plugin: 'ivy-publish'
            apply plugin: 'maven-publish'
            ${keyInfo.addAsPropertiesScript()}

            publishing {
                publications {
                    ivy(IvyPublication) {

        fails 'publish'

        then:
        failure.assertHasCause("Ivy publication 'ivy' cannot include multiple components")
    }

    def "publishes to all defined repositories"() {
        given:
        def ivyRepo2 = ivy("ivy-repo-2")

        settingsFile << "rootProject.name = 'root'"
        buildFile << """
            apply plugin: 'ivy-publish'

            group = 'org.gradle.test'

            STACKTRACE_MESSAGE,
            INFO_DEBUG,
            SCAN,
            GET_HELP)

    }

    void "resolve missing dynamic dependencies from a SFTP Ivy repository"() {
        given:
        buildFile << """
            repositories {
                ivy {
                    url "${ivySftpRepo.uri}"
                    credentials {
                        username 'sftp'

        compile 'group:projectD:1.0GA'
    }
}
task showMissing { doLast { println configurations.compile.files } }
"""

        when:
        moduleA.ivy.expectGetMissing()
        moduleB.ivy.expectGetMissing()
        moduleC.ivy.expectGet()
        moduleD.ivy.expectGet()

        then:
        fails("showMissing")
        failure.assertHasDescription('Execution failed for task \':showMissing\'.')