@Nonnull
    List<Version> getVersions();

    @Nonnull
    default Optional<Version> getLowerVersion() {
        return getVersions().isEmpty()
                ? Optional.empty()
                : Optional.of(getVersions().get(0));
    }

    @Nonnull
    default Optional<Version> getHigherVersion() {
        return getVersions().isEmpty()
                ? Optional.empty()

                    }
                }

                Collections.sort(versions);
                result.setVersions(versions);
            }
        }

        return result;
    }

    private Map<String, ArtifactRepository> getVersions(
            RepositorySystemSession session, VersionRangeResult result, VersionRangeRequest request) {

                    }
                }

                Collections.sort(versions);
                result.setVersions(versions);
            }
        }

        return result;
    }

    private Map<String, ArtifactRepository> getVersions(
            RepositorySystemSession session, VersionRangeResult result, VersionRangeRequest request) {

                public List<Exception> getExceptions() {
                    return res.getExceptions();
                }

                @Override
                public List<Version> getVersions() {
                    return map(res.getVersions(), v -> session.parseVersion(v.toString()));
                }

                @Override
                public Optional<Repository> getRepository(Version version) {

 * limitations under the License.
 */

package org.gradle.test.fixtures.maven

import org.gradle.test.fixtures.ModuleArtifact

interface RootMavenMetaData extends ModuleArtifact {
    List<String> getVersions();

            }

            Collection<String> versions =
                    new LinkedHashSet<>(recessive.getVersioning().getVersions());
            versions.addAll(versioning.getVersions());
            versioning.setVersions(new ArrayList<>(versions));
        }

        // just carry-on as-is
        if (!recessive.getPlugins().isEmpty()) {

        try {
            List<String> versions = getVersions(sdkSubkey);
            return versions.stream().map(version -> getValue(sdkSubkey, path, value, version)).collect(Collectors.toList());
        } catch (MissingRegistryEntryException | NativeIntegrationUnavailableException e) {
            // Ignore
            return Collections.emptyList();
        }
    }

    private List<String> getVersions(String sdkSubkey) {

                versioning.release(recessive.getVersioning().getRelease());
            }

            Collection<String> versions =
                    new LinkedHashSet<>(recessive.getVersioning().getVersions());
            versions.addAll(original.getVersions());
            versioning.versions(new ArrayList<>(versions));
        }

        metadata = metadata.withVersioning(versioning.build());

        // just carry-on as-is

    /**
     * Id of this module
     */
    ModuleIdentifier getId();

    /**
     * Candidate versions of this module. Many times, it has only single version.
     */
    Collection<ComponentState> getVersions();

    void replaceWith(ComponentState selected);

        this.versions = versions;
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public List<? extends ModuleVersionIdentifier> getVersions() {
        return versions;
    }