}
            return buf.toString();
        }
    }

    public ArtifactVersion matchVersion(List<ArtifactVersion> versions) {
        // TODO could be more efficient by sorting the list and then moving along the restrictions in order?

        ArtifactVersion matched = null;
        for (ArtifactVersion version : versions) {
            if (containsVersion(version)) {

identifiable sections of that work are not derived from the Program, and
can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based on
the Program, the distribution of the whole must be on the terms of this

        when(mavenExecutionRequest.getProjectActivation()).thenReturn(projectActivation);
        when(mavenExecutionRequest.getMakeBehavior()).thenReturn(parameterMakeBehavior);
        when(mavenExecutionRequest.getPom()).thenReturn(parameterRequestedPom);
        when(mavenExecutionRequest.isRecursive()).thenReturn(parameterRecursive);

            // Just returning an Integer with the index here is faster, but requires a lot of if/then/else to check for
            // -1
            //  or QUALIFIERS.size and then resort to lexical ordering. Most comparisons are decided by the first
            // character,
            // so this is still fast. If more characters are needed then it requires a lexical sort anyway.

        projects = new ProjectSorter(projects).getSortedProjects();

        assertEquals(parentProject, projects.get(0));

        // the order of these two is non-deterministic, based on when they're added to the reactor.
        assertThat(projects, hasItem(pluginProject));
        assertThat(projects, hasItem(pluginLevelDepProject));

     * <ul>
     * <li>collect all the vertices for the projects that we want to build.</li>
     * <li>iterate through the deps of each project and if that dep is within
     * the set of projects we want to build then add an edge, otherwise throw
     * the edge away because that dependency is not within the set of projects
     * we are trying to build. we assume a closed set.</li>
     * <li>do a topo sort on the graph that remains.</li>

        return interpolate(model, context, true);
    }

    /**
     * Serialize the inbound Model instance to a StringWriter, perform the regex replacement to resolve
     * POM expressions, then re-parse into the resolved Model instance.
     * <p>
     * <b>NOTE:</b> This will result in a different instance of Model being returned!!!
     *

        if (!vertices.contains(vertex)) {
            vertices.add(vertex);
        }

        if (parentVertex != null) // then create the edge
        {
            ArtifactMetadata md = node.getMd();
            MetadataGraphEdge e =
                    new MetadataGraphEdge(md.version, md.resolved, md.artifactScope, md.artifactUri, depth, pomOrder);

     * If no module is found, or if module information cannot be extracted, then this constructor
     * builds an empty map.
     *
     * <p>If the {@code resolve} parameter value is {@code false}, then some or all map values may
     * be null instead of the actual module name. This option can avoid the cost of reading module
     * descriptors when only the modules existence needs to be verified.</p>
     *
     * <p><b>Algorithm:</b>

     *   <li>If {@link #MODULES} path type is also set, then the dependency can be placed either on the
     *       class-path or on the module-path, but only one of those. The choice is up to the plugin,
     *       possibly using heuristic rules (Maven 3 behavior).</li>
     *   <li>If a {@link #patchModule(String)} is also set and the main JAR file is placed on the module-path,