if (result.getModelIds().isEmpty()) {
            DefaultModelBuildingResult tmp = new DefaultModelBuildingResult();
            tmp.setEffectiveModel(result.getEffectiveModel());
            tmp.setProblems(getProblems());
            tmp.setActiveExternalProfiles(result.getActiveExternalProfiles());
            String id = getRootModelId();
            tmp.addModelId(id);
            tmp.setRawModel(id, getRootModel());

        ToolchainsBuildingResult result = toolchainBuilder.build(request);
        assertNotNull(result.getEffectiveToolchains());
        assertNotNull(result.getProblems());
        assertEquals(0, result.getProblems().size());
    }

    @Test
    void testBuildRequestWithUserToolchains() throws Exception {
        Properties props = new Properties();
        props.put("key", "user_value");

/**
 * Signals one or more errors during settings building. The settings builder tries to collect as many problems as
 * possible before eventually failing to provide callers with rich error information. Use {@link #getProblems()} to
 * query the details of the failure.
 *
 * @deprecated since 4.0.0, use {@link org.apache.maven.api.services.SettingsBuilder} instead
 */
@Deprecated(since = "4.0.0")

    public static <T> Result<T> error(Result<?> result) {
        return error(result.getProblems());
    }

    public static <T> Result<T> error(Result<?>... results) {
        final List<ModelProblem> problemsList = new ArrayList<>();

        for (Result<?> result1 : results) {
            for (ModelProblem modelProblem : result1.getProblems()) {
                problemsList.add(modelProblem);
            }
        }

        problems.setSource("");

        userToolchains = interpolate(userToolchains, problems);

        if (hasErrors(problems.getProblems())) {
            throw new ToolchainsBuildingException(problems.getProblems());
        }

        return new DefaultToolchainsBuildingResult(userToolchains, problems.getProblems());
    }

    private PersistedToolchains interpolate(PersistedToolchains toolchains, ProblemCollector problems) {

/**
 * Defines events that the model builder fires during construction of the effective model. When a listener encounters
 * errors while processing the event, it can report these problems via {@link ModelBuildingEvent#getProblems()}.
 * Note: To cope with future extensions to this interface, it is strongly recommended to extend
 * {@link AbstractModelBuildingListener} rather than to directly implement this interface.
 *

                }

                @Nonnull
                @Override
                public Collection<BuilderProblem> getProblems() {
                    return new MappedCollection<>(res.getProblems(), this::toProblem);
                }

                private BuilderProblem toProblem(ModelProblem problem) {
                    return new BuilderProblem() {

            }
        }

        if (hasErrors(problems.getProblems())) {
            throw new SettingsBuildingException(problems.getProblems());
        }

        return new DefaultSettingsBuildingResult(userSettings, problems.getProblems());
    }

    private boolean hasErrors(List<SettingsProblem> problems) {
        if (problems != null) {

     */
    PersistedToolchains getEffectiveToolchains();

    /**
     * Return a list of problems, if any.
     *
     * @return a list of problems, never {@code null}.
     */
    List<Problem> getProblems();

    public Model getModel() {
        return model;
    }

    @Override
    public ModelBuildingRequest getRequest() {
        return request;
    }

    @Override
    public ModelProblemCollector getProblems() {
        return problems;
    }