cs, found := containerStatuses[container.Name]
			if found {
				if pod.Status.Resize == v1.PodResizeStatusInfeasible {
					containerReqs = cs.AllocatedResources.DeepCopy()
				} else {
					containerReqs = max(container.Resources.Requests, cs.AllocatedResources)
				}
			}
		}

		if len(opts.NonMissingContainerRequests) > 0 {
			containerReqs = applyNonMissing(containerReqs, opts.NonMissingContainerRequests)
		}

						Requests: v1.ResourceList{
							v1.ResourceCPU: resource.MustParse("4"),
						},
					},
				},
			},
			containerStatus: []v1.ContainerStatus{
				{
					Name: "container-1",
					AllocatedResources: v1.ResourceList{
						v1.ResourceCPU: resource.MustParse("2"),
					},
				},
			},
		},
		{
			description: "resized, no resize status",
			expectedRequests: v1.ResourceList{

			pvc.Status.ModifyVolumeStatus = nil
		}
	}

	if !utilfeature.DefaultFeatureGate.Enabled(features.RecoverVolumeExpansionFailure) {
		if !helper.ClaimContainsAllocatedResources(oldPVC) {
			pvc.Status.AllocatedResources = nil
		}
		if !helper.ClaimContainsAllocatedResourceStatus(oldPVC) {
			pvc.Status.AllocatedResourceStatuses = nil
		}
	}
}

func dataSourceInUse(oldPVCSpec *core.PersistentVolumeClaimSpec) bool {

			},
		},
		Status: api.PersistentVolumeClaimStatus{
			Capacity: api.ResourceList{
				api.ResourceStorage: resource.MustParse(allocatedResources),
			},
			Phase: api.ClaimBound,
			AllocatedResources: api.ResourceList{
				api.ResourceStorage: resource.MustParse(allocatedResources),
			},
		},
	}
	if resizeStatus != nil {
		claimStatusMap := map[api.ResourceName]api.ClaimResourceStatus{

		// AllocatedResources values come from checkpoint. It is the source-of-truth.
		found := false
		status.AllocatedResources, found = kl.statusManager.GetContainerResourceAllocation(string(pod.UID), cName)
		if !(container.Resources.Requests == nil && container.Resources.Limits == nil) && !found {
			// Log error and fallback to AllocatedResources in oldStatus if it exists

// updateContainerResourceAllocation updates AllocatedResources values
// (for cpu & memory) from checkpoint store
func (kl *Kubelet) updateContainerResourceAllocation(pod *v1.Pod) {
	for _, c := range pod.Spec.Containers {
		allocatedResources, found := kl.statusManager.GetContainerResourceAllocation(string(pod.UID), c.Name)
		if c.Resources.Requests != nil && found {
			if _, ok := allocatedResources[v1.ResourceCPU]; ok {

						{
							Name:               "c1",
							Image:              "image",
							AllocatedResources: api.ResourceList{api.ResourceCPU: resource.MustParse("100m")},
						},
						{
							Name:               "c2",
							Image:              "image",
							AllocatedResources: api.ResourceList{api.ResourceCPU: resource.MustParse("200m")},
						},
					},
				},
			},

			cs, found := containerStatuses[container.Name]
			if found {
				if pod.Status.Resize == api.PodResizeStatusInfeasible {
					containerReqs = cs.AllocatedResources
				} else {
					containerReqs = max(container.Resources.Requests, cs.AllocatedResources)
				}
			}
		}

		addResourceList(reqs, containerReqs)
	}

	restartableInitCotnainerReqs := api.ResourceList{}

	}

	if !utilfeature.DefaultFeatureGate.Enabled(features.InPlacePodVerticalScaling) && !inPlacePodVerticalScalingInUse(oldPodSpec) {
		// Drop Resize, AllocatedResources, and Resources fields
		dropResourcesFields := func(csl []api.ContainerStatus) {
			for i := range csl {
				csl[i].AllocatedResources = nil
				csl[i].Resources = nil
			}
		}
		dropResourcesFields(podStatus.ContainerStatuses)

		newPVC.Status.Conditions = nil

		if p.expansionRecoveryEnabled {
			oldPVC.Status.AllocatedResourceStatuses = nil
			newPVC.Status.AllocatedResourceStatuses = nil

			oldPVC.Status.AllocatedResources = nil
			newPVC.Status.AllocatedResources = nil
		}

		// TODO(apelisse): We don't have a good mechanism to
		// verify that only the things that should have changed
		// have changed. Ignore it for now.