collector.add(Problem.Severity.ERROR, "Error message", 10, 5, null);
        collector.add(Problem.Severity.WARNING, "Warning message", 15, 3, null);

        List<Problem> problems = collector.getProblems();
        assertEquals(2, problems.size(), "Should collect both problems");
        assertEquals(Problem.Severity.ERROR, problems.get(0).getSeverity(), "First problem should be ERROR");

                validateStringNotEmpty(problems, "mirrors.mirror.id", mirror.getId(), mirror.getUrl());

                validateBannedCharacters(
                        problems, "mirrors.mirror.id", Severity.WARNING, mirror.getId(), null, ILLEGAL_REPO_ID_CHARS);

                if ("local".equals(mirror.getId())) {
                    addViolation(
                            problems,
                            Severity.WARNING,

        repo.setUrl("http://xxx.xxx.com");
        problems = new SimpleProblemCollector();
        validator.validate(model, problems);
        assertEquals(1, problems.messages.size());

        repo.setId("xxx");
        problems = new SimpleProblemCollector();
        validator.validate(model, problems);
        assertEquals(0, problems.messages.size());
    }

    @Test
    void testValidateMirror() throws Exception {

    private final List<SettingsProblem> problems;

    /**
     * Creates a new exception with the specified problems.
     *
     * @param problems The problems that cause this exception, may be {@code null}.
     */
    public SettingsBuildingException(List<SettingsProblem> problems) {
        super(toMessage(problems));

        this.problems = new ArrayList<>();
        if (problems != null) {

    }

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

    @Override
    public void setSource(String source) {
        this.source = source;
    }

    @Override
    public void add(Problem.Severity severity, String message, int line, int column, Exception cause) {
        Problem problem = new DefaultProblem(message, severity, source, line, column, cause);

    }

    public void add(ModelProblem problem) {
        problems.add(problem);

        severities.add(problem.getSeverity());
    }

    public void addAll(List<ModelProblem> problems) {
        this.problems.addAll(problems);

        for (ModelProblem problem : problems) {
            severities.add(problem.getSeverity());
        }
    }

    @Override

            return "Some problems were encountered while processing the POMs";
        }

        long totalProblems = 0;
        long errorProblems = 0;

        for (ProjectBuildingResult result : results) {
            List<ModelProblem> problems = result.getProblems();
            totalProblems += problems.size();

            for (ModelProblem problem : problems) {

                if (!modelResult.getProblems().isEmpty()) {
                    List<ModelProblem> problems = modelResult.getProblems();
                    if (logger.isDebugEnabled()) {
                        String problem = (problems.size() == 1) ? "problem" : "problems";
                        String problemPredicate = problem + ((problems.size() == 1) ? " was" : " were");

    }

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

    public DefaultModelBuildingResult setProblems(List<ModelProblem> problems) {
        if (problems != null) {
            this.problems = new ArrayList<>(problems);
        } else {
            this.problems.clear();
        }

        return this;
    }

            file.forEachLine(Charsets.UTF_8) {
                val (version, _, problem, relativePath, lineNumber) = it.split(';')
                byCategory.getOrPut(toCategory(version, file.nameWithoutExtension)) {
                    mutableMapOf()
                }.getOrPut(file.nameWithoutExtension) {
                    mutableSetOf()
                }.add(Problem(name = problem, relativePath = relativePath, lineNumber = lineNumber.toInt()))
            }