Status:             v1.ConditionFalse,
							Reason:             "KubeletHasSufficientMemory",
							Message:            "kubelet has sufficient memory available",
							LastHeartbeatTime:  metav1.Time{},
							LastTransitionTime: metav1.Time{},
						},
						{
							Type:               v1.NodeDiskPressure,
							Status:             v1.ConditionFalse,
							Reason:             "KubeletHasNoDiskPressure",

	4:   {lang: 0x1f, region: 0x9a},
	5:   {lang: 0x3a, region: 0x6c},
	7:   {lang: 0x3b, region: 0x9d},
	8:   {lang: 0x1d7, region: 0x28},
	9:   {lang: 0x13, region: 0x9d},
	10:  {lang: 0x5b, region: 0x96},
	11:  {lang: 0x60, region: 0x52},
	12:  {lang: 0xb9, region: 0xb5},
	13:  {lang: 0x63, region: 0x96},
	14:  {lang: 0xa5, region: 0x35},
	15:  {lang: 0x3e9, region: 0x9a},
	17:  {lang: 0x529, region: 0x12f},

visible, and the Star (if the Glass be sufficiently soiled with Smoak) appears something more like a mathematical Point. And for the same Reason, the enormous Part of the Light in the Circumference of every lucid Point ought to be less discernible in shorter Telescopes than in longer, because the shorter transmit less Light to the Eye. Now, that the fix'd Stars, by reason of their immense Distance, appear like Points, unless so far as their Light is dilated by Refraction, may appear from hence; that when...

    --project "${PROJECT}" \
    --region "${REGION}" \
    --protocol tcp \
    --region "${REGION}" \
    --load-balancing-scheme internal \
    --health-checks "${MASTER_NAME}-hc"

  gcloud compute forwarding-rules create "${MASTER_NAME}-internal" \
    --project "${PROJECT}" \
    --region "${REGION}" \
    --load-balancing-scheme internal \
    --network "${NETWORK}" \

var statusOk = []autoscalingv2.HorizontalPodAutoscalerCondition{
	{Type: autoscalingv2.AbleToScale, Status: v1.ConditionTrue, Reason: "SucceededRescale"},
	{Type: autoscalingv2.ScalingActive, Status: v1.ConditionTrue, Reason: "ValidMetricFound"},
	{Type: autoscalingv2.ScalingLimited, Status: v1.ConditionFalse, Reason: "DesiredWithinRange"},
}

// statusOkWithOverrides returns the "ok" status with the given conditions as overridden

				reason = container.State.Waiting.Reason
			} else if container.State.Terminated != nil && container.State.Terminated.Reason != "" {
				reason = container.State.Terminated.Reason
			} else if container.State.Terminated != nil && container.State.Terminated.Reason == "" {
				if container.State.Terminated.Signal != 0 {

		// terminated status.
		{
			containers: []v1.Container{{Name: "without-reason"}, {Name: "with-reason"}},
			statuses: []*kubecontainer.Status{
				{
					Name:     "without-reason",
					State:    kubecontainer.ContainerStateExited,
					ExitCode: 1,
				},
				{
					Name:     "with-reason",
					State:    kubecontainer.ContainerStateExited,
					ExitCode: 2,
				},
				{

					FieldPath: "spec.containers{foo}",
				},
				Reason:     "Event Reason",
				Message:    "Message Data",
				EventTime:  metav1.MicroTime{Time: time.Now().UTC().AddDate(0, 0, -3)},
				Count:      1,
				Type:       api.EventTypeWarning,
				ObjectMeta: metav1.ObjectMeta{Name: "event5"},
			},
			options: printers.GenerateOptions{Wide: true},
			// Columns: Last Seen, Type, Reason, Object, Subobject, Message, First Seen, Count, Name

			s.Phase = pod.Status.Phase
		}
	}

	if s.Phase == oldPodStatus.Phase {
		// preserve the reason and message which is associated with the phase
		s.Reason = oldPodStatus.Reason
		s.Message = oldPodStatus.Message
		if len(s.Reason) == 0 {
			s.Reason = pod.Status.Reason
		}
		if len(s.Message) == 0 {
			s.Message = pod.Status.Message
		}
	}

			if action.GetVerb() == "update" && action.GetResource().Resource == "pods" {
				updateReason := action.(testcore.UpdateActionImpl).GetObject().(*v1.Pod).Status.Reason
				podReasonUpdate = true
				if updateReason != item.expectedReason {
					t.Errorf("expected pod status reason: %+v, got %+v for %+v", item.expectedReason, updateReason, item.description)
				}
			}
		}

		if podReasonUpdate != item.expectedPodUpdate {