child.publish()

        buildFile << """
repositories {
    maven { url '${mavenRepo.uri}' }
}
configurations { compile }
dependencies { compile 'org:child:1.0' }
task libs { doLast { assert configurations.compile.files*.name == ['child-1.0.jar', 'child_dep-1.7.jar', 'typed_dep-1.8.bar', 'classified_dep-1.9-classy.jar', 'fq_dep-2.1-classy.bar'] } }
"""

        expect:
        succeeds 'libs'

                    sha512: getChecksum(foo, "sha512", "pom")
                )
            }
            artifact("foo-1.0-classy.jar") {
                declaresChecksums(
                    sha1: getChecksum(foo, "sha1", "jar", "classy"),
                    sha512: getChecksum(foo, "sha512", "jar", "classy")
                )
            }
            artifact("foo-1.0.zip") {
                declaresChecksums(

dependencies {
    compile 'group:projectA:1.2@jar'
    compile 'group:projectB:1.2:classy@jar'
}
task retrieve(type: Sync) {
    into 'libs'
    from configurations.compile
}
"""

        when:
        projectA.pom.expectGet()
        projectA.artifact.expectGet()
        projectB.pom.expectGet()
        projectB.artifact(classifier: 'classy').expectGet()

        then:
        succeeds('retrieve')

                classpath = files()
            }
            dependencies {
                implementation "org:foo:1.0"
                implementation "org:foo:1.0:classy"
            }

            publishing {
                repositories {
                    maven { url "${mavenRepo.uri}" }
                }
                publications {

                    artifact source: customJar, classifier: "classy"
                }
            }
""")
        when:
        succeeds 'publish'

        then:
        module.assertPublished()
        module.assertArtifactsPublished("ivy-2.4.xml", "ivyPublish-2.4-classy.jar")
        module.parsedIvy.expectArtifact("ivyPublish").hasAttributes("jar", "jar", null, "classy")

        and:
        resolveArtifacts(module)  {

        coordinates1.revision.set("rev")
        def artifact1 = new FileBasedIvyArtifact(new File("foo.txt"), coordinates1, DefaultTaskDependencyFactory.withNoAssociatedProject())
        artifact1.classifier = "classy"

        def coordinates2 = TestUtil.objectFactory().newInstance(IvyPublicationCoordinates)
        coordinates2.organisation.set("")
        coordinates2.module.set("")
        coordinates2.revision.set("")

                dependsOn group: 'org.test', artifact: 'projectB', version: '1.0', 'classifier': 'classy'
            }
            'org.test:projectB:1.0' {
                withModule {
                    undeclaredArtifact(type: 'jar', classifier: 'classy')
                }
            }
        }
        buildFile << """

class AssertingRule implements ComponentMetadataRule {

    void execute(ComponentMetadataContext context) {

      <component group="org" name="bar" version="1.2">
         <artifact name="bar-1.2.jar">
            <sha1 value="9876"/>
            <sha512 value="123def"/>
         </artifact>
         <artifact name="bar-1.2-classy.jar">
            <sha512 value="5678abcd"/>
         </artifact>
      </component>
      <component group="org" name="baz" version="1.4">
         <artifact name="baz-1.4.jar">

        given:
        declareChecksum("org:foo:1.0", "sha1", "abc")
        declareChecksumOfArtifact("org", "foo", "1.0", "zip", "zip", null, "sha256", "def")
        declareChecksumOfArtifact("org", "foo", "1.0", "jar", "jar", "classy", "sha1", "123")

        when:
        serialize()

        then:
        contents == """<?xml version="1.0" encoding="UTF-8"?>
<verification-metadata>
   <configuration>

        """
    }

    def "can attach an archive task provider as an artifact"() {
        createBuildScripts("""
            def customJar = tasks.register("myJar", Jar) {
                archiveClassifier = 'classy'
            }
            publications {
                mavenCustom(MavenPublication) {
                    artifact(customJar)
                }
            }
        """)

        when: