func (obj *TypeMeta) GetObjectKind() schema.ObjectKind { return obj }

// SetGroupVersionKind satisfies the ObjectKind interface for all objects that embed TypeMeta
func (obj *TypeMeta) SetGroupVersionKind(gvk schema.GroupVersionKind) {
	obj.APIVersion, obj.Kind = gvk.ToAPIVersionAndKind()
}

// GroupVersionKind satisfies the ObjectKind interface for all objects that embed TypeMeta

        versions: [PREFER_11, RANGE_10_11, PREFER_13, RANGE_10_14],
        expected: "11"
    ).and(
        versions: [PREFER_7_8, FIXED_12],  // No version satisfies the range [7,8]
        expected: FAILED
    ).and(
        versions: [PREFER_14_16, FIXED_12], // No version satisfies the range [14,16]
        expected: FAILED
    ).and(
        versions: [PREFER_12, RANGE_10_11],
        expected: "11",

"""

        lockfileFixture.createLockfile('lockedConf',['org:foo:1.0'], unique)

        when:
        fails 'checkDeps'

        then:
        failure.assertHasCause """Cannot find a version of 'org:foo' that satisfies the version constraints:
   Dependency path ':depLock:unspecified' --> 'org:foo:1.+'
   Dependency path ':depLock:unspecified' --> 'org:foo:{strictly 1.1}'

	for _, t := range a.Tags {
		if _, has := x[t.Key]; has {
			return true
		}
		x[t.Key] = struct{}{}
	}

	return false
}

// BySize returns true when sz satisfies a
// ObjectSizeLessThan/ObjectSizeGreaterthan or a logical AND of these predicates
// Note: And combines size and other predicates like Tags, Prefix, etc. This
// method applies exclusively to size predicates only.

        if (hasRejectAll) {
            sb.append("Module '").append(module.getId()).append("' has been rejected:\n");
        } else {
            sb.append("Cannot find a version of '").append(module.getId()).append("' that satisfies the version constraints:\n");
        }

        Set<EdgeState> allEdges = new LinkedHashSet<>();
        allEdges.addAll(module.getIncomingEdges());
        allEdges.addAll(module.getUnattachedDependencies());

		return Selector{}, fmt.Errorf("conflicting selector specification: %q", s)
	}

	return NewSelector(present, absent), nil
}

// Selects returns true, if the given label set satisfies the Selector.
func (f *Selector) Selects(inputs Set) bool {
	return !inputs.containsAny(f.absent) && inputs.containsAll(f.present)
}

	contentTypeHdr = strings.Replace(contentTypeHdr, "multipart/form-data", "multipart/form-datA", 1)
	req.Header.Set("Content-Type", contentTypeHdr)
	req.Header.Set("User-Agent", "Mozilla")

	// Since `apiRouter` satisfies `http.Handler` it has a ServeHTTP to execute the logic of the handler.
	// Call the ServeHTTP to execute the handler.
	apiRouter.ServeHTTP(rec, req)

	ctx, cancel := context.WithCancel(GlobalContext)
	defer cancel()

// This is an initial implementation, but it will be replaced with something
// that admits incremental immutable modification more efficiently.
type labelMap map[string]string

// String satisfies Stringer and returns key, value pairs in a consistent
// order.
func (l *labelMap) String() string {
	if l == nil {
		return ""
	}
	keyVals := make([]string, 0, len(*l))

	for k, v := range *l {

        when:
        allowAllRepositoryInteractions()
        fails ':checkDeps'

        then:
        failure.assertHasCause """Cannot find a version of 'org:databind' that satisfies the version constraints:"""

        where:
        dep1           | v1      | dep2           | v2
        'org:core'     | '2.9.4' | 'org:databind' | '2.7.9'
        'org:databind' | '2.7.9' | 'org:core'     | '2.9.4'

the prefix `user-uploads/` as soon as the latest object satisfies the expiration criteria. 

> NOTE: If the latest object is a delete marker then filtering based on `Filter.Tags` is ignored and 
> if the DELETE marker modTime satisfies the `Expiration.Days` then all versions of the object are 
> immediately purged.

```
{
    "Rules": [
        {