if err != nil {
		return errors.Wrap(err, "[upgrade/versions] FATAL")
	}

	// Fetch the current state of the component configs
	klog.V(1).Infoln("[upgrade/plan] analysing component config version states")
	configVersionStates, err := componentconfigs.GetVersionStates(&initCfg.ClusterConfiguration, client)
	if err != nil {
		return errors.WithMessage(err, "[upgrade/versions] FATAL")
	}

	// No upgrades available

			// to create the appropriate stack.
			versionsSorter(fivs.Versions).reverse()

			var rebalanced, expired int
			for _, version := range fivs.Versions {
				// Skip transitioned objects for now. TBD
				if version.IsRemote() {
					continue
				}

				// Apply lifecycle rules on the objects that are expired.
				if filterLifecycle(bucket, version.Name, version) {
					expired++
					continue
				}

                    assert it.target.version == '1.4'
                    assert it.target.name == it.requested.name
                    assert it.target.group == it.requested.group
                    it.useVersion '1.5'
                }
                eachDependency {
                    assert it.target.version == '1.5'
                    //don't change the version
                }
            }
"""

        List<String> versions = config.getVersionAliases();
        List<String> plugins = config.getPluginAliases();
        performValidation(libraries, bundles, versions, plugins);
        entryPointsConsumer.accept(new EntryPoints(
            toClassNode(libraries, rootNode(AccessorKind.library)),
            toClassNode(versions, rootNode(AccessorKind.version, "versions")).parent,

                conf("$dep1") {
                    version { strictly '$v1' }
                }
                conf("org:kotlin:2.9.4.1")

                conf("$dep2") {
                    version { strictly '$v2' }
                }
            }
        """

        and:
        "a rule which infers module set from group and version"()

        when:
        allowAllRepositoryInteractions()

        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"

static constexpr char kPlatformName[] = "Host";
constexpr char kEntryFuncName[] = "main";

static constexpr char kMlirModuleStr[] = R"(
  module attributes {tf.versions = {bad_consumers = [], min_consumer = 0 : i32, producer = 268 : i32}} {
  func.func @main() -> () {
    func.return
  }
})";

MlirToHloArgs CreateTestMlirToHloArgs(const char* module_str = kMlirModuleStr) {

.libs.versions.toml
[source,text]
----
[versions]
guava = "32.1.2-jre"
junit-jupiter = "5.10.0"

[libraries]
guava = { module = "com.google.guava:guava", version.ref = "guava" }
junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" }
----

To reference the libraries defined in the version catalog:

        Collection<String> versions = new LinkedHashSet<>();

        if ((repoMetadata != null) && (repoMetadata.getVersioning() != null)) {
            versions.addAll(repoMetadata.getVersioning().getVersions());
        }

        versions.addAll(availableVersions);

        List<ArtifactVersion> artifactVersions = new ArrayList<>(versions.size());

        for (String version : versions) {

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

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