private String join(String message1, String message2) {
        String message = "";

        if (message1 != null && !message1.isEmpty()) {
            message = message1.trim();
        }

        if (message2 != null && !message2.isEmpty()) {
            if (message != null && !message.isEmpty()) {
                if (message.endsWith(".") || message.endsWith("!") || message.endsWith(":")) {
                    message += " ";

        StringBuilder buffer = new StringBuilder(256);

        if (!getSource().isEmpty()) {
            if (!buffer.isEmpty()) {
                buffer.append(", ");
            }
            buffer.append(getSource());
        }

        if (getLineNumber() > 0) {
            if (!buffer.isEmpty()) {
                buffer.append(", ");
            }

        mergeSite_Url(target, source, sourceDominant, context);
    }

    protected boolean isSiteEmpty(Site site) {
        return StringUtils.isEmpty(site.getId())
                && StringUtils.isEmpty(site.getName())
                && StringUtils.isEmpty(site.getUrl());
    }

    @Override
    protected void mergeSite_Url(Site target, Site source, boolean sourceDominant, Map<Object, Object> context) {

    val errors: List<ReportMessage>,
    val warnings: List<ReportMessage>,
    val information: List<ReportMessage>,
    val accepted: List<ReportMessage>
) {

    val isEmpty: Boolean
        get() = errors.isEmpty() && warnings.isEmpty() && information.isEmpty()

    fun toText() =
        StringBuilder("Binary compatibility\n").apply {

        }
        visitor.onEnd();
    }

    private void skipComment() {
        scanner.next(4);
        while (!scanner.isEmpty() && !scanner.lookingAt(END_HTML_COMMENT)) {
            scanner.next();
        }
        if (!scanner.isEmpty()) {
            scanner.next(3);
        }
    }

    private void parseHtmlEntity(StringBuilder buffer) {
        scanner.next();

        // Apply default behavior when no specific options are provided
        if (defaultWhenNoOptionsSpecified
                && options.infer().isEmpty()
                && options.model().isEmpty()
                && options.plugins().isEmpty()
                && options.model().isEmpty()) {
            return true;
        }

        return false;
    }

    /**
     * Gets a description of what this strategy does.

        }

        buffer.append(":\n");

        for (ProjectBuildingResult result : results) {
            if (!result.getProblems().isEmpty()) {
                String projectInfo = result.getProjectId();
                if (projectInfo.trim().isEmpty()) {
                    projectInfo =
                            result.getPomFile() != null ? result.getPomFile().getName() : "unknown project";
                }

        this.groupId = (groupId != null && !groupId.isEmpty()) ? groupId : null;
        this.artifactId = (artifactId != null && !artifactId.isEmpty()) ? artifactId : null;
        this.classifier = (classifier != null && !classifier.isEmpty()) ? classifier : null;
        this.extension = (extension != null && !extension.isEmpty()) ? extension : null;
        this.version = (version != null && !version.isEmpty()) ? version : null;

        descriptor.setVersion("0.1");
        List<String> errors = new ArrayList<>();
        mavenPluginValidator.validate(plugin, descriptor, errors);
        assertTrue(
                errors.isEmpty(), "Expected collection to be empty but had " + errors.size() + " elements: " + errors);
    }

    @Test
    void testInvalidGroupId() {
        Artifact plugin = new DefaultArtifact(

        List<Restriction> restrictions;

        if (r1.isEmpty() || r2.isEmpty()) {
            restrictions = Collections.emptyList();
        } else {
            restrictions = Collections.unmodifiableList(intersection(r1, r2));
        }

        ArtifactVersion version = null;
        if (!restrictions.isEmpty()) {
            for (Restriction r : restrictions) {