return artifactId;
    }

    public void setArtifactId(String artifactId) {
        this.artifactId = artifactId;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }

    public String getClassifier() {
        return classifier;
    }

            replacementTokens.put("releaseDate", dateTime);
            replacementTokens.put("version", moduleIdentity.getVersion().map(GradleVersion::getVersion));
            replacementTokens.put("baseVersion", moduleIdentity.getVersion().map(v -> v.getBaseVersion().getVersion()));

            task.getDestinationFile().convention(extension.getStagingRoot().file("release-notes/release-notes.html"));
        });

    @Test
    void testDefaultPolicy() throws Exception {
        MetadataGraphEdge res;

        res = policy.apply(e1, e2);
        assertEquals("1.1", res.getVersion(), "Wrong depth edge selected");

        res = policy.apply(e1, e3);
        assertEquals("1.2", res.getVersion(), "Wrong version edge selected");
    }
    // ------------------------------------------------------------------------------------------

        return Objects.equals(a1.getGroupId(), a2.getGroupId())
                && Objects.equals(a1.getArtifactId(), a2.getArtifactId())
                && Objects.equals(a1.getVersion(), a2.getVersion());
    }

    private Properties toProperties(Map<String, String> dominant, Map<String, String> recessive) {
        Properties props = new Properties();
        if (recessive != null) {

     */
    @Nonnull
    Version getVersion();

    /**
     * {@return the version or meta-version of the artifact}.
     * A meta-version is a version suffixed with the {@code SNAPSHOT} keyword.
     * Meta-versions are represented in a base version by their symbols (e.g., {@code SNAPSHOT}),
     * while they are replaced by, for example, the actual timestamp in the {@linkplain #getVersion() version}.
     */
    @Nonnull

        result = 31 * result + a.getGroupId().hashCode();
        result = 31 * result + a.getArtifactId().hashCode();
        result = 31 * result + a.getType().hashCode();
        if (a.getVersion() != null) {
            result = 31 * result + a.getVersion().hashCode();
        }
        result = 31 * result + (a.getClassifier() != null ? a.getClassifier().hashCode() : 0);

        if (since instanceof SinceTagStatus.Present present) {
            if (present.getVersion().equals(getCurrentVersion())){
                return null;
            } else {
                return acceptOrReject(member, Violation.error(member, String.format(SINCE_MISMATCH_ERROR_MESSAGE, getCurrentVersion(), present.getVersion())));
            }
        } else if (since instanceof SinceTagStatus.Inconsistent inconsistent) {

        Artifact artifact = new DefaultArtifact(
                dependency.getGroupId(),
                dependency.getArtifactId(),
                dependency.getVersion(),
                dependency.getScope(),
                dependency.getType(),
                dependency.getClassifier(),
                new TestArtifactHandler(dependency.getType()));

        MavenSession session = legacySupport.getSession();

        if (plugin.getVersion() == null) {
            PluginVersionRequest versionRequest = new DefaultPluginVersionRequest(
                    plugin, session.getRepositorySession(), project.getRemotePluginRepositories());
            plugin.setVersion(pluginVersionResolver.resolve(versionRequest).getVersion());
        }

        try {

                    model.setArtifactId(intArtifactId);
                }
                // Version
                String orgVersion = model.getVersion();
                String intVersion = interpolate(orgVersion);
                if (orgVersion != intVersion) {
                    model.setVersion(intVersion);
                }

                // Packaging
                String orgPackaging = model.getPackaging();