func (m *MockProvider) ListVolumesForPod(podUID types.UID) (map[string]volume.Volume, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVolumesForPod", podUID)
	ret0, _ := ret[0].(map[string]volume.Volume)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// ListVolumesForPod indicates an expected call of ListVolumesForPod.
func (mr *MockProviderMockRecorder) ListVolumesForPod(podUID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()

		mountOptions: util.MountOptionFromSpec(spec),
		readOnly:     readOnly,
	}, nil

}

func (plugin *localVolumePlugin) NewUnmounter(volName string, podUID types.UID) (volume.Unmounter, error) {
	return &localVolumeUnmounter{
		localVolume: &localVolume{
			podUID:  podUID,
			volName: volName,
			mounter: plugin.host.GetMounter(plugin.GetPluginName()),
			plugin:  plugin,
		},
	}, nil
}

				return nil
			}, retry.Timeout(time.Second*20))

			retry.UntilSuccessOrFail(t, func() error {
				podID, err := getPodID(apps.A[0])
				if err != nil {
					return fmt.Errorf("could not get Pod ID: %v", err)
				}
				args := []string{
					"--namespace=dummy",
					"x", "describe", "pod", fmt.Sprintf("%s.%s", podID, apps.Namespace.Name()),
				}
				output, _, err := istioCtl.Invoke(args)
				if err != nil {

		VolumeName          string `json:"volumeName"`
		PodName             string `json:"podName"`
		VolumeSpecName      string `json:"volumeSpecName"`
		OuterVolumeSpecName string `json:"outerVolumeSpecName"`
		PodUID              string `json:"podUID"`
		VolumeGIDValue      string `json:"volumeGIDValue"`
		DevicePath          string `json:"devicePath"`
		SeLinuxMountContext string `json:"seLinuxMountContext"`
	}{

	podID := types.UID("test-pod")
	pods := []*kubecontainer.Pod{{
		ID:         podID,
		Containers: []*kubecontainer.Container{infraContainer},
	}}
	runtimeMock.EXPECT().GetPods(ctx, true).Return(pods, nil).Times(1)

	goodStatus := &kubecontainer.PodStatus{
		ID:                podID,

	for _, claimInfo := range m.cache.claimInfo {
		for podUID := range claimInfo.PodUIDs {
			if activePods.Has(podUID) {
				continue
			}
			if inactivePodClaims[podUID] == nil {
				inactivePodClaims[podUID] = &podClaims{
					uid:        types.UID(podUID),
					namespace:  claimInfo.Namespace,
					claimNames: []string{},
				}
			}

	"k8s.io/mount-utils"
)

const (
	testPVName                        = "pvA"
	testMountPath                     = "pods/poduid/volumes/kubernetes.io~local-volume/pvA"
	testGlobalPath                    = "plugins/kubernetes.io~local-volume/volumeDevices/pvA"
	testPodPath                       = "pods/poduid/volumeDevices/kubernetes.io~local-volume"
	testBlockFormattingToFSGlobalPath = "plugins/kubernetes.io/local-volume/mounts/pvA"
)

  /var/lib/kubelet/plugins/kubernetes.io/csi/volumeDevices/staging/{specName} ... Staging path
  /var/lib/kubelet/plugins/kubernetes.io/csi/volumeDevices/publish/{specName}/{podUID} ... Publish path
  /var/lib/kubelet/pods/{podUID}/volumeDevices/kubernetes.io~csi/ ... Pod device map path

		}
	}

	podName := opts.PodName
	podUID := opts.PodUID
	volumeName := opts.VolumeName
	mounter := opts.Mounter
	blockVolumeMapper := opts.BlockVolumeMapper
	outerVolumeSpecName := opts.OuterVolumeSpecName
	volumeGidValue := opts.VolumeGidVolume
	volumeSpec := opts.VolumeSpec

	podObj = mountedPod{
		podName:                podName,
		podUID:                 podUID,
		mounter:                mounter,

func (p *staticPolicy) RemoveContainer(s state.State, podUID string, containerName string) error {
	klog.InfoS("Static policy: RemoveContainer", "podUID", podUID, "containerName", containerName)
	cpusInUse := getAssignedCPUsOfSiblings(s, podUID, containerName)
	if toRelease, ok := s.GetCPUSet(podUID, containerName); ok {
		s.Delete(podUID, containerName)
		// Mutate the shared pool, adding released cpus.
		toRelease = toRelease.Difference(cpusInUse)