{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.

	},
	Status: api.PodStatus{
		Phase: api.PodRunning,
		Conditions: []api.PodCondition{
			{
				Type:   api.PodReady,
				Status: api.ConditionTrue,
			},
		},
		ContainerStatuses: []api.ContainerStatus{
			{
				Name: "etcd-container",
				State: api.ContainerState{
					Running: &api.ContainerStateRunning{
						StartedAt: parseTimeOrDie("2015-04-22T11:49:32Z"),
					},
				},

								},
								Limits: api.ResourceList{
									api.ResourceMemory: resource.MustParse("400Mi"),
								},
							},
						},
					},
				},
				Status: api.PodStatus{
					ContainerStatuses: []api.ContainerStatus{
						{
							AllocatedResources: api.ResourceList{
								api.ResourceMemory: resource.MustParse("150Mi"),
							},
						},
					},
				},
			},

// ref: https://github.com/kubernetes/community/blob/master/sig-scalability/slos/pod_startup_latency.md
func hasPodStartedSLO(pod *v1.Pod) bool {
	for _, cs := range pod.Status.ContainerStatuses {
		if cs.State.Running == nil || cs.State.Running.StartedAt.IsZero() {
			return false
		}
	}

	return true
}

func (p *basicPodStartupLatencyTracker) DeletePodStartupState(podUID types.UID) {

	var pods []*v1.Pod
	for i := 0; i < count; i++ {
		newPod := newPod(fmt.Sprintf("pod-%v", rand.String(10)), job)
		newPod.Status = v1.PodStatus{Phase: status}
		newPod.Status.ContainerStatuses = []v1.ContainerStatus{
			{
				State: v1.ContainerState{
					Terminated: &v1.ContainerStateTerminated{
						FinishedAt: testFinishedAt,
					},
				},
			},
		}

		podStatus.HostIPs = nil
	}

	if !utilfeature.DefaultFeatureGate.Enabled(features.RecursiveReadOnlyMounts) && !rroInUse(oldPodSpec) {
		for i := range podStatus.ContainerStatuses {
			podStatus.ContainerStatuses[i].VolumeMounts = nil
		}
		for i := range podStatus.InitContainerStatuses {
			podStatus.InitContainerStatuses[i].VolumeMounts = nil
		}
		for i := range podStatus.EphemeralContainerStatuses {