* <li>{@code *,!repo1} (since 2.0.9)= everything except {@code repo1}.</li>
     * </ul>
     *
     * @param originalRepository to compare for a match.
     * @param pattern used for match.
     * @return true if the repository is a match to this pattern.
     */
    static boolean matchPattern(ArtifactRepository originalRepository, String pattern) {
        boolean result = false;

        Artifact resolvedArtifact = result.getArtifacts().iterator().next();

        assertEquals("1.0", resolvedArtifact.getVersion(), "Resolved version don't match original artifact version");
    }

    @Test
    void testResolveCompileScopeOverTestScope()
            throws ArtifactResolutionException, InvalidVersionSpecificationException {

        Server match = null;
        java.util.List<Server> servers = getServers();
        if (servers != null && serverId != null) {
            for (Server server : servers) {
                if (serverId.equals(server.getId())) {
                    match = server;
                    break;
                }
            }
        }
        return match;
    }

    @Deprecated

                            BuilderProblem.Severity.ERROR,
                            "pluginGroups.pluginGroup[" + i + "]",
                            null,
                            "must denote a valid group id and match the pattern " + ID);
                }
            }
        }

        List<Server> servers = settings.getServers();

        if (servers != null) {
            Set<String> serverIds = new HashSet<>();

        } catch (ComponentLookupException e) {
            throw new PluginConfigurationException(
                    mojoDescriptor.getPluginDescriptor(),
                    "Unable to retrieve component configurator " + configuratorId + " for configuration of mojo "
                            + mojoDescriptor.getId(),
                    e);
        } catch (NoClassDefFoundError e) {

        MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();

        try {
            mavenPluginManager.checkPrerequisites(mojoDescriptor.getPluginDescriptor());
        } catch (PluginIncompatibleException e) {
            throw new LifecycleExecutionException(messageBuilderFactory, mojoExecution, session.getCurrentProject(), e);
        }

                    Files.delete(artifactPath.getParent());
                    Files.delete(artifactPath.getParent().getParent());
                } catch (DirectoryNotEmptyException e) {
                    // ignore
                }
            }
        } catch (IOException e) {
            LOGGER.error("Error while cleaning project local repository", e);
        }
    }

    /**

                                } catch (IOException e) {
                                    throw new UncheckedIOException(e);
                                }
                            }
                            names.put(mf, name);
                        }
                    });
                } catch (UncheckedIOException e) {
                    throw e.getCause();

                String c = cache.get(value);
                if (c == null) {
                    try {
                        c = interpolator.interpolate(value, recursionInterceptor);
                    } catch (InterpolationException e) {
                        problems.add(BuilderProblem.Severity.ERROR, ModelProblem.Version.BASE, e.getMessage(), e);
                    }
                    cache.put(value, c);
                }

        // [prefix]:[goal]

        if (session.getCurrentProject() != null) {
            try {
                lifecyclePluginResolver.resolveMissingPluginVersions(session.getCurrentProject(), session);
            } catch (PluginVersionResolutionException e) {
                // not critical here
                logger.debug(e.getMessage(), e);
            }
        }