}

func (s *stateMemory) GetPodResizeStatus(podUID string) (v1.PodResizeStatus, bool) {
	s.RLock()
	defer s.RUnlock()

	resizeStatus, ok := s.podResizeStatus[podUID]
	return resizeStatus, ok
}

func (s *stateMemory) GetResizeStatus() PodResizeStatus {
	s.RLock()
	defer s.RUnlock()
	prs := make(map[string]v1.PodResizeStatus)
	for k, v := range s.podResizeStatus {
		prs[k] = v
	}
	return prs
}

		for container, alloc := range podAllocation[pod] {
			checkpoint.AllocationEntries[pod][container] = alloc
		}
	}

	podResizeStatus := sc.cache.GetResizeStatus()
	checkpoint.ResizeStatusEntries = make(map[string]v1.PodResizeStatus)
	for pUID, rStatus := range podResizeStatus {
		checkpoint.ResizeStatusEntries[pUID] = rStatus
	}

	err := sc.checkpointManager.CreateCheckpoint(sc.checkpointName, checkpoint)

	GetPodResizeStatus(podUID string) (v1.PodResizeStatus, bool)
	GetResizeStatus() PodResizeStatus
}

type writer interface {
	SetContainerResourceAllocation(podUID string, containerName string, alloc v1.ResourceList) error
	SetPodResourceAllocation(PodResourceAllocation) error
	SetPodResizeStatus(podUID string, resizeStatus v1.PodResizeStatus) error
	SetResizeStatus(PodResizeStatus) error

type PodResourceAllocationCheckpoint struct {
	AllocationEntries   map[string]map[string]v1.ResourceList `json:"allocationEntries,omitempty"`
	ResizeStatusEntries map[string]v1.PodResizeStatus         `json:"resizeStatusEntries,omitempty"`
	Checksum            checksum.Checksum                     `json:"checksum"`
}

// NewPodResourceAllocationCheckpoint returns an instance of Checkpoint

	klog.InfoS("GetContainerResourceAllocation()")
	return m.state.GetContainerResourceAllocation(podUID, containerName)
}

func (m *fakeManager) GetPodResizeStatus(podUID string) (v1.PodResizeStatus, bool) {
	klog.InfoS("GetPodResizeStatus()")
	return "", false
}

func (m *fakeManager) SetPodAllocation(pod *v1.Pod) error {
	klog.InfoS("SetPodAllocation()")
	for _, container := range pod.Spec.Containers {

	EphemeralContainerStatuses []ContainerStatusApplyConfiguration        `json:"ephemeralContainerStatuses,omitempty"`
	Resize                     *v1.PodResizeStatus                        `json:"resize,omitempty"`
	ResourceClaimStatuses      []PodResourceClaimStatusApplyConfiguration `json:"resourceClaimStatuses,omitempty"`
}

}

// GetPodResizeStatus mocks base method.
func (m *MockManager) GetPodResizeStatus(podUID string) (v1.PodResizeStatus, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPodResizeStatus", podUID)
	ret0, _ := ret[0].(v1.PodResizeStatus)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetPodResizeStatus indicates an expected call of GetPodResizeStatus.

	restartAlways := v1.ContainerRestartPolicyAlways
	testCases := []struct {
		description      string
		options          PodResourcesOptions
		overhead         v1.ResourceList
		podResizeStatus  v1.PodResizeStatus
		initContainers   []v1.Container
		containers       []v1.Container
		containerStatus  []v1.ContainerStatus
		expectedRequests v1.ResourceList
	}{
		{

	GetPodResizeStatus(podUID string) (v1.PodResizeStatus, bool)

	// SetPodAllocation checkpoints the resources allocated to a pod's containers.
	SetPodAllocation(pod *v1.Pod) error

	// SetPodResizeStatus checkpoints the last resizing decision for the pod.
	SetPodResizeStatus(podUID types.UID, resize v1.PodResizeStatus) error
}

const syncPeriod = 10 * time.Second

			delete(target.Requests, resource)
		}
	}
}

func (kl *Kubelet) determinePodResizeStatus(pod *v1.Pod, podStatus *v1.PodStatus) v1.PodResizeStatus {
	var podResizeStatus v1.PodResizeStatus
	specStatusDiffer := false
	for _, c := range pod.Spec.Containers {
		if cs, ok := podutil.GetContainerStatus(podStatus.ContainerStatuses, c.Name); ok {