*
     * @return the problems that were encountered during the project building, can be empty but never {@code null}
     */
    @Nonnull
    List<ModelProblem> getProblems();

    /**
     * Creates a human readable representation of these errors.
     */
    String toString();

            if (cause instanceof ModelBuildingException) {
                String message = "In: " + pom + "\n\n";
                for (ModelProblem problem : ((ModelBuildingException) cause).getProblems()) {
                    message += problem + "\n";
                }
                System.out.println(message);
            }

            throw e;
        }
    }

        }

        @Override
        public PersistedToolchains getEffectiveToolchains() {
            return effectiveToolchains;
        }

        @Override
        public List<BuilderProblem> getProblems() {
            return problems;
        }
    }

            }
        }
        DefaultTypeValidationContext.throwOnProblemsOf(implementation, validationContext.getProblems());
        Transform transform = new DefaultTransform(
            implementation,
            parameterObject,
            from,
            to,

        InternalProblems problemsService = validationContext.getProblemsService();
        InternalProblemReporter reporter = problemsService.getInternalReporter();
        List<Problem> problems = validationContext.getProblems();
        for (Problem problem : problems) {
            reporter.report(problem);
        }

        Map<Severity, ImmutableList<Problem>> problemsMap = problems.stream()
            .collect(

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

            assertThat(result.getProblems()).hasSize(1);
            result.getProblems().forEach(p -> assertThat(p.getException())
                    .isInstanceOf(expectedException)
                    .hasMessageContaining(partOfMessage));
        }
    }

    @Test

            PropertyValidationAccess.collectValidationProblems(topLevelBean, validationContext);

            problems.addAll(validationContext.getProblems());
        }

        private static DefaultTypeValidationContext createTypeValidationContext(Class<?> topLevelBean, boolean enableStricterValidation) {
            if (Task.class.isAssignableFrom(topLevelBean)) {

                    return exception.getResults().stream()
                            .filter(projectsOutsideOfRequestScope)
                            .flatMap(projectBuildingResult -> projectBuildingResult.getProblems().stream())
                            .map(ModelProblem::getException)
                            .filter(pluginArtifactNotFoundException)

        }

        @Override
        public Settings getEffectiveSettings() {
            return effectiveSettings;
        }

        @Override
        public List<BuilderProblem> getProblems() {
            return problems;
        }
    }

                problems.add(Severity.FATAL, ModelProblem.Version.V40, null, e);
            }

            return Result.newResult(model, problems.getProblems());
        } catch (ModelBuilderException e) {
            return Result.error(problems.getProblems());
        }
    }

    Model readFileModel(ModelBuilderRequest request, DefaultModelProblemCollector problems)
            throws ModelBuilderException {