File javaHome,
        String javaVersion,
        String javaVendor,
        String runtimeName,
        String runtimeVersion,
        String jvmName,
        String jvmVersion,
        String jvmVendor,
        String architecture
    ) {
        return new DefaultJvmInstallationMetadata(javaHome, javaVersion, javaVendor, runtimeName, runtimeVersion, jvmName, jvmVersion, jvmVendor, architecture);
    }

            assert usedToolchain == [
                javaVersion: jdkMetadata.javaVersion,
                javaVendor: jdkMetadata.vendor.displayName,
                runtimeName: jdkMetadata.runtimeName,
                runtimeVersion: jdkMetadata.runtimeVersion,
                jvmName: jdkMetadata.jvmName,
                jvmVersion: jdkMetadata.jvmVersion,
                jvmVendor: jdkMetadata.jvmVendor,

    def "jre is rendered properly"() {
        given:
        def metadata = JvmInstallationMetadata.from(
            new File("path"),
            "1.8.0", "vendorName",
            "runtimeName", "1.8.0-b01",
            "jvmName", "25.292-b01", "jvmVendor",
            "myArch"
        )
        installation.source >> "SourceSupplier"

        expect:

            return failure(javaHome, "Cannot parse version number: " + javaVersion);
        }
        String javaVendor = metadata.get(ProbedSystemProperty.JAVA_VENDOR);
        String runtimeName = metadata.get(ProbedSystemProperty.RUNTIME_NAME);
        String runtimeVersion = metadata.get(ProbedSystemProperty.RUNTIME_VERSION);
        String jvmName = metadata.get(ProbedSystemProperty.VM_NAME);

	kubeRuntimeManager.containerGC = newContainerGC(runtimeService, podStateProvider, kubeRuntimeManager, tracer)
	kubeRuntimeManager.podStateProvider = podStateProvider
	kubeRuntimeManager.runtimeName = typedVersion.RuntimeName
	kubeRuntimeManager.imagePuller = images.NewImageManager(
		kubecontainer.FilterEventRecorder(recorder),
		kubeRuntimeManager,
		flowcontrol.NewBackOff(time.Second, 300*time.Second),
		false,

    def "java version is reported as specified in metadata"() {
        given:
        def javaHome = new File("/jvm/$javaVersion").absoluteFile
        def metadata = JvmInstallationMetadata.from(javaHome, javaVersion, "vendor", "runtimeName", runtimeVersion, "jvmName", jvmVersion, "jvmVendor", "archName")

        when:
        def javaToolchain = new JavaToolchain(metadata, TestFiles.fileFactory(), Mock(JavaToolchainInput) {

			"apiVersion", typedVersion.Version,
			"supportedAPIVersion", kubeRuntimeAPIVersion)
		return nil, ErrVersionNotSupported
	}

	kubeRuntimeManager.runtimeName = typedVersion.RuntimeName
	klog.InfoS("Container runtime initialized",
		"containerRuntime", typedVersion.RuntimeName,
		"version", typedVersion.RuntimeVersion,
		"apiVersion", typedVersion.RuntimeApiVersion)

	if c.ImageId != "" {
		imageID = c.ImageId
	}

	annotatedInfo := getContainerInfoFromAnnotations(c.Annotations)
	return &kubecontainer.Container{
		ID:                  kubecontainer.ContainerID{Type: m.runtimeName, ID: c.Id},
		Name:                c.GetMetadata().GetName(),
		ImageID:             imageID,
		ImageRef:            c.ImageRef,
		ImageRuntimeHandler: c.Image.RuntimeHandler,
		Image:               c.Image.Image,

}

// ConvertPodStatusToRunningPod returns Pod given PodStatus and container runtime string.
// TODO(random-liu): Convert PodStatus to running Pod, should be deprecated soon
func ConvertPodStatusToRunningPod(runtimeName string, podStatus *PodStatus) Pod {
	runningPod := Pod{
		ID:        podStatus.ID,
		Name:      podStatus.Name,
		Namespace: podStatus.Namespace,
	}
	for _, containerStatus := range podStatus.ContainerStatuses {

func (s *Base64Plugin) Version(ctx context.Context, request *kmsapi.VersionRequest) (*kmsapi.VersionResponse, error) {
	klog.V(3).InfoS("Received request for Version", "request", request)
	return &kmsapi.VersionResponse{Version: s.ver, RuntimeName: "testKMS", RuntimeVersion: "0.0.1"}, nil
}

// Decrypt performs base64 decoding of the payload of kms.DecryptRequest.