PodTerminationGracePeriod: pod.Spec.TerminationGracePeriodSeconds,
		Hash:                      kubecontainer.HashContainer(container),
		RestartCount:              restartCount,
		TerminationMessagePath:    container.TerminationMessagePath,
		PreStopHandler:            container.Lifecycle.PreStop,
	}

	featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.InPlacePodVerticalScaling, true)

			if err = os.WriteFile(fname, []byte(l), os.ModePerm); err != nil {
				scopes.Framework.Warnf("Unable to write logs for cluster/pod/container: %s/%s/%s/%s: %v",
					c.Name(), pod.Namespace, pod.Name, container.Name, err)
			}

			// Get previous container logs, if applicable
			if restarts := containerRestarts(pod, container.Name); restarts > 0 {

        when:
        EclipseProject project = loadToolingModel(EclipseProject)
        EclipseClasspathContainer container = project.classpathContainers.find { it.path == 'whenMergedContainerPath' }

        then:
        container != null
        container.exported == false
    }

    def "Classpath container can be configured"() {
        buildFile <<
        """apply plugin: 'java'
           apply plugin: 'eclipse'

			ID:   imageID(id),
			Size: size,
			Spec: container.ImageSpec{
				RuntimeHandler: runtimeHandler,
			},
		}
	}
}

// Make a container with the specified ID. It will use the image with the same ID.
func makeContainer(id int) *container.Container {
	return &container.Container{
		ID:      container.ContainerID{Type: "test", ID: fmt.Sprintf("container-%d", id)},
		Image:   imageName(id),

  // The k8s lifecycle hooks definition (pod.spec.containers.lifecycle) for the proxy container.
  // More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks
  k8s.io.api.core.v1.Lifecycle lifecycle = 36;

  // Controls if sidecar is injected at the front of the container list and blocks the start of the other containers until the proxy is ready
  //

// (pod, container) tuple. The key should include the content of the
// container, so that any change to the container generates a new key.
func getStableKey(pod *v1.Pod, container *v1.Container) string {
	hash := strconv.FormatUint(kubecontainer.HashContainer(container), 16)
	return fmt.Sprintf("%s_%s_%s_%s_%s", pod.Name, pod.Namespace, string(pod.UID), container.Name, hash)
}

        container.accessRules[0].kind == 0
        container.accessRules[0].pattern == 'id-accessible'
        container.accessRules[1].kind == 1
        container.accessRules[1].pattern == 'id-nonaccessible'
        container.accessRules[2].kind == 2
        container.accessRules[2].pattern == 'id-discouraged'
        container.accessRules[3].kind == 0
        container.accessRules[3].pattern == 'literal-accessible'

	labels[types.KubernetesContainerNameLabel] = container.Name

	return labels
}

// newContainerAnnotations creates container annotations from v1.Container and v1.Pod.
func newContainerAnnotations(container *v1.Container, pod *v1.Pod, restartCount int, opts *kubecontainer.RunContainerOptions) map[string]string {
	annotations := map[string]string{}

# 3.5

* Run the container image as non root user per default ([#97963](https://github.com/kubernetes/kubernetes/pull/97963))

# 3.4.1

* Support for Windows container images (OS Versions: 20H2) was added.([#97322](https://prs.k8s.io/97322), [@claudiubelu](https://github.com/claudiubelu))

# 3.4

	// This information is used by the caller to update a container config.
	GetResources(pod *v1.Pod, container *v1.Container) (*ContainerInfo, error)

	// PodMightNeedToUnprepareResources returns true if the pod with the given UID
	// might need to unprepare resources.
	PodMightNeedToUnprepareResources(UID types.UID) bool

	// GetContainerClaimInfos gets Container ClaimInfo objects