if err != nil {
		t.Fatal(err)
	}
	defer tearDownFn()

	crd := pruningFixture.DeepCopy()
	crd.Spec.Versions[0].Schema = &apiextensionsv1.CustomResourceValidation{}
	if err := yaml.Unmarshal([]byte(fooSchema), &crd.Spec.Versions[0].Schema.OpenAPIV3Schema); err != nil {
		t.Fatal(err)
	}

	crd, err = fixtures.CreateNewV1CustomResourceDefinition(crd, apiExtensionClient, dynamicClient)

        fails ':checkDeps'

        then:
        failure.assertHasCause("Could not resolve org:test:$selector1: Resolution strategy disallows usage of dynamic versions")
        failure.assertHasCause("Could not resolve org:test:$selector2: Resolution strategy disallows usage of dynamic versions")

        where:
        selector1        | selector2
        '[1.0, 2.0['     | '[1.0, 1.5['
        latestNotation() | '1.1'

	// Versions is the list of all supported versions for this resource.
	// If Version field is provided, this field is optional.
	// Validation: All versions must use the same validation schema for now. i.e., top
	// level Validation field is applied to all of these versions.
	// Order: The version name will be used to compute the order.
	// If the version string is "kube-like", it will sort above non "kube-like" version strings, which are ordered

    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:

- Existing or newer buckets can be created with versioning enabled and eventually can be suspended as well. Existing versions of objects stay as is and can still be accessed using the version ID.
- All versions, including delete-markers should be deleted before deleting a bucket.

			return
		}

		checksumOk := func(suffix string) bool {
			return rs == nil || m.Version == "" || !mustHaveSums() ||
				modfetch.HaveSum(module.Version{Path: m.Path, Version: m.Version + suffix})
		}

		mod := module.Version{Path: m.Path, Version: m.Version}

		if m.Version != "" {
			if old := reuse[mod]; old != nil {
				if err := checkReuse(ctx, mod, old.Origin); err == nil {
					*m = *old

			versions:  []string{"v1beta"},
			result:    nil,
			err:       &NoKindMatchError{GroupKind: schema.GroupKind{Kind: "Foo"}, SearchedVersions: []string{"v1beta"}},
		},
		{
			name:      "empty with multi(two) vesions",
			mapper:    MultiRESTMapper{},
			groupKind: schema.GroupKind{Kind: "Foo"},
			versions:  []string{"v1beta", "v2"},
			result:    nil,

echo "Verifying ETag for all objects"
./s3-check-md5 -versions -access-key minio -secret-key minio123 -endpoint http://127.0.0.1:9001/ -bucket bucket
./s3-check-md5 -versions -access-key minio -secret-key minio123 -endpoint http://127.0.0.1:9002/ -bucket bucket
./s3-check-md5 -versions -access-key minio -secret-key minio123 -endpoint http://127.0.0.1:9003/ -bucket bucket

     * If this method is called, Gradle will make sure that no dynamic version was used in the resulting dependency graph.
     * In practice, it means that if the resolved dependency graph contains a module and that the versions participating
     * in the selection of that module contain at least one dynamic version, then resolution will fail if the resolution
     * result can change because of this version selector.
     *

					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 {