// Name of the file.
	Name string `msg:"n,omitempty"`

	// Represents the latest mod time of the
	// latest version.
	LatestModTime time.Time `msg:"lm"`

	Versions     []FileInfo `msg:"vs"`
	FreeVersions []FileInfo `msg:"fvs"`
}

// findVersionIndex will return the version index where the version
// was found. Returns -1 if not found.
func (f *FileInfoVersions) findVersionIndex(v string) int {

					if err := selectFrom(idx); err != nil {
						return err
					}
				}
				versions = append(versions, xl2.versions)
			}

			if xl != nil && len(versions) > 0 {
				// Merge all versions. 'strict' doesn't matter since we only need one.
				xl.versions = mergeXLV2Versions(readQuorum, true, 0, versions...)
				if meta, err := xl.AppendTo(metaDataPoolGet()); err == nil {
					if best.reusable {

                converter.transform(producer.transform(key, dependenciesProvider, null), dependenciesProvider, null)
            }
        }
    }

    def version(String version) {
        return versionParser.transform(version)
    }

	}
	return groups
}

func extractVersions(rule *v1.Rule) []string {
	versions := make([]string, 0, len(rule.APIVersions))
	for _, version := range rule.APIVersions {
		if strings.ContainsAny(version, "*") {
			return nil
		}
		versions = append(versions, version)
	}
	return versions
}

func extractResources(rule *v1.Rule) []string {
	resources := make([]string, 0, len(rule.Resources))

[NOTE]
====
GradleRunner supports the same range of Gradle versions as the Tooling API.
The supported versions are defined in the <<third_party_integration.adoc#sec:embedding_compatibility,compatibility matrix>>.

Builds with older Gradle versions _may_ still work but there are no guarantees.
====

Starting with version 2.13, Gradle provides a conventional mechanism to inject the code under test into the test build.

        then:
        failure.assertHasCause("""Cannot find a version of 'org:foo' that satisfies the version constraints:
   Dependency path ':test:unspecified' --> 'org:foo:1.1'
   Dependency path ':test:unspecified' --> 'org:bar:1.0' (runtime) --> 'org:foo:{require 1.0; reject 1.1}'""")
    }

    void "honors multiple rejections #rejects using dynamic versions using dependency notation #rejects"() {
        given:

func GoModFile(ctx context.Context, path, version string) (string, error) {
	if !gover.ModIsValid(path, version) {
		return "", fmt.Errorf("invalid version %q", version)
	}
	if _, err := GoMod(ctx, path, version); err != nil {
		return "", err
	}
	// GoMod should have populated the disk cache for us.
	file, err := CachePath(ctx, module.Version{Path: path, Version: version}, "mod")
	if err != nil {
		return "", err
	}

	DeleteRestoredAction
	// DeleteRestoredVersionAction deletes a particular version that was temporarily restored
	DeleteRestoredVersionAction
	// DeleteAllVersionsAction deletes all versions when an object expires
	DeleteAllVersionsAction
	// DelMarkerDeleteAllVersionsAction deletes all versions when an object with delete marker as latest version expires
	DelMarkerDeleteAllVersionsAction

// to what options were introduced at which versions.
//
// Each EnvSet is given a compatibility version when it is created, and prepares the
// NewExpressions environment to be compatible with that version. The EnvSet also
// prepares StoredExpressions to be compatible with all known versions of Kubernetes.
type EnvSet struct {
	// compatibilityVersion is the version that all configuration in

        repoModule.rootMetaData.versions == ["1.0", "2.0"]
        repoModule.rootMetaData.releaseVersion == "2.0"
        repoModule.rootMetaData.latestVersion == "2.0"

        and:
        localModule.rootMetaData.groupId == "group"
        localModule.rootMetaData.artifactId == "root"
        localModule.rootMetaData.versions == ["1.0", "2.0"]
        localModule.rootMetaData.releaseVersion == "2.0"