"linux": {
            "uid": 1,
            "gid": 2,
            "supplementalGroups": [
              3
            ]
          }
        }
      }
    ],
    "containerStatuses": [
      {
        "name": "nameValue",
        "state": {
          "waiting": {
            "reason": "reasonValue",
            "message": "messageValue"
          },
          "running": {

	memoryRequest := container.Resources.Requests.Memory().Value()
	if utilfeature.DefaultFeatureGate.Enabled(features.InPlacePodVerticalScaling) {
		if cs, ok := podutil.GetContainerStatus(pod.Status.ContainerStatuses, container.Name); ok {
			memoryRequest = cs.AllocatedResources.Memory().Value()
		}
	}
	oomScoreAdjust := 1000 - (1000*memoryRequest)/memoryCapacity

		Conditions: []v1.PodCondition{
			{
				Type:   v1.PodReady,
				Status: v1.ConditionTrue,
			},
			{
				Type:   v1.PodScheduled,
				Status: v1.ConditionTrue,
			},
		},
		ContainerStatuses: []v1.ContainerStatus{
			{
				Name:  "container1",
				Ready: true,
			},
			{
				Name:  "container2",
				Ready: true,
			},
		},
		Message: "Message",
	}
}

            "requestsKey": "0"
          },
          "claims": [
            {
              "name": "nameValue"
            }
          ]
        }
      }
    ],
    "containerStatuses": [
      {
        "name": "nameValue",
        "state": {
          "waiting": {
            "reason": "reasonValue",
            "message": "messageValue"
          },
          "running": {

	}
	containerStatus.State.Running = &v1.ContainerStateRunning{StartedAt: metav1.Now()}
	containerStatus.Started = &started
	podStatus := v1.PodStatus{
		Phase:             v1.PodRunning,
		ContainerStatuses: []v1.ContainerStatus{containerStatus},
	}
	return podStatus
}

func getTestPod() *v1.Pod {
	container := v1.Container{
		Name: testContainerName,
	}
	pod := v1.Pod{
		Spec: v1.PodSpec{

							{ResourceName: api.ResourceMemory, RestartPolicy: api.RestartContainer},
						},
					},
				},
			},
			Status: api.PodStatus{
				Resize: api.PodResizeStatusInProgress,
				ContainerStatuses: []api.ContainerStatus{
					{
						Name:               "c1",
						Image:              "image",
						AllocatedResources: api.ResourceList{api.ResourceCPU: resource.MustParse("100m")},

				{
					Name: "payload-container",
				},
			},
		},
		Status: corev1.PodStatus{
			InitContainerStatuses: []corev1.ContainerStatus{
				*args.InitContainerStatus,
			},
			ContainerStatuses: []corev1.ContainerStatus{
				{
					Name: "payload-container",
					State: corev1.ContainerState{
						Waiting: &corev1.ContainerStateWaiting{
							Reason: "PodInitializing",
						},
					},
				},

            "mountPath": "mountPathValue",
            "readOnly": true,
            "recursiveReadOnly": "recursiveReadOnlyValue"
          }
        ]
      }
    ],
    "containerStatuses": [
      {
        "name": "nameValue",
        "state": {
          "waiting": {
            "reason": "reasonValue",
            "message": "messageValue"
          },
          "running": {

status:
  conditions:
  - lastProbeTime: "2003-01-01T01:01:01Z"
    lastTransitionTime: "2004-01-01T01:01:01Z"
    message: messageValue
    reason: reasonValue
    status: statusValue
    type: typeValue
  containerStatuses:
  - allocatedResources:
      allocatedResourcesKey: "0"
    containerID: containerIDValue
    image: imageValue
    imageID: imageIDValue
    lastState:
      running:

		return kubetypes.SortStatusesOfInitContainers(pod, statuses)
	}
	containerStatuses := make([]v1.ContainerStatus, 0, len(statuses))
	for _, status := range statuses {
		containerStatuses = append(containerStatuses, *status)
	}

	sort.Sort(kubetypes.SortedContainerStatuses(containerStatuses))
	return containerStatuses
}

// ServeLogs returns logs of current machine.