public String toString() {
            return source + (global ? " >> " : " > ") + target;
        }
    }

    private static class Relocations {
        private final List<Relocation> relocations;

        private Relocations(List<Relocation> relocations) {
            this.relocations = relocations;
        }

        private Relocation getRelocation(Artifact artifact) {
            return relocations.stream()

                .distinct()
                .map(Plugin::getArtifactId) // managed by us, groupId is always o.a.m.plugins
                .collect(Collectors.toList());

        if (!unversionedPlugins.isEmpty()) {
            logger.warn("Version not locked for default bindings plugins " + unversionedPlugins

                })
                .collect(toList());
    }

    static class ScenarioBuilder {
        private String description;
        private List<String> activeRequiredProjects = emptyList();
        private List<String> activeOptionalProjects = emptyList();
        private List<String> inactiveRequiredProjects = emptyList();
        private List<String> inactiveOptionalProjects = emptyList();

                        null))
                .collect(Collectors.toList());
        return new XmlNodeImpl("configuration", null, null, children, null);
    }

    public static org.codehaus.plexus.util.xml.Xpp3Dom convert(MojoDescriptor mojoDescriptor) {
        PlexusConfiguration c = mojoDescriptor.getMojoConfiguration();

        List<XmlNode> children = new ArrayList<>();

    @SuppressWarnings({"rawtypes", "unchecked"})
    @Override
    public Collection<Type> provides() {
        return (Collection) types();
    }

    public Collection<DefaultType> types() {
        return Arrays.asList(
                // Maven types
                new DefaultType(Type.POM, Language.NONE, "pom", null, false),
                new DefaultType(Type.BOM, Language.NONE, "pom", null, false),

                    PluginManagerException, LifecyclePhaseNotFoundException, LifecycleNotFoundException,
                    PluginVersionResolutionException {
        List<TaskSegment> taskSegments =
                lifecycleTaskSegmentCalculator.calculateTaskSegments(session, Arrays.asList(tasks));

        TaskSegment mergedSegment = new TaskSegment(false);

        for (TaskSegment taskSegment : taskSegments) {

                .proxies(request.getProxies().stream().map(Proxy::getDelegate).collect(Collectors.toList()))
                .servers(request.getServers().stream().map(Server::getDelegate).collect(Collectors.toList()))
                .mirrors(request.getMirrors().stream().map(Mirror::getDelegate).collect(Collectors.toList()))
                .profiles(request.getProfiles().stream()
                        .map(Profile::getDelegate)

    private static final String PREFIX_PROJECT = "project.";
    private static final String PREFIX_POM = "pom.";
    private static final List<String> PROJECT_PREFIXES_3_1 = Arrays.asList(PREFIX_POM, PREFIX_PROJECT);
    private static final List<String> PROJECT_PREFIXES_4_0 = Collections.singletonList(PREFIX_PROJECT);

    private static final Collection<String> TRANSLATED_PATH_EXPRESSIONS;

    static {

                res.getArtifacts(),
                "Check artifact list");

        ArtifactFilter filter = new ExclusionSetFilter(new String[] {"b"});
        res = collect(a, filter);
        assertEquals(createSet(new Object[] {a.artifact, c.artifact}), res.getArtifacts(), "Check artifact list");
    }

    @Test
    void testResolveCorrectDependenciesWhenDifferentDependenciesOnNearest()

        assertEquals(1, ((List<?>) pom.getValue("build/plugins[1]/executions")).size());
        assertEquals("maven-it-plugin-b", pom.getValue("build/plugins[2]/artifactId"));
        assertEquals(1, ((List<?>) pom.getValue("build/plugins[1]/executions")).size());
        assertEquals("maven-it-plugin-a", pom.getValue("reporting/plugins[1]/artifactId"));