if (artifactRequest != null && artifactRequest.getRepositories() != null) {
                    repositories.addAll(artifactRequest.getRepositories());
                } else if (artifactDescriptorRequest != null && artifactDescriptorRequest.getRepositories() != null) {
                    repositories.addAll(artifactDescriptorRequest.getRepositories());
                }
                if (!repositories.isEmpty()) {

                        RemoteRepository r = (RemoteRepository) result.getRepository();
                        subRequest.setRepositories(Collections.singletonList(r));
                    } else {
                        subRequest.setRepositories(request.getRepositories());
                    }
                    VersionResult subResult = resolveVersion(session, subRequest);

                        request.getPrefix(),
                        request.getPluginGroups(),
                        request.getRepositorySession().getLocalRepository(),
                        request.getRepositories());
            } else {
                logger.debug(
                        "Resolved plugin prefix {} to {}:{} from repository {}",
                        request.getPrefix(),

            Artifact pomArtifact = ArtifactDescriptorUtils.toPomArtifactUnconditionally(a);
            try {
                VersionRequest versionRequest =
                        new VersionRequest(a, request.getRepositories(), request.getRequestContext());
                versionRequest.setTrace(trace);
                VersionResult versionResult = versionResolver.resolveVersion(session, versionRequest);

        List<MetadataRequest> requests = new ArrayList<>();

        requests.add(new MetadataRequest(metadata, null, REPOSITORY_CONTEXT).setTrace(trace));

        for (RemoteRepository repository : request.getRepositories()) {
            requests.add(new MetadataRequest(metadata, repository, REPOSITORY_CONTEXT).setTrace(trace));
        }

                        .repositories(settings.getRepositories())
                        .pluginRepositories(settings.getPluginRepositories())
                        .build());
        RepositoryFactory repositoryFactory = session.getService(RepositoryFactory.class);
        List<RemoteRepository> repositories = profile.getRepositories().stream()
                .map(repositoryFactory::createRemote)

        assertEquals(p.getActivation().getPackaging(), clone.getActivation().getPackaging());
        assertEquals(p.getProperties(), clone.getProperties());
        assertEquals(p.getRepositories().size(), clone.getRepositories().size());
        // TODO deep compare the lists
        assertEquals(
                p.getPluginRepositories().size(), clone.getPluginRepositories().size());
        // TODO deep compare the lists

    PluginPrefixRequest setPom(Model pom);

    /**
     * Gets the remote repositories to use.
     *
     * @return The remote repositories to use, never {@code null}.
     */
    List<RemoteRepository> getRepositories();

    /**
     * Sets the remote repositories to use. Note: When creating a request from a project, be sure to use the
     * plugin repositories and not the regular project repositories.
     *

        List<MetadataRequest> metadataRequests =
                new ArrayList<>(request.getRepositories().size());

        metadataRequests.add(new MetadataRequest(metadata, null, request.getRequestContext()));

        for (RemoteRepository repository : request.getRepositories()) {
            MetadataRequest metadataRequest = new MetadataRequest(metadata, repository, request.getRequestContext());

    public DefaultPluginPrefixRequest setPom(Model pom) {
        this.pom = pom;

        return this;
    }

    public List<RemoteRepository> getRepositories() {
        return repositories;
    }

    public DefaultPluginPrefixRequest setRepositories(List<RemoteRepository> repositories) {
        if (repositories != null) {
            this.repositories = Collections.unmodifiableList(repositories);
        } else {