request.getArtifact(),
                    toList(result.getArtifacts()),
                    result.getMissingArtifacts(),
                    request.getRemoteRepositories());
        }

        // this should never happen since we checked all possible error sources before but better be sure
        if (result.hasExceptions()) {
            throw new ArtifactResolutionException(

        repositoryRequest.setLocalRepository(localRepository);

        return this;
    }

    @Override
    public List<ArtifactRepository> getRemoteRepositories() {
        return repositoryRequest.getRemoteRepositories();
    }

    @Override
    public DefaultMetadataResolutionRequest setRemoteRepositories(List<ArtifactRepository> remoteRepositories) {

     */
    public DefaultRepositoryRequest(RepositoryRequest repositoryRequest) {
        setLocalRepository(repositoryRequest.getLocalRepository());
        setRemoteRepositories(repositoryRequest.getRemoteRepositories());
        setOffline(repositoryRequest.isOffline());
        setForceUpdate(repositoryRequest.isForceUpdate());
    }

            AuthenticationSelector authenticationSelector) {
        injectMirror(mavenExecutionRequest.getRemoteRepositories(), mavenExecutionRequest.getMirrors());
        injectProxy(proxySelector, mavenExecutionRequest.getRemoteRepositories());
        injectAuthentication(authenticationSelector, mavenExecutionRequest.getRemoteRepositories());

    }

    @Override
    public List<ArtifactVersion> retrieveAvailableVersions(MetadataResolutionRequest request)
            throws ArtifactMetadataRetrievalException {
        return retrieveAvailableVersions(
                request.getArtifact(), request.getLocalRepository(), request.getRemoteRepositories());
    }

        return this;
    }

    /**
     * @deprecated instead use {@link #getRemoteRepositories()}
     */
    @Deprecated
    public List<ArtifactRepository> getRemoteRepostories() {
        return remoteRepositories;
    }

    public List<ArtifactRepository> getRemoteRepositories() {
        return getRemoteRepostories();
    }

    /**

 *   <li>Maintaining consistent repository ordering for reproducible builds</li>
 * </ul>
 *
 * @since 4.0.0
 * @see RemoteRepository
 * @see Session#getRemoteRepositories()
 */
@Experimental
@Immutable
public interface RepositoryAwareRequest extends Request<Session> {

    /**
     * Returns the list of remote repositories to be used for this request.
     *

    }

    @Override
    public ResolutionGroup retrieve(MetadataResolutionRequest request) throws ArtifactMetadataRetrievalException {
        return retrieve(request.getArtifact(), request.getLocalRepository(), request.getRemoteRepositories());
    }

                getContainer().lookup(RemoteRepositoryManager.class),
                this.getRemoteRepositories(),
                ProjectBuildingRequest.RepositoryMerging.REQUEST_DOMINANT,
                null);
    }

    private List<RemoteRepository> getRemoteRepositories() throws InvalidRepositoryException {
        final File repoDir = new File(getBasedir(), "src/test/remote-repo").getAbsoluteFile();

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

    /**
     * Sets the remote repositories to use.
     *
     * @param remoteRepositories The remote repositories to use.
     * @return This request, never {@code null}.
     */