import org.apache.maven.model.version.ModelVersionParser;

import static org.apache.maven.internal.impl.Utils.nonNull;

/**
 * A wrapper class around a resolver version that works as model version parser as well.
 */
@Named
@Singleton
public class DefaultVersionParser implements VersionParser {
    private final ModelVersionParser modelVersionParser;

    @Inject

     *
     * @param remoteRepository the repository
     */
    void setRepository(ArtifactRepository remoteRepository);

    /**
     * Get the repository metadata associated with this marker.
     *
     * @return the metadata, or <code>null</code> if none loaded
     */
    Metadata getMetadata();

    /**
     * Set the metadata contents.
     *
     * @param metadata the metadata
     */

     *
     * @param dir the directory to locate the pom for, never {@code null}
     * @return a {@code Source} pointing to the located pom or an empty {@code Optional} if none was found by this parser
     */
    @Nonnull
    Optional<Source> locate(@Nonnull Path dir);

    /**
     * Parse the model obtained previously by a previous call to {@link #locate(Path)}.
     *

    protected File getLocalRepositoryPath() throws FileNotFoundException, URISyntaxException {
        File markerFile = getFileForClasspathResource("local-repo/marker.txt");

        return markerFile.getAbsoluteFile().getParentFile();
    }

    protected static File getFileForClasspathResource(String resource)
            throws FileNotFoundException, URISyntaxException {

        // -------------------------------------------------------------------------------------
        // Alright, here's the justification for all the regexp wizardry below...
        //
        // Continuum and other server-like apps may need to locate the user-level and
        // global-level settings somewhere other than ${user.home} and ${maven.home},
        // respectively. Using a simple replacement of these patterns will allow them

        assertEquals(basedir, new File(repo.getBasedir()));
    }

    @Test
    void testAuthenticationHandling() {
        Server server = new Server();
        server.setId("repository");
        server.setUsername("jason");
        server.setPassword("abc123");

        ArtifactRepository repository =
                repositorySystem.createArtifactRepository("repository", "http://foo", null, null, null);

        for (Server server : decrypted.getServers()) {
            AuthenticationBuilder authBuilder = new AuthenticationBuilder();
            authBuilder.addUsername(server.getUsername()).addPassword(server.getPassword());
            authBuilder.addPrivateKey(server.getPrivateKey(), server.getPassphrase());
            authSelector.add(server.getId(), authBuilder.build());

    }

    @Override
    public MavenExecutionRequest addServer(Server server) {
        Objects.requireNonNull(server, "server cannot be null");

        for (Server p : getServers()) {
            if (p.getId() != null && p.getId().equals(server.getId())) {
                return this;
            }
        }

        getServers().add(server);

        return this;
    }

    @Override

    MavenExecutionRequest setProxies(List<Proxy> proxies);

    MavenExecutionRequest addProxy(Proxy proxy);

    // Servers
    List<Server> getServers();

    MavenExecutionRequest setServers(List<Server> servers);

    MavenExecutionRequest addServer(Server server);

    // Mirrors
    List<Mirror> getMirrors();

    MavenExecutionRequest setMirrors(List<Mirror> mirrors);

 * prior notice.
 *
 */
public interface PluginArtifactsCache {

    /**
     * A cache key.
     */
    interface Key {
        // marker interface for cache keys
    }

    /**
     * CacheRecord
     */
    class CacheRecord {

        private final List<Artifact> artifacts;

        public List<Artifact> getArtifacts() {