Model parent = Model.newBuilder().artifactId("PARENT").build();
        Model model = Model.newInstance();
        Model.Builder builder = Model.newBuilder(model);
        modelMerger.mergeModel_ArtifactId(builder, model, parent, false, null);
        assertNull(model.getArtifactId());

        model = Model.newBuilder().artifactId("MODEL").build();
        builder = Model.newBuilder(model);

        Model.Builder builder = Model.newBuilder(model);

        builder.dependencies(injectList(model.getDependencies(), this::injectDependency));
        Build build = model.getBuild();
        if (build != null) {
            Build newBuild = Build.newBuilder(build)
                    .plugins(injectList(build.getPlugins(), this::injectPlugin))

        Profile.Builder profile = Profile.newBuilder();

        profile.id(modelProfile.getId());

        org.apache.maven.api.model.Activation modelActivation = modelProfile.getActivation();

        if (modelActivation != null) {
            Activation.Builder activation = Activation.newBuilder();

            activation.activeByDefault(modelActivation.isActiveByDefault());

    }

    @Test
    void testResolveParentThrowsModelResolverExceptionWhenNotFound() throws Exception {
        final Parent parent = Parent.newBuilder()
                .groupId("org.apache")
                .artifactId("apache")
                .version("0")
                .build();

        ModelResolverException e = assertThrows(

    }

    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()) {

class SettingsUtilsTest {

    @Test
    void testShouldAppendRecessivePluginGroupIds() {
        Settings dominant = Settings.newBuilder()
                .pluginGroups(Arrays.asList("org.apache.maven.plugins", "org.codehaus.modello"))
                .build();

        Settings recessive = Settings.newBuilder()
                .pluginGroups(Arrays.asList("org.codehaus.plexus"))
                .build();

        this.pluginInfo = pluginInfo;
    }

    private static Metadata createRepositoryMetadata(PluginInfo pluginInfo) {
        return Metadata.newBuilder()
                .plugins(List.of(Plugin.newBuilder()
                        .prefix(pluginInfo.goalPrefix)
                        .artifactId(pluginInfo.artifactId)
                        .name(pluginInfo.name)
                        .build()))

                && effective.getPluginRepositories().isEmpty()) {
            Repository central = Repository.newBuilder()
                    .id("central")
                    .name("Central Repository")
                    .url("https://repo.maven.apache.org/maven2")
                    .snapshots(RepositoryPolicy.newBuilder().enabled(false).build())
                    .build();
            Repository centralWithNoUpdate = central.withReleases(

    void testValidate() {
        Profile prof = Profile.newBuilder().id("xxx").build();
        Settings model = Settings.newBuilder().profiles(List.of(prof)).build();
        List<BuilderProblem> problems = validator.validate(model);
        assertEquals(0, problems.size());

        Repository repo = org.apache.maven.api.settings.Repository.newInstance(false);
        Settings model2 = Settings.newBuilder()

                    .map(p -> prune(Profile.newBuilder(p, true), p).build())
                    .collect(Collectors.toList()));

            model = builder.build();
            String modelVersion = new MavenModelVersion().getModelVersion(model);
            model = model.withModelVersion(modelVersion);
        } else {
            Model.Builder builder = prune(
                    Model.newBuilder(model, true)