NewListFunc:               func() runtime.Object { return &resource.ResourceClaimList{} },
		PredicateFunc:             resourceclaim.Match,
		DefaultQualifiedResource:  resource.Resource("resourceclaims"),
		SingularQualifiedResource: resource.Resource("resourceclaim"),

		CreateStrategy:      resourceclaim.Strategy,
		UpdateStrategy:      resourceclaim.Strategy,

        "deletecollection",
        "get",
        "list",
        "patch",
        "update",
        "watch"
      ]
    },
    {
      "kind": "ResourceClaim",
      "name": "resourceclaims",
      "namespaced": true,
      "singularName": "resourceclaim",
      "storageVersionHash": "sMQbgChfibk=",
      "verbs": [
        "create",
        "delete",
        "deletecollection",
        "get",
        "list",

	if !Strategy.NamespaceScoped() {
		t.Errorf("ResourceClaim must be namespace scoped")
	}
	if Strategy.AllowCreateOnUpdate() {
		t.Errorf("ResourceClaim should not allow create on update")
	}
}

func TestClaimStrategyCreate(t *testing.T) {
	ctx := genericapirequest.NewDefaultContext()
	resourceClaim := resourceClaim.DeepCopy()

	Strategy.PrepareForCreate(ctx, resourceClaim)
	errs := Strategy.Validate(ctx, resourceClaim)

	newClaim := obj.(*resource.ResourceClaim)
	oldClaim := old.(*resource.ResourceClaim)
	newClaim.Status = oldClaim.Status
}

func (resourceclaimStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList {
	newClaim := obj.(*resource.ResourceClaim)
	oldClaim := old.(*resource.ResourceClaim)
	errorList := validation.ValidateClaim(newClaim)

		DeleteCollectionWorkers: 1,
		ResourcePrefix:          "resourceclaims",
	}
	resourceClaimStorage, statusStorage, err := NewREST(restOptions)
	if err != nil {
		t.Fatalf("unexpected error from REST storage: %v", err)
	}
	return resourceClaimStorage, statusStorage, server
}

func validNewClaim(name, ns string) *resource.ResourceClaim {
	claim := &resource.ResourceClaim{
		ObjectMeta: metav1.ObjectMeta{
			Name:      name,

	_ "k8s.io/kubernetes/pkg/apis/resource/install"
)

func TestSetDefaultAllocationMode(t *testing.T) {
	claim := &v1alpha2.ResourceClaim{}

	// field should be defaulted
	defaultMode := v1alpha2.AllocationModeWaitForFirstConsumer
	output := roundTrip(t, runtime.Object(claim)).(*v1alpha2.ResourceClaim)
	outMode := output.Spec.AllocationMode
	if outMode != defaultMode {

	}
}

func TestCodec(t *testing.T) {
	claim := internal.ResourceClaim{}
	data, err := runtime.Encode(legacyscheme.Codecs.LegacyCodec(schema.GroupVersion{Group: "resource.k8s.io", Version: "v1alpha2"}), &claim)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	other := internal.ResourceClaim{}
	if err := json.Unmarshal(data, &other); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	"k8s.io/component-base/metrics"
	"k8s.io/component-base/metrics/legacyregistry"
)

// ResourceClaimSubsystem - subsystem name used for ResourceClaim creation
const ResourceClaimSubsystem = "resourceclaim_controller"

var (
	// ResourceClaimCreateAttempts tracks the number of
	// ResourceClaims().Create calls (both successful and unsuccessful)
	ResourceClaimCreateAttempts = metrics.NewCounter(
		&metrics.CounterOpts{

// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
	scheme.AddTypeDefaultingFunc(&v1alpha2.ResourceClaim{}, func(obj interface{}) { SetObjectDefaults_ResourceClaim(obj.(*v1alpha2.ResourceClaim)) })
	scheme.AddTypeDefaultingFunc(&v1alpha2.ResourceClaimList{}, func(obj interface{}) { SetObjectDefaults_ResourceClaimList(obj.(*v1alpha2.ResourceClaimList)) })

limitations under the License.
*/

// Package resourceclaim implements the controller part of
// https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/3063-dynamic-resource-allocation
//
// It was derived from the generic ephemeral volume controller.