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",
					},
				},
			},

		Annotations: annotations,
	}
	// if RuntimeClassInImageCriAPI feature gate is enabled, set runtimeHandler CRI field
	if utilfeature.DefaultFeatureGate.Enabled(features.RuntimeClassInImageCriAPI) {
		runtimeHandler := ""
		if image.Spec != nil {
			runtimeHandler = image.Spec.RuntimeHandler
		}
		spec.RuntimeHandler = runtimeHandler
	}

	return spec
}

						Effect:   core.TaintEffectNoSchedule,
					}},
				},
			},
			external: &v1alpha1.RuntimeClass{
				ObjectMeta: metav1.ObjectMeta{Name: name},
				Spec: v1alpha1.RuntimeClassSpec{
					RuntimeHandler: handler,
					Overhead: &v1alpha1.Overhead{
						PodFixed: corev1.ResourceList{
							corev1.ResourceCPU: resource.MustParse(cpuOverhead),
						},
					},
					Scheduling: &v1alpha1.Scheduling{

	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()

	// 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.
	RuntimeHandler string `json:"runtimeHandler" protobuf:"bytes,1,opt,name=runtimeHandler"`

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

			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)

func Convert_v1alpha1_RuntimeClass_To_node_RuntimeClass(in *v1alpha1.RuntimeClass, out *node.RuntimeClass, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	out.Handler = in.Spec.RuntimeHandler

	if in.Spec.Overhead != nil {
		out.Overhead = &node.Overhead{}
		if err := Convert_v1alpha1_Overhead_To_node_Overhead(in.Spec.Overhead, out.Overhead, s); err != nil {
			return err
		}
	}

		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
	}