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

        try {
            List<ArtifactRepository> repositories = session.toArtifactRepositories(
                    request.getRepositories() != null ? request.getRepositories() : session.getRemoteRepositories());
            ProjectBuildingRequest req = new DefaultProjectBuildingRequest()
                    .setRepositorySession(session.getSession())

        shallowMergeById(dominant.getProfiles(), recessive.getProfiles(), recessiveSourceLevel);
        shallowMergeById(dominant.getRepositories(), recessive.getRepositories(), recessiveSourceLevel);
        shallowMergeById(dominant.getPluginRepositories(), recessive.getPluginRepositories(), recessiveSourceLevel);
    }

    /**
     * @param dominant

        //   </mirror>
        // </mirrors>

        for (Mirror mirror : settings.getMirrors()) {
            request.addMirror(mirror);
        }

        for (Repository remoteRepository : settings.getRepositories()) {
            try {
                request.addRemoteRepository(MavenRepositorySystem.buildArtifactRepository(remoteRepository));
            } catch (InvalidRepositoryException e) {

                && profile.getModules().isEmpty()
                && profile.getSubprojects().isEmpty()
                && profile.getProperties().isEmpty()
                && profile.getRepositories().isEmpty()
                && profile.getPluginRepositories().isEmpty()
                && profile.getReporting() == null;
    }

    @Nonnull
    Optional<Source> getSource();

    boolean isAllowStubModel();

    boolean isRecursive();

    boolean isProcessPlugins();

    @Nullable
    List<RemoteRepository> getRepositories();

    @Nonnull
    static ProjectBuilderRequest build(@Nonnull Session session, @Nonnull Source source) {
        return builder()
                .session(nonNull(session, "session cannot be null"))

     * User properties
     */
    @Nonnull
    Map<String, String> getUserProperties();

    @Nonnull
    RepositoryMerging getRepositoryMerging();

    @Nullable
    List<RemoteRepository> getRepositories();

    @Nullable
    ModelTransformer getLifecycleBindingsInjector();

    @Nonnull
    static ModelBuilderRequest build(@Nonnull ModelBuilderRequest request, @Nonnull ModelSource source) {

        assertProblemFree(collector);

        assertEquals(
                "file://localhost/myBasedir/temp-repo", (out.getRepositories().get(0)).getUrl());
    }

    @Test
    public void testBaseUri() throws Exception {
        Model model = Model.newBuilder()
                .version("3.8.1")
                .artifactId("foo")

            Repository repository = new Repository();
            repository.setId(REPO_ID);
            repository.setUrl(REPO_URL);
            repository.setLayout(REPO_LAYOUT);
            m.getRepositories().add(repository);
            return m;
        }
        return null;
    }

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