Settings s = Settings.newInstance();

        s = s.withLocalRepository("xxx");
        assertEquals("xxx", s.getLocalRepository());

        s = s.withLocalRepository("yyy");
        assertEquals("yyy", s.getLocalRepository());

        s = s.withLocalRepository(null);
        assertNull(s.getLocalRepository());
    }

     * @param repositoryRequest The repository request to copy from, must not be {@code null}.
     */
    public DefaultRepositoryRequest(RepositoryRequest repositoryRequest) {
        setLocalRepository(repositoryRequest.getLocalRepository());
        setRemoteRepositories(repositoryRequest.getRemoteRepositories());
        setOffline(repositoryRequest.isOffline());
        setForceUpdate(repositoryRequest.isForceUpdate());
    }

        configuration.setLocalRepository(getLocalRepository());
        initRepoSession(configuration);

        return projectBuilder.build(pom, configuration).getProject();
    }

    protected void initRepoSession(ProjectBuildingRequest request) throws Exception {
        File localRepo = new File(request.getLocalRepository().getBasedir());

                    dominantPluginGroupIds.add(pluginGroupId);
                }
            }
        }

        if (dominant.getLocalRepository() == null
                || dominant.getLocalRepository().isEmpty()) {
            dominant.setLocalRepository(recessive.getLocalRepository());
        }

        shallowMergeById(dominant.getMirrors(), recessive.getMirrors(), recessiveSourceLevel);

    }

    public DefaultMetadataResolutionRequest setArtifact(Artifact artifact) {
        this.artifact = artifact;

        return this;
    }

    public ArtifactRepository getLocalRepository() {
        return repositoryRequest.getLocalRepository();
    }

    public DefaultMetadataResolutionRequest setLocalRepository(ArtifactRepository localRepository) {
        repositoryRequest.setLocalRepository(localRepository);

                .setRemoteRepositories(getRemoteRepositories())
                .setLocalRepository(getLocalRepository());

        DefaultRepositorySystemSession session = new DefaultRepositorySystemSession();
        LocalRepository localRepo =
                new LocalRepository(request.getLocalRepository().getBasedir());

                .setPom(pom)
                .setProjectPresent(true)
                .setShowErrors(true)
                .setPluginGroups(Arrays.asList("org.apache.maven.plugins"))
                .setLocalRepository(getLocalRepository())
                .setRemoteRepositories(getRemoteRepositories())
                .setPluginArtifactRepositories(getPluginArtifactRepositories())
                .setGoals(Arrays.asList("package"));

        if (request.getLocalRepository() == null) {
            request.setLocalRepository(createLocalRepository(request));
        }

        if (request.getLocalRepositoryPath() == null) {
            request.setLocalRepositoryPath(new File(request.getLocalRepository().getBasedir()).getAbsoluteFile());
        }
    }

        return retrieve(request.getArtifact(), request.getLocalRepository(), request.getRemoteRepositories());
    }

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

                        request.getArtifact().getVersion());
                File pomFile = new File(
                        request.getLocalRepository().getBasedir(),
                        request.getLocalRepository().pathOf(pomArtifact));

                try {
                    Model model = modelReader.read(pomFile, null).getDelegate();