.collect(Collectors.toList()));
            model = builder.build();
            String modelVersion = new MavenModelVersion().getModelVersion(model);
            model = model.withModelVersion(modelVersion);
        }
        return model;
    }

    private static <T extends ModelBase.Builder> T prune(T builder, ModelBase model) {
        builder.properties(null).reporting(null);

                return xformed != path ? (builder != null ? builder : creator.get()).missing(xformed) : builder;
            }

            @Override
            protected ActivationFile.Builder transformActivationFile_Exists(
                    Supplier<? extends ActivationFile.Builder> creator,
                    ActivationFile.Builder builder,
                    ActivationFile target) {

     * be set on builder to make it able to create session instances.
     */
    @Override
    public SessionBuilder get() {
        requireNonNull(repositorySystem, "repositorySystem");
        SessionBuilder builder = repositorySystem.createSessionBuilder();
        configureSessionBuilder(builder);
        return builder;
    }

    <groupId>org.apache.maven</groupId>
    <artifactId>maven</artifactId>
    <version>4.0.0-beta-1-SNAPSHOT</version>
  </parent>

  <artifactId>maven-builder-support</artifactId>

  <name>Maven Builder Support</name>
  <description>Support for descriptor builders (model, setting, toolchains)</description>

  <dependencies>
    <dependency>
      <groupId>org.junit.jupiter</groupId>

        this.artifact = artifact;
    }

    private static Metadata createRepositoryMetadata(Artifact artifact) {

        Metadata.Builder metadata = Metadata.newBuilder();
        metadata.groupId(artifact.getGroupId());
        metadata.artifactId(artifact.getArtifactId());

        Versioning.Builder versioning = Versioning.newBuilder();
        versioning.versions(List.of(artifact.getBaseVersion()));
        if (!artifact.isSnapshot()) {

        return builder(nonNull(request, "request cannot be null"))
                .source(nonNull(source, "source cannot be null"))
                .build();
    }

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

        <artifactId>maven-artifact</artifactId>
        <version>${project.version}</version>
      </dependency>
      <dependency>
        <groupId>org.apache.maven</groupId>
        <artifactId>maven-builder-support</artifactId>
        <version>${project.version}</version>
      </dependency>
      <dependency>
        <groupId>org.apache.maven</groupId>
        <artifactId>maven-core</artifactId>

class TestApiStandalone {

    @Test
    void testStandalone() {
        Session session = ApiRunner.createSession();

        ModelBuilder builder = session.getService(ModelBuilder.class);
        ModelBuilderResult result = builder.build(ModelBuilderRequest.builder()
                .session(session)
                .source(ModelSource.fromPath(Paths.get("pom.xml").toAbsolutePath()))
                .projectBuild(true)

        private int getParallelism(ProjectBuildingRequest request) {
            int parallelism = DEFAULT_BUILDER_PARALLELISM;
            try {
                String str = request.getUserProperties().getProperty(BUILDER_PARALLELISM);
                if (str == null) {
                    str = request.getSystemProperties().getProperty(BUILDER_PARALLELISM);
                }
                if (str != null) {

                new DefaultLocalRepository(new LocalRepository("target/test-classes/apiv4-repo"));
        org.apache.maven.api.RemoteRepository remoteRepository = session.getRemoteRepository(
                new RemoteRepository.Builder("mirror", "default", "file:target/test-classes/repo").build());
        this.session = session.withLocalRepository(localRepository)
                .withRemoteRepositories(Collections.singletonList(remoteRepository));