====

[[sec:strict-version-consequences]]
=== Consequences of using strict versions

Using a strict version must be carefully considered, in particular by library authors.
As the _producer_, a strict version will effectively behave like a _force_: the version declaration takes precedence over whatever is found in the transitive dependency graph.

		if disabledVersions[version] {
			if !errors.IsNotFound(err) {
				t.Errorf("expected the CR creation fail with NotFound for disabled version %s, got error: %v", version, err)
			}
			continue
		}
		if err != nil {
			t.Fatalf("unable to create noxu Instance:%v", err)
		}

    };

    private void checkVersionsOrder(String[] versions) {
        Comparable[] c = new Comparable[versions.length];
        for (int i = 0; i < versions.length; i++) {
            c[i] = newComparable(versions[i]);
        }

        for (int i = 1; i < versions.length; i++) {
            Comparable low = c[i - 1];
            for (int j = i; j < versions.length; j++) {
                Comparable high = c[j];

    def "has all defined aliases"() {
        builder.library("foo-lib1", "org", "foo").version("lib-version")
        builder.library("foo-lib2", "org", "foo").version("lib-version2")
        builder.bundle("foo-bundle", ["foo-lib1", "foo-lib2"])
        builder.plugin("foo-plugin", "foo.bar").version("plugin-version")
        builder.version("foo-version", "1.0.0")

        when:
        def model = builder.build()

        then:

        vs.version = ""
        return vs
    }

    private static RenderableVersion fixed(int version) {
        def vs = new SimpleVersion()
        vs.version = "${version}"
        return vs
    }

    private static RenderableVersion prefer(int version) {
        def vs = new PreferVersion()
        vs.version = "${version}"
        return vs
    }

        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;

// It is controlled by "k8s:prerelease-lifecycle-gen:replacement=<group>,<version>,<kind>" tags in types.go.
func (in *DaemonSetList) APILifecycleReplacement() schema.GroupVersionKind {
	return schema.GroupVersionKind{Group: "apps", Version: "v1", Kind: "DaemonSetList"}
}

// APILifecycleRemoved is an autogenerated function, returning the release in which the API is no longer served as int versions of major and minor for comparison.

					Version: "v1",
				},
			},
			Out: &CustomResourceDefinition{},
			ExpectOut: &CustomResourceDefinition{
				Spec: CustomResourceDefinitionSpec{
					Versions: []CustomResourceDefinitionVersion{{Name: "v1", Served: true, Storage: true}},
				},
			},
		},
		{
			Name: "internal to v1, multiple versions",
			In: &apiextensions.CustomResourceDefinition{
				Spec: apiextensions.CustomResourceDefinitionSpec{

		return upgrades, err
	}
	printer.Printf("[upgrade/versions] kubeadm version: %s\n", kubeadmVersionStr)

	// Get and output the current latest stable version
	stableVersionStr, stableVersion, err := versionGetterImpl.VersionFromCILabel("stable", "stable version")
	if err != nil {
		klog.Warningf("[upgrade/versions] WARNING: %v\n", err)

		c.FuzzNoCustom(o)

		// The ResourceManager will just not serve the group if its versions
		// list is empty
		atLeastOne := apidiscoveryv2.APIVersionDiscovery{}
		c.Fuzz(&atLeastOne)
		o.Versions = append(o.Versions, atLeastOne)
		sort.Slice(o.Versions[:], func(i, j int) bool {
			return version.CompareKubeAwareVersionStrings(o.Versions[i].Version, o.Versions[j].Version) > 0
		})

		o.TypeMeta = metav1.TypeMeta{}
		var name string