MavenProject fromProject,
            Map<String, MavenProject> projectMap,
            boolean force,
            boolean safe)
            throws CycleDetectedException {
        if (fromVertex.equals(toVertex)) {
            return;
        }

        if (fromProject != null) {
            MavenProject toProject = projectMap.get(toVertex.getLabel());
            fromProject.addProjectReference(toProject);

        Iterator<RemoteRepository> iterator = repositories.iterator();
        while (iterator.hasNext()) {
            RemoteRepository remoteRepository = iterator.next();
            if (remoteRepository.getId().equals(id)) {
                iterator.remove();
            }
        }
    }

    @Override
    public ModelResolver newCopy() {
        return new DefaultModelResolver(this);
    }

).apply {
    disabledChecks.addAll(
        // DISCUSS
        "EnumOrdinal", // This violation is ubiquitous, though most are benign.
        "EqualsGetClass", // Let's agree if we want to adopt Error Prone's idea of valid equals()
        "JdkObsolete", // Most of the checks are good, but we do not want to replace all LinkedLists without a good reason

        // NEVER
        "AssignmentExpression", // Not using it is more a matter of taste.

    @Nonnull
    public String id() {
        return id;
    }

    public boolean isTransitive() {
        return transitive;
    }

    public boolean is(String id) {
        return id().equals(id);
    }

            Matcher pidMatcher = pidPattern.matcher(line);
            if (commandLineArgsMatcher.find() && pidMatcher.find()) {
                String pid = pidMatcher.group(1);
                if (!MY_PID.equals(pid)) {
                    action.accept(pid, line);
                }
            }
        });
    }

    private static List<String> ps() {

        }

        private void injectReactorDependency(List<MavenProject> projects, String moduleFrom, String moduleTo) {
            for (MavenProject project : projects) {
                if (moduleFrom.equals(project.getArtifactId())) {
                    Dependency dependency = new Dependency();
                    dependency.setArtifactId(moduleTo);
                    dependency.setGroupId(project.getGroupId());

            messageBuffer.append("</configuration>");

            String alias = param.getAlias();
            if ((alias != null && !alias.isEmpty()) && !alias.equals(param.getName())) {
                messageBuffer.append(LS).append(LS).append("-OR-").append(LS).append(LS);
                messageBuffer
                        .append("<configuration>")

            throws ChecksumFailedException {
        if (ArtifactRepositoryPolicy.CHECKSUM_POLICY_FAIL.equals(checksumPolicy)) {
            throw new ChecksumFailedException(message, cause);
        } else if (!ArtifactRepositoryPolicy.CHECKSUM_POLICY_IGNORE.equals(checksumPolicy)) {
            // warn if it is set to anything other than ignore

     *   <li>Ensures no duplicate repositories exist in the list</li>
     *   <li>Ensures no null repository entries exist in the list</li>
     * </ul>
     *
     * <p>Duplicate detection is based on the {@code RemoteRepository#equals(Object)}
     * method, which typically compares repository IDs and URLs.
     *
     * @param repositories the list of repositories to validate, may be {@code null}

            String pluginArtifactId = plugin.getArtifactId();

            assertTrue(validPluginCounts.containsKey(pluginArtifactId), "Illegal plugin found: " + pluginArtifactId);

            if (pluginArtifactId.equals(testPluginArtifactId)) {
                testPlugin = plugin;
            }

            Integer count = validPluginCounts.get(pluginArtifactId);