// Here, we need to determine which policy to use. Release updateInterval will be used when
        // the metadata refers to a release artifact or meta-version, and snapshot updateInterval will be used when
        // it refers to a snapshot artifact or meta-version.
        // NOTE: Release metadata includes version information about artifacts that have been released, to allow

            ArtifactRepository localRepository)
            throws RepositoryMetadataStoreException {
        // TODO this could be a lot nicer... should really be in the snapshot transformation?
        if (metadata.isSnapshot()) {
            Metadata prevMetadata = metadata.getMetadata();

            for (ArtifactRepository repository : previousMetadata.keySet()) {

     */
    @Nonnull
    String getExtension();

    /**
     * Determines whether this artifact uses a snapshot version.
     *
     * @return {@code true} if the artifact is a snapshot, {@code false} otherwise
     * @see org.apache.maven.api.Session#isVersionSnapshot(String)
     */
    boolean isSnapshot();

    /**
     * {@return coordinates with the same identifiers as this artifact}.

        this.groupId = groupId;
    }

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

    @Override
    public boolean isSnapshot() {
        return getBaseVersion() != null
                && (getBaseVersion().endsWith(SNAPSHOT_VERSION)
                        || getBaseVersion().equals(LATEST_VERSION));
    }

    @Override

import java.util.Map;
import java.util.regex.Matcher;

import org.apache.maven.artifact.versioning.VersionRange;

/**
 * ArtifactUtils
 */
public final class ArtifactUtils {

    public static boolean isSnapshot(String version) {
        if (version != null) {
            if (version.regionMatches(
                    true,
                    version.length() - Artifact.SNAPSHOT_VERSION.length(),

    /**
     * Checks whether a given artifact version is considered a {@code SNAPSHOT} or not.
     * <p>
     * Shortcut for {@code getService(ArtifactManager.class).isSnapshot(...)}.
     * <p>
     * In case there is {@link Artifact} in scope, the recommended way to perform this check is
     * use of {@link Artifact#isSnapshot()} instead.
     *
     * @param version artifact version

        ArtifactRepositoryPolicy policy = artifact.isSnapshot() ? repository.getSnapshots() : repository.getReleases();

        if (!policy.isEnabled()) {
            logger.debug(
                    "Skipping disabled repository " + repository.getId() + " for resolution of " + artifact.getId());

        } else if (artifact.isSnapshot() || !artifact.getFile().exists()) {

            if (artifact.isSnapshot()) {
                Matcher matcher = Artifact.VERSION_FILE_PATTERN.matcher(artifact.getVersion());
                if (matcher.matches()) {
                    Snapshot snapshot = new Snapshot();
                    snapshot.setTimestamp(matcher.group(2));
                    try {
                        snapshot.setBuildNumber(Integer.parseInt(matcher.group(3)));

        }

        return pluginArtifactRepositories;
    }

    @Deprecated
    public ArtifactRepository getDistributionManagementArtifactRepository() {
        return getArtifact().isSnapshot() && (getSnapshotArtifactRepository() != null)
                ? getSnapshotArtifactRepository()
                : getReleaseArtifactRepository();
    }

    public List<Repository> getPluginRepositories() {

    </dependency>
    <dependency>
      <groupId>snapshot-test</groupId>
      <artifactId>maven-snapshot-b</artifactId>
      <version>1.0-SNAPSHOT</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>snapshot-test</groupId>
      <artifactId>maven-snapshot-c</artifactId>
      <version>1.0-SNAPSHOT</version>
      <type>jar</type>
      <scope>compile</scope>