t.Errorf("Fail: unexpected QueueSets %v", extraQueueSetNames)
				}
				for plName, hr, nCount := cts.popHeldRequest(); hr != nil; plName, hr, nCount = cts.popHeldRequest() {
					desired := desiredPLNames.Has(plName) || mandPLs[plName] != nil
					if testDebugLogs {
						t.Logf("Releasing held request %#+v, desired=%v, plName=%s, count:=%d", hr.rd, desired, plName, nCount)
					}
					close(hr.finishCh)
				}
				cts.requestWG.Wait()

	brokenPodTerminating = makePod(makePodArgs{
		PodName: "broken-pod-terminating",
		Annotations: map[string]string{
			"sidecar.istio.io/status": "something",
		},
		Labels: map[string]string{
			"testlabel": "true",
		},
		NodeName:            "test-node",
		InitContainerStatus: &brokenInitContainerTerminating,
	})

	brokenPodWaiting = makePod(makePodArgs{
		PodName: "broken-pod-waiting",

	}
	gvi.podVolumes[rcv.podName] = rcv
}

func (rc *reconciler) cleanupMounts(volume podVolume) {
	klog.V(2).InfoS("Reconciler sync states: could not find volume information in desired state, clean up the mount points", "podName", volume.podName, "volumeSpecName", volume.volumeSpecName)
	mountedVolume := operationexecutor.MountedVolume{
		PodName: volume.podName,

		volumeNameMatch := previousOp.key.volumeName == key.volumeName

		podNameMatch := previousOp.key.podName == EmptyUniquePodName ||
			key.podName == EmptyUniquePodName ||
			previousOp.key.podName == key.podName

		podNameExactMatch := previousOp.key.podName == key.podName

		nodeNameMatch := previousOp.key.nodeName == EmptyNodeName ||
			key.nodeName == EmptyNodeName ||

	return c.Results, nil
}

func (c MockClient) EnvoyDo(ctx context.Context, podName, podNamespace, method, path string) ([]byte, error) {
	results, ok := c.Results[podName]
	if !ok {
		return nil, fmt.Errorf("unable to retrieve Pod: pods %q not found", podName)
	}
	return results, nil
}

func (c MockClient) EnvoyDoWithPort(ctx context.Context, podName, podNamespace, method, path string, port int) ([]byte, error) {

			for _, workload := range workloads {
				podName := workload[0].WorkloadsOrFail(t)[0].PodName()
				namespace := workload.Config().Namespace.Name()

				retry.UntilSuccessOrFail(t, func() error {
					args := []string{
						"x", "proxy-status", "--xds-via-agents", fmt.Sprintf("%s.%s", podName, namespace),
					}
					output, _, err := istioCtl.Invoke(args)
					if err != nil {

	}
}

func (m *maxSeatsTracker) GetMaxSeats(plName string) uint64 {
	m.RLock()
	defer m.RUnlock()

	return m.maxSeats[plName]
}

func (m *maxSeatsTracker) SetMaxSeats(plName string, maxSeats uint64) {
	m.Lock()
	defer m.Unlock()

	m.maxSeats[plName] = maxSeats
}

func (m *maxSeatsTracker) ForgetPriorityLevel(plName string) {
	m.Lock()
	defer m.Unlock()

	delete(m.maxSeats, plName)

	"k8s.io/kubelet/pkg/apis/podresources/v1alpha1"
	podresourcetest "k8s.io/kubernetes/pkg/kubelet/apis/podresources/testing"
)

func TestListPodResourcesV1alpha1(t *testing.T) {
	podName := "pod-name"
	podNamespace := "pod-namespace"
	podUID := types.UID("pod-uid")
	containerName := "container-name"

	devs := []*podresourcesv1.ContainerDevices{
		{
			ResourceName: "resource",

			podName,
			generatedVolumeName,
			nodeName)
	}

	// Act
	generatedVolumeName, podErr = dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volumeSpec, nodeName)

	// Assert
	if podErr != nil {
		t.Fatalf("AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
			podName,
			podErr)
	}

		return err
	}

	// Check if the workload is running under Kubernetes.
	podNamespace := string(k8sArgs.K8S_POD_NAMESPACE)
	podName := string(k8sArgs.K8S_POD_NAME)
	log := log.WithLabels("pod", podNamespace+"/"+podName)
	if podNamespace == "" || podName == "" {
		log.Debugf("Not a kubernetes pod")
		return nil
	}

	for _, excludeNs := range conf.Kubernetes.ExcludeNamespaces {