photonPersistentDisk:
    fsType: fsTypeValue
    pdID: pdIDValue
  portworxVolume:
    fsType: fsTypeValue
    readOnly: true
    volumeID: volumeIDValue
  quobyte:
    group: groupValue
    readOnly: true
    registry: registryValue
    tenant: tenantValue
    user: userValue
    volume: volumeValue
  rbd:
    fsType: fsTypeValue
    image: imageValue

          "cachingMode": "cachingModeValue",
          "fsType": "fsTypeValue",
          "readOnly": true,
          "kind": "kindValue"
        },
        "photonPersistentDisk": {
          "pdID": "pdIDValue",
          "fsType": "fsTypeValue"
        },
        "portworxVolume": {
          "volumeID": "volumeIDValue",
          "fsType": "fsTypeValue",
          "readOnly": true
        },

    inlineVolumeSpec:
      accessModes:
      - accessModesValue
      awsElasticBlockStore:
        fsType: fsTypeValue
        partition: 3
        readOnly: true
        volumeID: volumeIDValue
      azureDisk:
        cachingMode: cachingModeValue
        diskName: diskNameValue
        diskURI: diskURIValue
        fsType: fsTypeValue
        kind: kindValue
        readOnly: true
      azureFile:
        readOnly: true

    inlineVolumeSpec:
      accessModes:
      - accessModesValue
      awsElasticBlockStore:
        fsType: fsTypeValue
        partition: 3
        readOnly: true
        volumeID: volumeIDValue
      azureDisk:
        cachingMode: cachingModeValue
        diskName: diskNameValue
        diskURI: diskURIValue
        fsType: fsTypeValue
        kind: kindValue
        readOnly: true
      azureFile:
        readOnly: true

	"testing"

	"github.com/minio/minio/internal/disk"
)

func TestFree(t *testing.T) {
	di, err := disk.GetInfo(t.TempDir(), true)
	if err != nil {
		t.Fatal(err)
	}

	if di.FSType == "UNKNOWN" {
		t.Error("Unexpected FSType", di.FSType)
	}

	if err != nil {
		return nil, err
	}

	klog.V(5).Infof("iscsi: VolumeSpecToMounter volumeMode %s", volumeMode)
	return &iscsiDiskMounter{
		iscsiDisk:  iscsiDisk,
		fsType:     fsType,
		volumeMode: volumeMode,
		readOnly:   readOnly,
		mounter:    &mount.SafeFormatAndMount{Interface: host.GetMounter(iscsiPluginName), Exec: exec},
		exec:       exec,

// Files - total inodes available
// Ffree - free inodes available
// FSType - file system type
// Major - major dev id
// Minor - minor dev id
// Devname - device name
type Info struct {
	Total      uint64
	Free       uint64
	Used       uint64
	Files      uint64
	Ffree      uint64
	FSType     string
	Major      uint32
	Minor      uint32
	Name       string
	Rotational *bool

		volumePath:        resizeOptions.DeviceMountPath,
		stagingTargetPath: resizeOptions.DeviceStagePath,
		volumeID:          csiSource.VolumeHandle,
		newSize:           resizeOptions.NewSize,
		fsType:            csiSource.FSType,
		accessMode:        api.ReadWriteOnce,
		mountOptions:      pv.Spec.MountOptions,
		secrets:           nodeExpandSecrets,
	}

	if !fsVolume {

			template: &api.PersistentVolume{
				Spec: api.PersistentVolumeSpec{
					PersistentVolumeSource: api.PersistentVolumeSource{
						PhotonPersistentDisk: &api.PhotonPersistentDiskVolumeSource{
							PdID:   "",
							FSType: "",
						},
					},
				},
			},
			expected: []string{
				`spec.photonPersistentDisk: deprecated in v1.11, non-functional in v1.16+`,
			},
		},
		{
			name: "PV RBD deprecation warning",

		err := v.DecodeMsg(dc)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkDecodeDiskInfoMsgp(b *testing.B) {
	v := DiskInfo{
		Total:     1000,
		Free:      1000,
		Used:      1000,
		FSType:    "xfs",
		RootDisk:  true,
		Healing:   true,
		Endpoint:  "http://localhost:9001/tmp/drive1",
		MountPath: "/tmp/drive1",
		ID:        "uuid",
		Error:     "",
	}
	var buf bytes.Buffer