then:
        createDependency("group1", "name1", "version1") == createDependency("group1", "name1", "version1")
        createDependency("group1", "name1", "version1").hashCode() == createDependency("group1", "name1", "version1").hashCode()
        createDependency("group1", "name1", "version1") != createDependency("group1", "name1", "version2")
        createDependency("group1", "name1", "version1") != createDependency("group1", "name2", "version1")

     */
    private boolean isHigher(Version version1, Version version2, boolean inclusive) {
        int result = comparator.compare(version1, version2);
        return result >= (inclusive ? 0 : 1);
    }

    public String getUpperBound() {
        return upperBound;
    }

    public Version getUpperBoundVersion() {
        return upperBoundVersion;
    }

		t.Errorf("expected group to be %v, got %v", e, a)
	}
}

func TestCacheableObject(t *testing.T) {
	gvk1 := schema.GroupVersionKind{Group: "group", Version: "version1", Kind: "MockCacheableObject"}
	gvk2 := schema.GroupVersionKind{Group: "group", Version: "version2", Kind: "MockCacheableObject"}

	encoder := NewCodec(
		&mockSerializer{}, &mockSerializer{},
		&mockConvertor{}, nil,

        then:
        checkResolve "group:projectA:1.+": "group:projectA:1.1"

        when: "Version 1.2 is published"
        server.resetExpectations()
        def version2 = ivyHttpRepo.module("group", "projectA", "1.2").publish()

        then: "Version 1.1 is still used, as the 1.+ -> 1.1 mapping is cached"
        checkResolve "group:projectA:1.+": "group:projectA:1.1"

	testCases := []struct {
		bucket    string
		versioned bool
		object    string
		content   []byte
	}{
		{"bucket1", false, "object1", []byte("aaaaaaaaaaaaaaaa")},
		{"bucket2", false, "object2", bytes.Repeat([]byte{'a'}, smallFileThreshold*2)},
		{"bucket3", true, "version1", []byte("aaaaaaaaaaaaaaaa")},
		{"bucket4", true, "version2", bytes.Repeat([]byte{'a'}, smallFileThreshold*2)},
	}

// 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-- {

    "version": "8.9-20240612013748+0000",
    "buildTime": "20240612013748+0000"
  },
  "latestRc": {
    "version": "8.8-rc-2",
    "buildTime": "20240527070937+0000"
  },
  "finalReleases": [
    {
      "version": "8.8",
      "buildTime": "20240531214656+0000"
    },
    {
      "version": "8.7",
      "buildTime": "20240322155246+0000"
    },
    {
      "version": "8.6",

		return fmt.Errorf("failed to decode etcd version JSON: %v", err)
	}

	// Return without updating the version if it stayed the same since last time.
	if *lastSeenBinaryVersion == version.BinaryVersion {
		return nil
	}

	// Delete the metric for the previous version.
	if *lastSeenBinaryVersion != "" {
		deleted := etcdVersion.Delete(metrics.Labels{"binary_version": *lastSeenBinaryVersion})
		if !deleted {

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.

Supported members of a version declaration are:

- `require`: the <<rich_versions.adoc#sec:required-version,required version>>
- `strictly`: the <<rich_versions.adoc#sec:strict-version,strict version>>
- `prefer`: the <<rich_versions.adoc#sec:preferred-version,preferred version>>
- `reject`: the list of <<rich_versions.adoc#sec:rejected-version,rejected versions>>
- `rejectAll`: a boolean to reject all <<rich_versions.adoc#sec:rejected-version,versions>>