store := &genericregistry.Store{
		NewFunc:                   func() runtime.Object { return &storageapi.CSIDriver{} },
		NewListFunc:               func() runtime.Object { return &storageapi.CSIDriverList{} },
		DefaultQualifiedResource:  storageapi.Resource("csidrivers"),
		SingularQualifiedResource: storageapi.Resource("csidriver"),

		CreateStrategy:      csidriver.Strategy,
		UpdateStrategy:      csidriver.Strategy,

		return genericapiserver.APIGroupInfo{}, err
	} else if len(storageMap) > 0 {
		apiGroupInfo.VersionedResourcesStorageMap[storageapiv1alpha1.SchemeGroupVersion.Version] = storageMap
	}
	if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
		return genericapiserver.APIGroupInfo{}, err
	} else if len(storageMap) > 0 {

	store := &genericregistry.Store{
		NewFunc:                   func() runtime.Object { return &storageapi.VolumeAttributesClass{} },
		NewListFunc:               func() runtime.Object { return &storageapi.VolumeAttributesClassList{} },
		DefaultQualifiedResource:  storageapi.Resource("volumeattributesclasses"),
		SingularQualifiedResource: storageapi.Resource("volumeattributesclass"),

		CreateStrategy:      volumeattributesclass.Strategy,

}

func validNewVolumeAttachment(name string) *storageapi.VolumeAttachment {
	pvName := "foo"
	return &storageapi.VolumeAttachment{
		ObjectMeta: metav1.ObjectMeta{
			Name: name,
		},
		Spec: storageapi.VolumeAttachmentSpec{
			Attacher: "valid-attacher",
			Source: storageapi.VolumeAttachmentSource{
				PersistentVolumeName: &pvName,
			},
			NodeName: "valid-node",
		},

		NewFunc:                   func() runtime.Object { return &storageapi.CSIStorageCapacity{} },
		NewListFunc:               func() runtime.Object { return &storageapi.CSIStorageCapacityList{} },
		DefaultQualifiedResource:  storageapi.Resource("csistoragecapacities"),
		SingularQualifiedResource: storageapi.Resource("csistoragecapacity"),

		TableConvertor: rest.NewDefaultTableConvertor(storageapi.Resource("csistoragecapacities")),

	}
	return csiDriverStorage.CSIDriver, server
}

func validNewCSIDriver(name string) *storageapi.CSIDriver {
	attachRequired := true
	podInfoOnMount := true
	requiresRepublish := true
	storageCapacity := true
	seLinuxMount := true
	return &storageapi.CSIDriver{
		ObjectMeta: metav1.ObjectMeta{
			Name: name,
		},
		Spec: storageapi.CSIDriverSpec{
			AttachRequired:    &attachRequired,
			PodInfoOnMount:    &podInfoOnMount,

	store := &genericregistry.Store{
		NewFunc:                   func() runtime.Object { return &storageapi.StorageClass{} },
		NewListFunc:               func() runtime.Object { return &storageapi.StorageClassList{} },
		DefaultQualifiedResource:  storageapi.Resource("storageclasses"),
		SingularQualifiedResource: storageapi.Resource("storageclass"),

		CreateStrategy:      storageclass.Strategy,

	store := &genericregistry.Store{
		NewFunc:                   func() runtime.Object { return &storageapi.VolumeAttachment{} },
		NewListFunc:               func() runtime.Object { return &storageapi.VolumeAttachmentList{} },
		DefaultQualifiedResource:  storageapi.Resource("volumeattachments"),
		SingularQualifiedResource: storageapi.Resource("volumeattachment"),

		CreateStrategy:      volumeattachment.Strategy,

// NewMultipartUpload metadata shuffling.
func shuffleDisksAndPartsMetadataByIndex(disks []StorageAPI, metaArr []FileInfo, fi FileInfo) (shuffledDisks []StorageAPI, shuffledPartsMetadata []FileInfo) {
	shuffledDisks = make([]StorageAPI, len(disks))
	shuffledPartsMetadata = make([]FileInfo, len(disks))
	distribution := fi.Erasure.Distribution

	var inconsistent int

	store := &genericregistry.Store{
		NewFunc:                   func() runtime.Object { return &storageapi.CSINode{} },
		NewListFunc:               func() runtime.Object { return &storageapi.CSINodeList{} },
		DefaultQualifiedResource:  storageapi.Resource("csinodes"),
		SingularQualifiedResource: storageapi.Resource("csinode"),

		CreateStrategy:      csinode.Strategy,
		UpdateStrategy:      csinode.Strategy,