def repo3Name = "ivy"
        repo3.getName() >> { repo3Name }
        repo3.setName(_) >> { repo3Name = it[0] }

        repositoryFactory.createIvyRepository() >>> [repo1, repo2, repo3]

        when:
        handler.ivy {}
        handler.ivy {}
        handler.ivy {}

        then:
        repo1Name == "ivy"
        repo2Name == "ivy2"
        repo3Name == "ivy3"
    }

        def repo2ProjectA2 = repo2.module("group", "projectA", "1.2").publish()
        repo1ProjectA1.ivy.expectGet()
        repo2ProjectA1.ivy.expectHead()
        repo2ProjectA1.ivy.sha1.expectGet()
        repo2ProjectA1.ivy.expectGet()
        repo2ProjectA1.jar.expectGet()
        succeeds "cache"

        when:
        repo1.directoryList("group", "projectA").expectGet()

        ivy.expectArtifact('ivyPublish', 'html').hasType("html").hasConf(null)
        ivy.expectArtifact('ivyPublish', 'jar').hasType("jar").hasConf(null)
        ivy.expectArtifact('ivyPublish', 'reg').hasType("reg").hasConf(null)
        ivy.expectArtifact('ivyPublish', 'foo').hasType("foo").hasConf(null)
        ivy.expectArtifact('ivyPublish', 'bar').hasType("bar").hasConf(null)

        and:

        when:
        thirdPartyModuleInEmptyRepo.ivy.expectDownloadMissing()
        thirdPartyModuleInEmptyRepo.jar.expectDownloadMissing()
        thirdPartyModule.ivy.expectDownload()
        thirdPartyModule.jar.expectDownload()

        companyModuleInEmptyRepo.ivy.expectDownloadMissing()
        companyModuleInEmptyRepo.jar.expectDownloadMissing()
        companyModuleInThirdPartyRepo.ivy.expectDownloadMissing()

                .expectSourceArtifact("my-sources")
                .createVerifyTask("verifyRefresh")

        and:
        server.resetExpectations()
        module.ivy.expectHead()
        module.ivy.sha1.expectGet()
        module.ivy.expectGet()
        sourceArtifact.expectGet()

        then:
        executer.withArgument(execArg)
        succeeds("verifyRefresh")

        where:

        def file = temporaryFolder.file("ivy.xml") << """
<ivy-module version="1.0">
    <not-an-ivy-file/>
</ivy-module>
"""

        when:
        parse(parseContext, file)

        then:
        def e = thrown(MetaDataParseException)
        e.message == "Could not parse Ivy file ${file}"
        e.cause.message.contains('Not a valid Ivy file')
    }

        module.jar.sha256.expectPut()
        module.jar.sha512.expectPut()

        module.ivy.expectPutBroken()
        module.ivy.expectPut(HttpStatus.CREATED_201)
        module.ivy.sha1.expectPut(HttpStatus.CREATED_201)
        module.ivy.sha256.expectPut(HttpStatus.CREATED_201)
        module.ivy.sha512.expectPut(HttpStatus.CREATED_201)

        module.moduleMetadata.expectPutBroken()

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

        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'

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