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");

                getProblems(problem.getSeverity()).add(problem);
                return true;
            }
            return false;
        }

        @Override
        public Stream<P> problems(BuilderProblem.Severity severity) {
            requireNonNull(severity, "severity");
            return getProblems(severity).stream();
        }

        assertEquals(1, pex.getResults().size());
        assertNotNull(pex.getResults().get(0).getPomFile());
        assertTrue(pex.getResults().get(0).getProblems().size() > 0);
        ProjectBuildingResultWithProblemMessageAssert.assertThat(
                        pex.getResults().get(0))

        if (!settingsResult.getProblems().isEmpty() && LOGGER.isWarnEnabled()) {
            LOGGER.warn("");
            LOGGER.warn("Some problems were encountered while building the effective settings");

            for (SettingsProblem problem : settingsResult.getProblems()) {
                LOGGER.warn("{} @ {}", problem.getMessage(), problem.getLocation());
            }

                // that may lead to unexpected build failure, log them
                if (!modelResult.getProblems().isEmpty()) {
                    List<ModelProblem> problems = modelResult.getProblems();
                    if (logger.isDebugEnabled()) {
                        String problem = (problems.size() == 1) ? "problem" : "problems";

        context.eventSpyDispatcher.onEvent(toolchainsResult);

        context.effectiveToolchains = toolchainsResult.getEffectiveToolchains();

        if (toolchainsResult.getProblems().hasWarningProblems()) {
            int totalProblems = toolchainsResult.getProblems().totalProblemsReported();
            context.logger.info("");
            context.logger.info(String.format(

        Result<? extends ProjectDependencyGraph> graphResult = buildGraph(session);

        if (graphResult.hasErrors()) {
            return addExceptionToResult(
                    result, graphResult.getProblems().iterator().next().getException());
        }

        try {
            session.setProjectMap(getProjectMap(session.getProjects()));
        } catch (DuplicateProjectException e) {

    }

    private ExceptionSummary handle(ProjectBuildingResult result) {
        List<ExceptionSummary> children = new ArrayList<>();

        for (ModelProblem problem : result.getProblems()) {
            ExceptionSummary child = handle(problem, result.getProjectId());
            if (child != null) {
                children.add(child);
            }
        }

                    server = result.getServer();

                    if (logger.isDebugEnabled()) {
                        for (SettingsProblem problem : result.getProblems()) {
                            logger.debug(problem.getMessage(), problem.getException());
                        }
                    }

            String partOfMessage = ((ExceptionThrown) parameterExpectedResult).partOfMessage;

            assertEquals(1, ((Collection) result.getProblems()).size());
            result.getProblems().forEach(p -> {
                assertTrue(expectedException.isInstance(p.getException()));
                assertTrue(p.getException().getMessage().contains(partOfMessage));
            });