assertNotNull(actual);

        boolean hasLocation = actual.getProblems().stream()
                .anyMatch(p -> p.getLineNumber() == lineNumber && p.getColumnNumber() == columnNumber);

        if (!hasLocation) {
            String actualLocations = actual.getProblems().stream()
                    .map(p -> formatLocation(p.getColumnNumber(), p.getLineNumber()))

        assertNotNull(actual);

        boolean hasMessage =
                actual.getProblems().stream().anyMatch(p -> p.getMessage().contains(problemMessage));

        if (!hasMessage) {
            String actualMessages = actual.getProblems().stream()
                    .map(ModelProblem::getMessage)
                    .map(m -> "\"" + m + "\"")

                }

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

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

        long totalProblemsCount = 0;

        for (ProjectBuildingResult result : results) {
            projects.add(result.getProject());

            int problemsCount = result.getProblems().size();
            totalProblemsCount += problemsCount;
            if (problemsCount != 0 && LOGGER.isWarnEnabled()) {
                LOGGER.warn("");
                LOGGER.warn(

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

        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(

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

        context.localRepositoryPath = localRepositoryPath(context);

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

            if (results.stream()
                    .flatMap(r -> r.getProblems().stream())
                    .anyMatch(p -> p.getSeverity() != org.apache.maven.model.building.ModelProblem.Severity.WARNING)) {
                org.apache.maven.model.building.ModelProblem cycle = results.stream()
                        .flatMap(r -> r.getProblems().stream())

        return rel;
    }

    private ModelProblem hasMissingParentPom(ProjectBuildingException e) {
        if (e.getCause() instanceof ModelBuildingException mbe) {
            for (ModelProblem problem : mbe.getProblems()) {
                if (problem.getException() instanceof UnresolvableModelException) {
                    return problem;
                }
            }
        }
        return null;
    }