artifact source: "customFile.txt", classifier: "output"
                    artifact source: customFileTask.outputFile, extension: "htm", classifier: "documentation", builtBy: customFileTask
                    artifact source: regularFileTask.outputFile, extension: "txt", classifier: "regular"
                    artifact source: customJar, extension: "war", classifier: null
                }
            }
""")

                noComponentPublished()
            }
        }
    }

    def "can publish artifact with classifier"() {
        given:
        createBuildScripts("""
            publications {
                ivy(IvyPublication) {
                    artifact source: customJar, classifier: "classy"
                }
            }
""")
        when:
        succeeds 'publish'

        then:

        VersionRequest requestB = new VersionRequest();
        requestB.addRepository(newTestRepository());
        Artifact artifactB =
                new DefaultArtifact("org.apache.maven.its", "dep-mng5324", "classifierB", "jar", "07.20.3-SNAPSHOT");
        requestB.setArtifact(artifactB);

        VersionResult resultB = versionResolver.resolveVersion(session, requestB);

            sb.append(" -Dversion=");
            sb.append(version);

            // insert classifier only if it was used in the artifact
            if (classifier != null && !classifier.equals("")) {
                sb.append(" -Dclassifier=");
                sb.append(classifier);
            }
            sb.append(" -Dpackaging=");
            sb.append(type);

     * If a Maven consumer wants to use that artifact, it has no choice but using <classifier>,
     * so if a Gradle consumer depends on that Maven published library, we want to make sure we
     * can match this classified dependency to a proper variant.
     */
    def "reasonable behavior when a Maven library uses a classifier to select a Gradle variant"() {

        where:
        extension | classifier     | message
        null      | "classifier"   | "extension cannot be null"
        "ext"     | ""             | "classifier cannot be an empty string. Use null instead"
        "ex\r"    | "classifier"   | "extension cannot contain ISO control character '\\u000d'"
        "ex/"     | "classifier"   | "extension cannot contain '/'"

    }

    @Issue("gradle/gradle#11825")
    def "dependency on different classifiers of a given module"() {
        given:
        repository {
            'org:foo:1.0' {
                dependsOn(group: 'org', artifact:'bar', version:'1.0', classifier:'classy')
                dependsOn(group: 'org', artifact:'bar', version:'1.0', classifier:'other')
            }
            'org:bar:1.0' {
                withModule {

        println "names: " + configurations.compile.resolvedConfiguration.resolvedArtifacts.collect { "\$it.name:\$it.extension:\$it.type" }
        println "classifiers: " + configurations.compile.resolvedConfiguration.resolvedArtifacts.collect { it.classifier }
    }
}
"""

        when:
        m1.ivy.expectGet()

     *
     * @param type the type of the artifact being queried
     * @param extension the extension, defaults to the type
     * @param classifier the classifier, defaults to null (no classifier)
     */
    void selectArtifact(String type, @Nullable String extension, @Nullable String classifier);

    /**
     * Adds an artifact to substitute.
     *
     * This method is a convenience to re-register artifacts requested by the original

        where:
        name    | type    | extension | classifier   | message
        null    | "type"  | "ext"     | "classifier" | "name cannot be null"
        ""      | "type"  | "ext"     | "classifier" | "name cannot be empty"
        "na/me" | "type"  | "ext"     | null         | "name cannot contain '/'"
        "name"  | null    | "ext"     | "classifier" | "type cannot be null"