if (ivyArtifactName == null) {
            ArtifactFile names = new ArtifactFile(relativeUrl, uniqueVersion());
            ivyArtifactName = new DefaultIvyArtifactName(names.getName(), names.getExtension(), names.getExtension(), names.getClassifier());
        }
        return ivyArtifactName;
    }

    @Override
    public TaskDependency getBuildDependencies() {
        return TaskDependencyInternal.EMPTY;
    }

            return classifier;
        } else {
            return artifact.getClassifier();
        }
    }

    @Override
    public String getExtension() {
        if (extension != null) {
            return extension;
        } else {
            return artifact.getExtension();
        }
    }

    @Override
    public String getVersion() {
        if (version != null) {
            return version;

    @Nonnull
    Session getSession();

    String getGroupId();

    String getArtifactId();

    String getVersion();

    String getClassifier();

    String getExtension();

    String getType();

    static ArtifactFactoryRequest build(
            Session session, String groupId, String artifactId, String version, String extension) {
        return ArtifactFactoryRequest.builder()

    }

    /**
     * @throws Exception
     */
    public void testGetExtension() throws Exception {
        assertEquals("1", "xml", ResourceUtil.getExtension("aaa/bbb.xml"));
        assertEquals("2", null, ResourceUtil.getExtension("aaa"));
    }

    /**
     * @throws Exception
     */
    public void testRemoteExtension() throws Exception {

        path.append(artifact.getExtension()).append("s/");

        path.append(artifact.getArtifactId()).append('-').append(artifact.getVersion());

        if (!artifact.getClassifier().isEmpty()) {
            path.append('-').append(artifact.getClassifier());
        }

        path.append('.').append(artifact.getExtension());

        return path.toString();
    }

        attributes.put(PatternHelper.ARTIFACT_KEY, ivyArtifact.getName());
        attributes.put(PatternHelper.TYPE_KEY, ivyArtifact.getType());
        attributes.put(PatternHelper.EXT_KEY, ivyArtifact.getExtension());
        attributes.put(CLASSIFIER_KEY, ivyArtifact.getClassifier());
        return attributes;
    }

    protected Map<String, String> toAttributes(ModuleIdentifier module) {

                .artifactId(coordinate.getArtifactId())
                .version(coordinate.getVersion().asString())
                .classifier(coordinate.getClassifier())
                .extension(coordinate.getExtension())
                .build();
    }

    @Nonnull
    static DependencyCoordinateFactoryRequest build(@Nonnull Session session, @Nonnull Dependency dependency) {
        return builder()

            field(publication, "artifact type", artifact.getType())
                    .notEmpty().validInFileName();
            field(publication, "artifact extension", artifact.getExtension())
                    .notNull().validInFileName();
            field(publication, "artifact classifier", artifact.getClassifier())
                    .optionalNotEmpty().validInFileName();

                return session.parseVersionConstraint(dependency.getVersion());
            }

            @Override
            public String getExtension() {
                return getType().getExtension();
            }

            @Override
            public Type getType() {
                String type = dependency.getType();
                return session.requireType(type);

        }
        String classifier = GUtil.elvis(publishArtifact.getClassifier(), null);
        return new DefaultIvyArtifactName(name, publishArtifact.getType(), publishArtifact.getExtension(), classifier);
    }

    public static DefaultIvyArtifactName forFile(File file, @Nullable String classifier) {
        String fileName = file.getName();
        return forFileName(fileName, classifier);
    }