}
	if in.Topology != nil {
		in, out := &in.Topology, &out.Topology
		*out = make(map[string]string, len(*in))
		for key, val := range *in {
			(*out)[key] = val
		}
	}
	if in.NodeName != nil {
		in, out := &in.NodeName, &out.NodeName
		*out = new(string)
		**out = **in
	}
	if in.Hints != nil {
		in, out := &in.Hints, &out.Hints
		*out = new(EndpointHints)
		(*in).DeepCopyInto(*out)
	}
	return
}

		"metadata.namespace",
		"metadata.uid",
		"spec.nodeName",
		"spec.restartPolicy",
		"spec.serviceAccountName",
		"spec.schedulerName",
		"status.phase",
		"status.hostIP",
		"status.hostIPs",
		"status.podIP",
		"status.podIPs":
		return label, value, nil
	// This is for backwards compatibility with old v1 clients which send spec.host
	case "spec.host":
		return "spec.nodeName", value, nil
	default:

func (o podByCreationTimestampAndPhase) Less(i, j int) bool {
	// Scheduled Pod first
	if len(o[i].Spec.NodeName) != 0 && len(o[j].Spec.NodeName) == 0 {
		return true
	}

	if len(o[i].Spec.NodeName) == 0 && len(o[j].Spec.NodeName) != 0 {
		return false
	}

	if o[i].CreationTimestamp.Equal(&o[j].CreationTimestamp) {
		return o[i].Name < o[j].Name
	}

			if areAttachedErr != nil {
				klog.Errorf(
					"VolumesAreAttached failed for checking on node %q with: %v",
					nodeName,
					areAttachedErr)
				continue
			}

			for spec, check := range attached {
				if !check {
					actualStateOfWorld.MarkVolumeAsDetached(volumeSpecMap[spec], nodeName)

}

func validateStructuredResourceHandle(handle *resource.StructuredResourceHandle, fldPath *field.Path) field.ErrorList {
	var allErrs field.ErrorList
	if handle.NodeName != "" {
		allErrs = append(allErrs, validateNodeName(handle.NodeName, fldPath.Child("nodeName"))...)
	}
	allErrs = append(allErrs, validateDriverAllocationResults(handle.Results, fldPath.Child("results"))...)
	return allErrs
}

					Spec: v1.PodSpec{
						NodeName: "node-one",
						Containers: []v1.Container{
							{Resources: v1.ResourceRequirements{Requests: v1.ResourceList{"cpu": resource.MustParse("1")}}},
						},
					},
					Status: v1.PodStatus{Phase: v1.PodUnknown},
				},
				{
					ObjectMeta: metav1.ObjectMeta{Namespace: "test", Name: "foo-pending"},
					Spec: v1.PodSpec{
						NodeName: "node-one",
						InitContainers: []v1.Container{

        "apiVersion": "apiVersionValue",
        "resourceVersion": "resourceVersionValue",
        "fieldPath": "fieldPathValue"
      },
      "topology": {
        "topologyKey": "topologyValue"
      },
      "nodeName": "nodeNameValue",
      "hints": {
        "forZones": [
          {
            "name": "nameValue"
          }
        ]
      }
    }
  ],
  "ports": [
    {
      "name": "nameValue",

	configutil "k8s.io/kubernetes/cmd/kubeadm/app/util/config"
)

func TestCreateConfigMap(t *testing.T) {
	nodeName := "fake-node"
	client := fake.NewSimpleClientset()
	client.PrependReactor("get", "nodes", func(action core.Action) (bool, runtime.Object, error) {
		return true, &v1.Node{
			ObjectMeta: metav1.ObjectMeta{
				Name: nodeName,
			},
			Spec: v1.NodeSpec{},
		}, nil
	})

	allowExpansion := ne.runPreCheck()
	if !allowExpansion {
		return false, nil, testResponseData{false, true}
	}

	var err error
	nodeName := ne.vmt.Pod.Spec.NodeName

	if !ne.pvcAlreadyUpdated {
		ne.pvc, err = util.MarkNodeExpansionInProgress(ne.pvc, ne.kubeClient)

		if err != nil {

    ready: true
    serving: true
    terminating: true
  deprecatedTopology:
    deprecatedTopologyKey: deprecatedTopologyValue
  hints:
    forZones:
    - name: nameValue
  hostname: hostnameValue
  nodeName: nodeNameValue
  targetRef:
    apiVersion: apiVersionValue
    fieldPath: fieldPathValue
    kind: kindValue
    name: nameValue
    namespace: namespaceValue
    resourceVersion: resourceVersionValue