given:
        store.add(artifact1)
        store.add(artifact2)
        _ * artifact1.file >> file1
        _ * artifact2.file >> file2

        expect:
        set.files.files == [file1, file2] as Set
    }

    def "files are built by the union of the tasks that build the publish artifacts"() {
        PublishArtifact artifact1 = Mock()
        PublishArtifact artifact2 = Mock()
        Task task1 = Mock()

        Artifact artifact2 = mock(Artifact.class);
        when(artifact2.getFile()).thenReturn(null);
        when(artifact2.getGroupId()).thenReturn("group1");
        when(artifact2.getArtifactId()).thenReturn("artifact2");
        when(artifact2.getExtension()).thenReturn("ext");
        when(artifact2.getClassifier()).thenReturn("classifier1");
        when(artifact2.getVersion()).thenReturn("1");
        artifacts.add(artifact2);

import org.gradle.api.Action
import org.gradle.api.XmlProvider
import org.gradle.api.artifacts.repositories.IvyArtifactRepository
import org.gradle.api.internal.artifacts.DefaultImmutableModuleIdentifierFactory
import org.gradle.api.internal.artifacts.DefaultModuleVersionIdentifier
import org.gradle.api.internal.artifacts.DependencyManagementTestUtil
import org.gradle.api.internal.artifacts.repositories.metadata.IvyMutableModuleMetadataFactory

        Artifact artifact = new DefaultArtifact(
                groupId, artifactId, VersionRange.createFromVersion("5.0"), scope, type, classifier, artifactHandler);
        assertTrue(artifact.compareTo(artifact1) == 0);
        assertTrue(artifact1.compareTo(artifact) == 0);
    }

    @Test
    void testNonResolvedVersionRangeConsistentlyYieldsNullVersions() throws Exception {

            if (diff != 0) {
                return diff;
            }
            diff = artifact1.getType().compareTo(artifact2.getType());
            if (diff != 0) {
                return diff;
            }
            // Use an arbitrary ordering when the artifacts have the same public attributes
            return Integer.compare(artifact1.hashCode(), artifact2.hashCode());

    }

    def "writes dependency with artifacts"() {
        def artifact1 = Mock(DependencyArtifact)
        def artifact2 = Mock(DependencyArtifact)

        when:
        artifact1.name >> "artifact-1"
        artifact1.type >> "type-1"
        artifact1.extension >> "ext-1"
        artifact1.classifier >> null
        artifact2.name >> "artifact-2"
        artifact2.type >> null

        child.artifacts == variantDef.artifacts
    }

    def "converts to OutgoingVariant when explicit variant and artifacts defined"() {
        def artifact1 = Stub(PublishArtifact)
        def artifact2 = Stub(PublishArtifact)

        given:
        publications.artifacts.add(artifact1)
        publications.attributes.attribute(Attribute.of("thing", String), "value1")

        given:
        def publication = createPublication()
        def artifact1 = Mock(PublishArtifact)
        artifact1.file >> artifactFile
        artifact1.classifier >> ""
        artifact1.extension >> "jar"
        def artifact2 = Mock(PublishArtifact)
        artifact2.file >> artifactFile
        artifact2.classifier >> ""
        artifact2.extension >> "jar"

    }

    /**
     * The groupId of the artifact.
     *
     * @return the groupId
     */
    @Nonnull
    String getGroupId();

    /**
     * The artifactId of the artifact.
     *
     * @return the artifactId
     */
    @Nonnull
    String getArtifactId();

    /**
     * The version of the artifact.
     *
     * @return the version
     */
    @Nonnull

        "group-₦ガき∆"        | "artifact"            | "version"   | "groupId (group-₦ガき∆) is not a valid Maven identifier ([A-Za-z0-9_\\-.]+)"
        "group"             | "artifact with spaces" | "version"   | "artifactId (artifact with spaces) is not a valid Maven identifier ([A-Za-z0-9_\\-.]+)"
        "group"             | "artifact-₦ガき∆"       | "version"   | "artifactId (artifact-₦ガき∆) is not a valid Maven identifier ([A-Za-z0-9_\\-.]+)"