* In this case though, the result contains simply the (parsed) input version, regardless of the
     * repositories and their contents.
     *
     * @param artifact the artifact for which to resolve the versions
     * @return a list of resolved {@code Version}s.
     * @throws org.apache.maven.api.services.VersionRangeResolverException if the resolution failed

 */
public interface ModelVersionParser {

    /**
     * Parses the specified version string, for example "1.0".
     *
     * @param version the version string to parse, must not be {@code null}
     * @return the parsed version, never {@code null}
     * @throws VersionParserException if the string violates the syntax rules of this scheme
     */
    @Nonnull
    Version parseVersion(@Nonnull String version);

    /**

        } catch (IOException e) {
            problems.add(new DefaultBuilderProblem(
                    null,
                    -1,
                    -1,
                    e,
                    "Failed to use environment variables for interpolation: " + e.getMessage(),
                    BuilderProblem.Severity.WARNING));
        }

        return new MavenToolchainsTransformer(value -> {
                    try {

FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED

            }
        } catch (IOException | XMLStreamException e) {
            // The root locator can be used very early during the setup of Maven,
            // even before the arguments from the command line are parsed.  Any exception
            // that would happen here should cause the build to fail at a later stage
            // (when actually parsing the POM) and will lead to a better exception being

        }
    }

    /**
     * Simply parse the given xml string.
     *
     * @param xml the input xml string
     * @return the parsed object
     * @throws XmlReaderException if an error occurs during the parsing
     * @see #toXmlString(Object)
     */
    public static Model fromXml(@Nonnull String xml) throws XmlReaderException {

        if (version == null || version.isEmpty()) {
            problems.add(
                    BuilderProblem.Severity.ERROR,
                    ModelProblem.Version.BASE,
                    "Failed to determine Java version for profile " + profile.getId(),
                    activation.getLocation("jdk"));
            return false;
        }
        return isJavaVersionCompatible(jdk, version);
    }

                        }
                        return new Relocation(global, s, t);
                    })
                    .collect(Collectors.toList());
            LOGGER.info("Parsed {} user relocations", relocationList.size());
            return new Relocations(relocationList);
        }
    }

    private static Artifact parseArtifact(String coord) {
        Artifact s;

        ArtifactSpec b = a.addDependency("b", "1.0");
        b.addDependency("a", "1.0");
        assertThrows(
                CyclicDependencyException.class,
                () -> collect(a),
                "Should have failed on cyclic dependency not involving project");
    }

    @Test
    @Disabled("works, but we don't fail on cycles presently")
    void testCircularDependencyIncludingCurrentProject()

                return null;
            }

            try {
                return ReflectionValueExtractor.evaluate(expression, root, false);
            } catch (Exception e) {
                addFeedback("Failed to extract \'" + expression + "\' from: " + root, e);
            }

            return null;
        }
    }

    /**