// This function assumes that the highest supported version must be v1.x.
func HighestSupportedVersion(versions []string) (*Version, error) {
	if len(versions) == 0 {
		return nil, errors.New("empty array for supported versions")
	}

	var (
		highestSupportedVersion *Version
		theErr                  error
	)

	for i := len(versions) - 1; i >= 0; i-- {

          versions.bad_consumers().data(),
          versions.bad_consumers().data() + versions.bad_consumers().size())));
  module->setAttr("tf.versions",
                  b.getDictionaryAttr(llvm::ArrayRef<mlir::NamedAttribute>(
                      {producer, min_consumer, bad_consumers})));
}

mlir::LogicalResult ExtractTfVersions(mlir::ModuleOp module,
                                      VersionDef* versions) {
  versions->Clear();

		_, err = dst.unmarshalV(x.metaV, version.meta)
		if err != nil {
			return versions, err
		}
		fi, err := dst.ToFileInfo(volume, path, allParts)
		if err != nil {
			return versions, err
		}
		fi.NumVersions = len(x.versions)
		versions = append(versions, fi)
	}

	for i := range versions {
		versions[i].NumVersions = len(versions)
		if i > 0 {

                    "Base version of Gradle version (%s) must not be greater than base version of current Gradle version: %s", parsedGradleVersion.getVersion(), currentBaseVersion);
                Preconditions.checkArgument(cacheVersion > versions.get(versions.lastKey()),
                    "cache version (%s) must be greater than all previous versions: %s", cacheVersion, versions.values());
            }

        "groupVersion": "apiregistration.k8s.io/v1",
        "version": "v1"
      },
      "versions": [
        {
          "groupVersion": "apiregistration.k8s.io/v1",
          "version": "v1"
        }
      ]
    },
    {
      "name": "apps",
      "preferredVersion": {
        "groupVersion": "apps/v1",
        "version": "v1"
      },
      "versions": [
        {
          "groupVersion": "apps/v1",

		return true
	}
	if !chkNumVersions(fivs.Versions) {
		t.Fatalf("Expected all versions to have the same NumVersions")
	}

	sort.Slice(versions, func(i, j int) bool {
		if versions[i].IsLatest {
			return true
		}
		if versions[j].IsLatest {
			return false
		}
		return versions[i].ModTime.After(versions[j].ModTime)
	})

	for i, fi := range fivs.Versions {
		if fi.VersionID != versions[i].VersionID {

For example you might want to always integrate the latest version of a dependency to consume cutting edge features at any given time.
A _dynamic version_ allows for resolving the latest version or the latest version of a version range for a given module.

CAUTION: Using dynamic versions in a build bears the risk of potentially breaking it. As soon as a new version of the dependency is released that contains an incompatible API change your source code might stop compiling.

        boolean searchPerformed = false;

        if (versions.releaseVersion != null && !versions.releaseVersion.isEmpty()) {
            version = versions.releaseVersion;
            repo = versions.releaseRepository;
        } else if (versions.latestVersion != null && !versions.latestVersion.isEmpty()) {
            version = versions.latestVersion;
            repo = versions.latestRepository;

		return err
	}

	if len(out.Versions) == 0 {
		return nil
	}

	// Copy versions[0] to version
	out.Version = out.Versions[0].Name

	// If versions[*].{subresources,schema,additionalPrinterColumns,selectableFields} are identical, move to spec
	subresources := out.Versions[0].Subresources
	subresourcesIdentical := true
	validation := out.Versions[0].Schema
	validationIdentical := true

        version('2.5')   | version('2.4')  | 'existing version with major and minor attribute'
        version('2.2.1') | version('2.2')  | 'existing version with major, minor and patch attribute'
        version('0.8')   | null            | 'first released version'
        version('0.1')   | null            | 'version that does not exist'
    }