EphemeralVolumeController                    = "ephemeral-volume-controller"
	StorageVersionGarbageCollectorController     = "storageversion-garbage-collector-controller"
	ResourceClaimController                      = "resourceclaim-controller"
	LegacyServiceAccountTokenCleanerController   = "legacy-serviceaccount-token-cleaner-controller"
	ValidatingAdmissionPolicyStatusController    = "validatingadmissionpolicy-status-controller"

	claimName := "test-claim"

	for _, test := range []struct {
		description    string
		claim          *resourcev1alpha2.ResourceClaim
		expectedResult *ClaimInfo
	}{
		{
			description: "successfully created object",
			claim: &resourcev1alpha2.ResourceClaim{
				ObjectMeta: metav1.ObjectMeta{
					UID:       claimUID,
					Name:      claimName,
					Namespace: namespace,
				},

type podSchedulingStrategy struct {
	runtime.ObjectTyper
	names.NameGenerator
}

// Strategy is the default logic that applies when creating and updating
// ResourceClaim objects via the REST API.
var Strategy = podSchedulingStrategy{legacyscheme.Scheme, names.SimpleNameGenerator}

func (podSchedulingStrategy) NamespaceScoped() bool {
	return true
}

		// This plugin should come before DefaultPreemption because if
		// there is a problem with a Pod and PostFilter gets called to
		// resolve the problem, it is better to first deallocate an
		// idle ResourceClaim than it is to evict some Pod that might
		// be doing useful work.
		for i := range config.MultiPoint.Enabled {
			if config.MultiPoint.Enabled[i].Name == names.DefaultPreemption {

func (m *ResourceClaim) Reset()      { *m = ResourceClaim{} }
func (*ResourceClaim) ProtoMessage() {}
func (*ResourceClaim) Descriptor() ([]byte, []int) {
	return fileDescriptor_4312f5b44a31ec02, []int{17}
}
func (m *ResourceClaim) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ResourceClaim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

	CSIStorageCapacity      GVK = "storage.k8s.io/CSIStorageCapacity"
	StorageClass            GVK = "storage.k8s.io/StorageClass"
	PodSchedulingContext    GVK = "PodSchedulingContext"
	ResourceClaim           GVK = "ResourceClaim"
	ResourceClass           GVK = "ResourceClass"
	ResourceClaimParameters GVK = "ResourceClaimParameters"
	ResourceClassParameters GVK = "ResourceClassParameters"

	// WildCard is a special GVK to match all resources.

		{Group: "rbac.authorization.k8s.io", Version: "v1", Kind: "RoleBindingList"}:                               {},
		{Group: "resource.k8s.io", Version: "v1alpha2", Kind: "ResourceClaim"}:                                     {},
		{Group: "resource.k8s.io", Version: "v1alpha2", Kind: "ResourceClaimList"}:                                 {},

	//
	// +featureGate=DynamicResourceAllocation
	// +optional
	ResourceClaims []PodResourceClaim
}

// PodResourceClaim references exactly one ResourceClaim through a ClaimSource.
// It adds a name to it that uniquely identifies the ResourceClaim inside the Pod.
// Containers that need access to the ResourceClaim reference it with this name.
type PodResourceClaim struct {

  //
  // The template will be used to create a new ResourceClaim, which will
  // be bound to this pod. When this pod is deleted, the ResourceClaim
  // will also be deleted. The name of the ResourceClaim will be <pod
  // name>-<resource name>, where <resource name> is the
  // PodResourceClaim.Name. Pod validation will reject the pod if the
  // concatenated name is not valid for a ResourceClaim (e.g. too long).
  //

					{PluginName: filterWithoutEnqueueExtensions, QueueingHintFn: defaultQueueingHintFn},
				},
				{Resource: framework.ResourceClaim, ActionType: framework.All}: {
					{PluginName: filterWithoutEnqueueExtensions, QueueingHintFn: defaultQueueingHintFn},
				},
				{Resource: framework.ResourceClass, ActionType: framework.All}: {
					{PluginName: filterWithoutEnqueueExtensions, QueueingHintFn: defaultQueueingHintFn},
				},