// Machine is found in Header.Machine.
type Machine uint16

const (
	EM_NONE          Machine = 0   /* Unknown machine. */
	EM_M32           Machine = 1   /* AT&T WE32100. */
	EM_SPARC         Machine = 2   /* Sun SPARC. */
	EM_386           Machine = 3   /* Intel i386. */
	EM_68K           Machine = 4   /* Motorola 68000. */
	EM_88K           Machine = 5   /* Motorola 88000. */

								PageSize: pageSize1Gb,
								NumPages: 1,
							},
						},
					},
				},
			},
			expectedError: fmt.Errorf("[memorymanager] the expected machine state is different from the real one"),
		},
		{
			description: "should fail when machine state does not have memory resource",
			machineState: state.NUMANodeMap{
				0: &state.NUMANodeState{
					MemoryMap: map[v1.ResourceName]*state.MemoryTable{

	podA := &example.Pod{
		ObjectMeta: metav1.ObjectMeta{Namespace: "test", Name: "bar"},
		Spec:       example.PodSpec{NodeName: "machine"},
	}
	podB := &example.Pod{
		ObjectMeta: metav1.ObjectMeta{Namespace: "test", Name: "foo"},
		Spec:       example.PodSpec{NodeName: "machine"},
	}

	testContext := genericapirequest.WithNamespace(genericapirequest.NewContext(), "test")

          </association>
        </field>
      </fields>
      <comment>We could probably have a specific element for a dev mailing list for things like CI,
        and maybe even a specific element for the user and scm mailing lists. Then leave the more
        lose structure for any other type of mailing list.</comment>
      <codeSegments>
        <codeSegment>
          <version>4.0.0+</version>
          <code>

				z.Files[za0001], err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Files", za0001)
					return
				}
			}
		case "MaxSize":
			z.MaxSize, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "MaxSize")
				return
			}
		case "MetadataOnly":
			z.MetadataOnly, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "MetadataOnly")

func withID(status v1.ContainerStatus, id string) v1.ContainerStatus {
	status.ContainerID = id
	return status
}

func TestPodPhaseWithRestartAlways(t *testing.T) {
	desiredState := v1.PodSpec{
		NodeName: "machine",
		Containers: []v1.Container{
			{Name: "containerA"},
			{Name: "containerB"},
		},
		RestartPolicy: v1.RestartPolicyAlways,
	}

	tests := []struct {
		pod           *v1.Pod

        },
        "gcePersistentDisk": {
          "$ref": "#/definitions/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource",

		// instead of returning a (retriable) error.

		if handlerN > maxSize {
			t.Errorf("expected max request body %d; got %d", maxSize, handlerN)
		}
		if requestSize > maxSize && handlerErr == nil {
			t.Error("expected error on handler side; got nil")
		}
		if requestSize <= maxSize {
			if handlerErr != nil {

    # shellcheck disable=SC2086
    if ! ${gcloud} compute instance-templates create \
      "${template_name}" \
      --project "${PROJECT}" \
      --machine-type "${machine_type}" \
      --boot-disk-type "${NODE_DISK_TYPE}" \
      --boot-disk-size "${NODE_DISK_SIZE}" \
      "${node_image_flags[@]}" \
      --service-account "${NODE_SERVICE_ACCOUNT}" \

        "properties": {
          "action": {
            "description": "action is what action was taken/failed regarding to the regarding object. It is machine-readable. This field cannot be empty for new Events and it can have at most 128 characters.",
            "type": "string"
          },
          "apiVersion": {