Image:          "test",
				RuntimeHandler: "",
				Annotations:    []kubecontainer.Annotation(nil),
			},
		},
		{
			input: &runtimeapi.Image{
				Id: "test",
				Spec: &runtimeapi.ImageSpec{
					RuntimeHandler: "test-runtimeHandler",
					Annotations: map[string]string{
						"kubernetes.io/os":             "linux",
						"kubernetes.io/runtimehandler": "handler",
					},
				},
			},

	s.Lock()
	defer s.Unlock()
	s.runtimeError = err
}

func (s *runtimeState) setRuntimeHandlers(rtHandlers []kubecontainer.RuntimeHandler) {
	s.Lock()
	defer s.Unlock()
	s.rtHandlers = rtHandlers
}

func (s *runtimeState) runtimeHandlers() []kubecontainer.RuntimeHandler {
	s.RLock()
	defer s.RUnlock()
	return s.rtHandlers
}

func (s *runtimeState) setStorageState(err error) {
	s.Lock()

			imageKey = getImageTuple(image.ID, image.Spec.RuntimeHandler)
			klog.V(5).InfoS("Adding image ID with runtime class to currentImages", "imageKey", imageKey, "runtimeHandler", image.Spec.RuntimeHandler)
		}

		currentImages.Insert(imageKey)

		// New image, set it as detected now.
		if _, ok := im.imageRecords[imageKey]; !ok {
			klog.V(5).InfoS("Image ID is new", "imageID", imageKey, "runtimeHandler", image.Spec.RuntimeHandler)

		image := images[0]
		assert.Equal(t, "missing_image:latest", image.ID, "Image ID")
		assert.Equal(t, "", image.Spec.RuntimeHandler, "image.Spec.RuntimeHandler not empty", "ImageID", image.ID)

		expectedAnnotations := []Annotation{
			{
				Name:  "kubernetes.io/runtimehandler",
				Value: "handler_name",
			}}
		assert.Equal(t, expectedAnnotations, image.Spec.Annotations, "image spec annotations")
	})
}

  // runtime (using native Linux containers) will be used to run the containers
  // in a pod.
  // The runtimeHandler must be lowercase, conform to the DNS Label (RFC 1123)
  // requirements, and is immutable.
  optional string runtimeHandler = 1;

  // overhead represents the resource overhead associated with running a pod for a
  // given RuntimeClass. For more details, see

	runtimeHandler := ""
	if pod != nil && rcManager != nil {
		var err error
		runtimeHandler, err = rcManager.LookupRuntimeHandler(pod.Spec.RuntimeClassName)
		if err != nil {
			return nil, err
		}
	}
	userNs, err := runtimeHelper.GetOrCreateUserNamespaceMappings(pod, runtimeHandler)
	if err != nil {
		return nil, err
	}

  // runtime (using native Linux containers) will be used to run the containers
  // in a pod.
  // The runtimeHandler must be lowercase, conform to the DNS Label (RFC 1123)
  // requirements, and is immutable.
  optional string runtimeHandler = 1;

  // overhead represents the resource overhead associated with running a pod for a
  // given RuntimeClass. For more details, see

        "time": "2004-01-01T01:01:01Z",
        "fieldsType": "fieldsTypeValue",
        "fieldsV1": {},
        "subresource": "subresourceValue"
      }
    ]
  },
  "spec": {
    "runtimeHandler": "runtimeHandlerValue",
    "overhead": {
      "podFixed": {
        "podFixedKey": "0"
      }
    },
    "scheduling": {
      "nodeSelector": {
        "nodeSelectorKey": "nodeSelectorValue"
      },

    kind: kindValue
    name: nameValue
    uid: uidValue
  resourceVersion: resourceVersionValue
  selfLink: selfLinkValue
  uid: uidValue
spec:
  overhead:
    podFixed:
      podFixedKey: "0"
  runtimeHandler: runtimeHandlerValue
  scheduling:
    nodeSelector:
      nodeSelectorKey: nodeSelectorValue
    tolerations:
    - effect: effectValue
      key: keyValue
      operator: operatorValue

		// of not populating the runtimeHandler CRI field in ImageSpec struct is preserved.
		// Therefore, when RuntimeClassInImageCriAPI feature gate is set, check to see if this
		// field is empty and log a warning message.
		if utilfeature.DefaultFeatureGate.Enabled(features.RuntimeClassInImageCriAPI) {
			if img.Spec == nil || (img.Spec != nil && img.Spec.RuntimeHandler == "") {