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

        }

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

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

                    server = result.getServer();

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

    }

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

                }

                model = modelBuilder.build(modelRequest).getEffectiveModel();
            } catch (ModelBuildingException e) {
                for (ModelProblem problem : e.getProblems()) {
                    if (problem.getException() instanceof UnresolvableModelException) {
                        result.addException(problem.getException());

        assertEquals(1, results.size());
        ProjectBuildingResult result = results.get(0);
        assertNotNull(result);
        assertNotNull(result.getProject());
        assertEquals(1, result.getProblems().size());
        assertEquals(1, result.getProject().getArtifacts().size());
        assertNotNull(result.getDependencyResolutionResult());
    }

    /**

        decrypt.setServers(request.getServers());
        SettingsDecryptionResult decrypted = settingsDecrypter.decrypt(decrypt);

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

        DefaultMirrorSelector mirrorSelector = new DefaultMirrorSelector();

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

                    );
                }
            })
        );

        ImmutableList<Problem> validationMessages = validationContext.getProblems();
        if (!validationMessages.isEmpty()) {
            throw new DefaultMultiCauseException(
                String.format(validationMessages.size() == 1