func (m *manager) AddContainer(pod *v1.Pod, container *v1.Container, containerID string) {
	m.Lock()
	defer m.Unlock()

	m.containerMap.Add(string(pod.UID), container.Name, containerID)

	// Since we know that each init container always runs to completion before
	// the next container starts, we can safely remove references to any previously
	// started init containers. This will free up the memory from these init containers

	assert.Equal(imageFsInfo.Timestamp, containerfs.Time.Time)
	assert.Equal(imageFsInfo.Available, *containerfs.AvailableBytes)
	assert.Equal(imageFsInfo.Capacity, *containerfs.CapacityBytes)
	assert.Equal(imageFsInfo.InodesFree, containerfs.InodesFree)
	assert.Equal(imageFsInfo.Inodes, containerfs.Inodes)
	assert.Equal(*imageFsInfo.Inodes-*imageFsInfo.InodesFree, *containerfs.InodesUsed)

}

func makeGCContainer(podName, containerName string, attempt int, createdAt int64, state runtimeapi.ContainerState) containerTemplate {
	container := makeTestContainer(containerName, "test-image")
	pod := makeTestPod(podName, "test-ns", podName, []v1.Container{container})
	return containerTemplate{
		pod:       pod,
		container: &container,
		attempt:   attempt,
		createdAt: createdAt,
		state:     state,
	}
}

      annotations:
        istio.io/rev: default
        kubectl.kubernetes.io/default-container: name1
        kubectl.kubernetes.io/default-logs-container: name1
        prometheus.io/path: /stats/prometheus
        prometheus.io/port: "15020"
        prometheus.io/scrape: "true"

  template:
    metadata:
      labels:
        istio: ingressgateway
    spec:
      # Ensure we can have istio-proxy as the only container. This isn't particularly useful as a sidecar
      # but will be used when we have a dedicated template to run a pod as a Gateway
      containers:
      - name: istio-proxy

# _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
# Lasta Di properties, you can set container's options
# _/_/_/_/_/_/_/_/_/_/

# location of smart-deploy mode e.g. maihama_env.properties: lasta_di.smart.deploy.mode
#smart.deploy.mode.location = maihama_env.properties: lasta_di.smart.deploy.mode

# package for smart deploy target e.g. org.docksidestage.app
smart.package1 = org.codelibs.fess.crawler

	limits := reuseOrClearResourceList(opts.Reuse)

	for _, container := range pod.Spec.Containers {
		if opts.ContainerFn != nil {
			opts.ContainerFn(container.Resources.Limits, podutil.Containers)
		}
		addResourceList(limits, container.Resources.Limits)
	}

	restartableInitContainerLimits := v1.ResourceList{}
	initContainerLimits := v1.ResourceList{}
	// init containers define the minimum of any resource
	//

	}

	if containerSc.RunAsUser != nil {
		effectiveSc.RunAsUser = new(int64)
		*effectiveSc.RunAsUser = *containerSc.RunAsUser
	}

	if containerSc.RunAsGroup != nil {
		effectiveSc.RunAsGroup = new(int64)
		*effectiveSc.RunAsGroup = *containerSc.RunAsGroup
	}

	if containerSc.RunAsNonRoot != nil {
		effectiveSc.RunAsNonRoot = new(bool)
		*effectiveSc.RunAsNonRoot = *containerSc.RunAsNonRoot

func (m *MockRuntime) DeleteContainer(ctx context.Context, containerID container.ContainerID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteContainer", ctx, containerID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteContainer indicates an expected call of DeleteContainer.
func (mr *MockRuntimeMockRecorder) DeleteContainer(ctx, containerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()

    type: typeValue
  containerStatuses:
  - allocatedResources:
      allocatedResourcesKey: "0"
    containerID: containerIDValue
    image: imageValue
    imageID: imageIDValue
    lastState:
      running:
        startedAt: "2001-01-01T01:01:01Z"
      terminated:
        containerID: containerIDValue
        exitCode: 1
        finishedAt: "2006-01-01T01:01:01Z"
        message: messageValue