storageClass := validNewStorageClass("foo")
	storageClass.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo"}
	deleteReclaimPolicy := api.PersistentVolumeReclaimDelete
	test.TestCreate(
		// valid
		storageClass,
		// invalid
		&storageapi.StorageClass{
			ObjectMeta:    metav1.ObjectMeta{Name: "*BadName!"},
			ReclaimPolicy: &deleteReclaimPolicy,
		},
	)
}

func TestUpdate(t *testing.T) {

	"storage.k8s.io/v1/csidrivers":                                      "hL6j/rwBV5w=",
	"storage.k8s.io/v1/csinodes":                                        "Pe62DkZtjuo=",
	"storage.k8s.io/v1/storageclasses":                                  "K+m6uJwbjGY=",
	"storage.k8s.io/v1/csistoragecapacities":                            "xeVl+2Ly1kE=",
	"storage.k8s.io/v1/volumeattachments":                               "tJx/ezt6UDU=",

	if err != nil {
		t.Fatalf("neither pv lister nor storageclass lister can be nil")
	}

	scs := []*storagev1.StorageClass{}
	scs = append(scs, goldClass, silverClass)
	for _, sc := range scs {
		err := informerFactory.Storage().V1().StorageClasses().Informer().GetStore().Add(sc)
		if err != nil {
			fmt.Println("add storageclass error: ", err)
		}
	}

	for _, tc := range tests {

var class2Parameters = map[string]string{
	"param2": "value2",
}
var deleteReclaimPolicy = v1.PersistentVolumeReclaimDelete
var modeImmediate = storage.VolumeBindingImmediate
var storageClasses = []*storage.StorageClass{
	{
		TypeMeta: metav1.TypeMeta{
			Kind: "StorageClass",
		},

		ObjectMeta: metav1.ObjectMeta{
			Name: "gold",
		},

		Provisioner:       mockPluginName,
		Parameters:        class1Parameters,

	classWithNoDefault := &storagev1.StorageClass{
		TypeMeta: metav1.TypeMeta{
			Kind: "StorageClass",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name: "nondefault2",
		},
		Provisioner: "nondefault1",
	}
	// Class with empty default annotation (=non-default)
	classWithEmptyDefault := &storagev1.StorageClass{
		TypeMeta: metav1.TypeMeta{
			Kind: "StorageClass",
		},
		ObjectMeta: metav1.ObjectMeta{

//     controllerTest.testCall *once*.
//  3. Compare resulting volumes and claims with expected volumes and claims.
func runSyncTests(t *testing.T, ctx context.Context, tests []controllerTest, storageClasses []*storage.StorageClass, pods []*v1.Pod) {
	doit := func(t *testing.T, test controllerTest) {
		// Initialize the controller
		client := &fake.Clientset{}
		ctrl, err := newTestController(ctx, client, nil, true)

				`storageclasses.storage.k8s.io "Class_0" not found`),
			wantFilterStatus: framework.NewStatus(framework.UnschedulableAndUnresolvable,
				`storageclasses.storage.k8s.io "Class_0" not found`),
		},
		{
			name:                "unbound volume immediate binding mode",
			Pod:                 createPodWithVolume("pod_1", "PVC_ImmediateSC"),
			Node:                testNode,

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

			t.Log("Feed testing data and wait for them to be synced")
			client.StorageV1().StorageClasses().Create(ctx, immediateSC, metav1.CreateOptions{})
			client.StorageV1().StorageClasses().Create(ctx, waitSC, metav1.CreateOptions{})
			client.StorageV1().StorageClasses().Create(ctx, waitHDDSC, metav1.CreateOptions{})
			for _, node := range item.nodes {

    - update
  - apiGroups:
    - ""
    resources:
    - persistentvolumeclaims
    verbs:
    - get
    - list
    - watch
  - apiGroups:
    - storage.k8s.io
    resources:
    - storageclasses
    verbs:
    - get
    - list
    - watch
  - apiGroups:
    - ""
    resources:
    - endpoints
    - services
    verbs:
    - get
  - apiGroups:
    - ""

	logger := sched.logger
	sc, ok := obj.(*storagev1.StorageClass)
	if !ok {
		logger.Error(nil, "Cannot convert to *storagev1.StorageClass", "obj", obj)
		return
	}

	// CheckVolumeBindingPred fails if pod has unbound immediate PVCs. If these
	// PVCs have specified StorageClass name, creating StorageClass objects
	// with late binding will cause predicates to pass, so we need to move pods