"deletecollection",
        "get",
        "list",
        "patch",
        "update",
        "watch"
      ]
    },
    {
      "kind": "ResourceClass",
      "name": "resourceclasses",
      "namespaced": false,
      "singularName": "resourceclass",
      "storageVersionHash": "wkt0Tpte++U=",
      "verbs": [
        "create",
        "delete",
        "deletecollection",
        "get",

		NewListFunc:               func() runtime.Object { return &resource.ResourceClassList{} },
		DefaultQualifiedResource:  resource.Resource("resourceclasses"),
		SingularQualifiedResource: resource.Resource("resourceclass"),

		CreateStrategy:      resourceclass.Strategy,
		UpdateStrategy:      resourceclass.Strategy,
		DeleteStrategy:      resourceclass.Strategy,
		ReturnDeletedObject: true,

	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store).ClusterScope()
	resourceClass := validNewClass("foo")
	resourceClass.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo"}
	test.TestCreate(
		// valid
		resourceClass,
		// invalid
		&resource.ResourceClass{
			ObjectMeta: metav1.ObjectMeta{Name: "*BadName!"},
		},
	)
}

func TestUpdate(t *testing.T) {

	storage := map[string]rest.Storage{}

	if resource := "resourceclasses"; apiResourceConfigSource.ResourceEnabled(resourcev1alpha2.SchemeGroupVersion.WithResource(resource)) {
		resourceClassStorage, err := resourceclassstore.NewREST(restOptionsGetter)
		if err != nil {
			return nil, err
		}

              ]
            },
            {
              "resource": "resourceclasses",
              "responseKind": {
                "group": "",
                "kind": "ResourceClass",
                "version": ""
              },
              "scope": "Cluster",
              "singularResource": "resourceclass",
              "verbs": [
                "create",
                "delete",

              ]
            },
            {
              "resource": "resourceclasses",
              "responseKind": {
                "group": "",
                "kind": "ResourceClass",
                "version": ""
              },
              "scope": "Cluster",
              "singularResource": "resourceclass",
              "verbs": [
                "create",
                "delete",

				}
				handlers = append(handlers, handlerRegistration)
			}
		case framework.ResourceClass:
			if utilfeature.DefaultFeatureGate.Enabled(features.DynamicResourceAllocation) {
				if handlerRegistration, err = informerFactory.Resource().V1alpha2().ResourceClasses().Informer().AddEventHandler(
					buildEvtResHandler(at, framework.ResourceClass, "ResourceClass"),
				); err != nil {
					return err
				}

	if utilfeature.DefaultFeatureGate.Enabled(features.DynamicResourceAllocation) {
		kubeSchedulerRules = append(kubeSchedulerRules,
			rbacv1helpers.NewRule(Read...).Groups(resourceGroup).Resources("resourceclasses").RuleOrDie(),
			rbacv1helpers.NewRule(ReadUpdate...).Groups(resourceGroup).Resources("resourceclaims").RuleOrDie(),
			rbacv1helpers.NewRule(ReadUpdate...).Groups(resourceGroup).Resources("resourceclaims/status").RuleOrDie(),

	claimName2    = podName + "-" + resourceName + "-2"
	className     = "my-resource-class"
	namespace     = "default"

	resourceClass = &resourcev1alpha2.ResourceClass{
		ObjectMeta: metav1.ObjectMeta{
			Name: className,
		},
		DriverName: "some-driver",
	}
	structuredResourceClass = &resourcev1alpha2.ResourceClass{
		ObjectMeta: metav1.ObjectMeta{
			Name: className,
		},
		DriverName:           "some-driver",

		clientset:                  fh.ClientSet(),
		claimLister:                fh.SharedInformerFactory().Resource().V1alpha2().ResourceClaims().Lister(),
		classLister:                fh.SharedInformerFactory().Resource().V1alpha2().ResourceClasses().Lister(),
		podSchedulingContextLister: fh.SharedInformerFactory().Resource().V1alpha2().PodSchedulingContexts().Lister(),