if csiLimitKeyLonger != expectedCSIKey {
		t.Errorf("Expected limit to be %s got %s", expectedCSIKey, csiLimitKeyLonger)
	}
}

func getDriverHash(driverName string) string {
	charsFromDriverName := driverName[:23]
	hash := sha1.New()
	hash.Write([]byte(driverName))
	hashed := hex.EncodeToString(hash.Sum(nil))
	hashed = hashed[:16]
	return CSIAttachLimitPrefix + charsFromDriverName + hashed

type ResourceHandle struct {
	// DriverName specifies the name of the resource driver whose kubelet
	// plugin should be invoked to process this ResourceHandle's data once it
	// lands on a node. This may differ from the DriverName set in
	// ResourceClaimStatus this ResourceHandle is embedded in.
	DriverName string `json:"driverName" protobuf:"bytes,1,name=driverName"`

)

// GetCSIAttachLimitKey returns limit key used for CSI volumes
func GetCSIAttachLimitKey(driverName string) string {
	csiPrefixLength := len(CSIAttachLimitPrefix)
	totalkeyLength := csiPrefixLength + len(driverName)
	if totalkeyLength >= ResourceNameLengthLimit {
		charsFromDriverName := driverName[:23]
		hash := sha1.New()
		hash.Write([]byte(driverName))
		hashed := hex.EncodeToString(hash.Sum(nil))
		hashed = hashed[:16]

import (
	"k8s.io/mount-utils"
	utilstrings "k8s.io/utils/strings"

	"k8s.io/apimachinery/pkg/types"
	"k8s.io/kubernetes/pkg/volume"
)

type flexVolume struct {
	// driverName is the name of the plugin driverName.
	driverName string
	// Driver executable used to setup the volume.
	execPath string
	// mounter provides the interface that is used to mount the actual
	// block device.
	mounter mount.Interface

	os.Exit(m.Run())
}

func makeTestPVWithMountOptions(name string, sizeGig int, driverName, volID string, mountOptions []string) *api.PersistentVolume {
	pv := makeTestPV(name, sizeGig, driverName, volID)
	pv.Spec.MountOptions = mountOptions
	return pv
}

func makeTestPV(name string, sizeGig int, driverName, volID string) *api.PersistentVolume {
	return &api.PersistentVolume{
		ObjectMeta: meta.ObjectMeta{

				parameters.DriverRequests = []resource.DriverRequests{{DriverName: goodName}}
				return parameters
			}(),
		},

		"invalid-driver": {

type ResourceHandle struct {
	// DriverName specifies the name of the resource driver whose kubelet
	// plugin should be invoked to process this ResourceHandle's data once it
	// lands on a node. This may differ from the DriverName set in
	// ResourceClaimStatus this ResourceHandle is embedded in.
	DriverName string

	// Data contains the opaque data associated with this ResourceHandle. It is

apiVersion: resource.k8s.io/v1alpha2
filters:
- driverName: driverNameValue
  namedResources:
    selector: selectorValue
generatedFrom:
  apiGroup: apiGroupValue
  kind: kindValue
  name: nameValue
  namespace: namespaceValue
kind: ResourceClassParameters
metadata:
  annotations:
    annotationsKey: annotationsValue
  creationTimestamp: "2008-01-01T01:01:01Z"
  deletionGracePeriodSeconds: 10
  deletionTimestamp: "2009-01-01T01:01:01Z"

					},
				},
			},
		},
		{
			name:         "empty node ID",
			driverName:   "com.example.csi.driver1",
			existingNode: generateNode(nil /* nodeIDs */, nil /* labels */, nil /*capacity*/),
			inputNodeID:  "",
			expectFail:   true,
		},
		{
			name:             "new node with valid max limit of volumes",
			driverName:       "com.example.csi.driver1",

					DriverName: driverName,
					Allocation: &resourcev1alpha2.AllocationResult{
						ResourceHandles: []resourcev1alpha2.ResourceHandle{},
					},
				},
				Spec: resourcev1alpha2.ResourceClaimSpec{
					ResourceClassName: className,
				},
			},
			expectedResult: &ClaimInfo{
				ClaimInfoState: state.ClaimInfoState{
					DriverName: driverName,
					ClassName:  className,