"kind": "kindValue",
      "name": "nameValue"
    },
    "allocationMode": "allocationModeValue"
  },
  "status": {
    "driverName": "driverNameValue",
    "allocation": {
      "resourceHandles": [
        {
          "driverName": "driverNameValue",
          "data": "dataValue",
          "structuredData": {
            "vendorClassParameters": {
              "apiVersion": "example.com/v1",

message ResourceHandle {
  // 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.
  optional string driverName = 1;

          - valuesValue
        matchFields:
        - key: keyValue
          operator: operatorValue
          values:
          - valuesValue
    resourceHandles:
    - data: dataValue
      driverName: driverNameValue
      structuredData:
        nodeName: nodeNameValue
        results:
        - namedResources:
            name: nameValue
          vendorRequestParameters:
            apiVersion: example.com/v1

			if data[volDataKey.volHandle] != csiMounter.volumeID {
				t.Error("volume data file unexpected volHandle:", data[volDataKey.volHandle])
			}
			if data[volDataKey.driverName] != string(csiMounter.driverName) {
				t.Error("volume data file unexpected driverName:", data[volDataKey.driverName])
			}
			if data[volDataKey.nodeName] != string(csiMounter.plugin.host.GetNodeName()) {

  },
  "vendorParameters": [
    {
      "driverName": "driverNameValue",
      "parameters": {
        "apiVersion": "example.com/v1",
        "kind": "CustomType",
        "spec": {
          "replicas": 1
        },
        "status": {
          "available": 1
        }
      }
    }
  ],
  "filters": [
    {
      "driverName": "driverNameValue",
      "namedResources": {

        matchFields:
        - key: keyValue
          operator: operatorValue
          values:
          - valuesValue
    resourceHandles:
    - data: dataValue
      driverName: driverNameValue
    shareable: true
  deallocationRequested: true
  driverName: driverNameValue
  reservedFor:
  - apiGroup: apiGroupValue
    name: nameValue
    resource: resourceValue

		t.Errorf("VolumeAttributesClassStrategy should not allow create on update")
	}

	class := &storage.VolumeAttributesClass{
		ObjectMeta: metav1.ObjectMeta{
			Name: "valid-class",
		},
		DriverName: "fake",
		Parameters: map[string]string{
			"foo": "bar",
		},
	}

	Strategy.PrepareForCreate(ctx, class)

	errs := Strategy.Validate(ctx, class)
	if len(errs) != 0 {

	// kubelet plugin whose name matches resourceClaim.Status.DriverName.
	resourceHandles := claim.Status.Allocation.ResourceHandles
	if len(resourceHandles) == 0 {
		resourceHandles = make([]resourcev1alpha2.ResourceHandle, 1)
	}
	claimInfoState := state.ClaimInfoState{
		DriverName:      claim.Status.DriverName,
		ClassName:       claim.Spec.ResourceClassName,
		ClaimUID:        claim.UID,

	}

	pvName := pv.GetName()
	nodeName := string(plug.host.GetNodeName())

	csiMapper.csiClient = setupClient(t, true)

	attachID := getAttachmentName(csiMapper.volumeID, string(csiMapper.driverName), string(nodeName))
	attachment := makeTestAttachment(attachID, nodeName, pvName)
	attachment.Status.Attached = true

				return err
			}
		}

		driverName, volumeHandle := pl.getCSIDriverInfo(logger, csiNode, pvc)
		if driverName == "" || volumeHandle == "" {
			logger.V(5).Info("Could not find a CSI driver name or volume handle, not counting volume")
			continue
		}

		volumeUniqueName := fmt.Sprintf("%s/%s", driverName, volumeHandle)
		volumeLimitKey := volumeutil.GetCSIAttachLimitKey(driverName)
		result[volumeUniqueName] = volumeLimitKey