for _, container := range pod.Spec.InitContainers {
				if !types.IsRestartableInitContainer(&container) {
					continue
				}

				pRes.Containers = append(pRes.Containers, p.getContainerResources(pod, &container))
			}
		}

		for _, container := range pod.Spec.Containers {
			pRes.Containers = append(pRes.Containers, p.getContainerResources(pod, &container))
		}
		podResources[i] = &pRes
	}

            }

            def container = objects.domainObjectContainer(NamedThing)
            container.register("foo")

            container.foo.prop()
            configure(container.foo) {
                prop()
            }
            container.configure {
                foo {
                    prop()
                }
            }

            assert container.foo.prop.counter == 3
        """

    }
}
// end::ndos[]

// tag::ndol[]

abstract class MyPluginExtensionNamedDomainObjectList {
    // Define a named domain object container to hold Person objects
    NamedDomainObjectList<Person> people = project.container(Person)

    // Add a person to the container
    void addPerson(String name) {
        people.create(name: name)
    }
}
// end::ndol[]

// tag::ndoc[]

// license that can be found in the LICENSE file.

package a

type Container[T any] struct {
	X T
}

func NewContainer[T any](x T) *Container[T] {
	return &Container[T]{x}
}

type MetaContainer struct {
	C *Container[Value]
}

type Value struct{}

func NewMetaContainer() *MetaContainer {
	c := NewContainer(Value{})
	// c := &Container[Value]{Value{}} // <-- this works
	return &MetaContainer{c}

}

func (i *internalContainerLifecycleImpl) PreStartContainer(pod *v1.Pod, container *v1.Container, containerID string) error {
	if i.cpuManager != nil {
		i.cpuManager.AddContainer(pod, container, containerID)
	}

	if i.memoryManager != nil {
		i.memoryManager.AddContainer(pod, container, containerID)
	}

	i.topologyManager.AddContainer(pod, container, containerID)

	return nil
}

		Windows: m.generateWindowsContainerResources(pod, container),
	}
}

// generateWindowsContainerResources generates windows container resources config for runtime
func (m *kubeGenericRuntimeManager) generateWindowsContainerResources(pod *v1.Pod, container *v1.Container) *runtimeapi.WindowsContainerResources {
	wcr := m.calculateWindowsResources(container.Resources.Limits.Cpu(), container.Resources.Limits.Memory())

	return wcr
}

    }

    GradleInContainer withBuildDir(File buildDirectory) {
        container.withWorkingDirectory("/test-build")
        container.withCopyFileToContainer(MountableFile.forHostPath(buildDirectory.toPath()), "/test-build")
        this
    }

    @PackageScope
    GradleExecResult execute(String... command) {
        if (!started) {
            container.withCommand("tail", "-f", "/dev/null")
            startContainer()
        }

import java.util.Collection;

/**
 * A container for dependency specifications.
 */
@Incubating @UnmanagedStruct
public interface DependencySpecContainer {

    /**
     * Defines a new dependency, based on a project path. The returned dependency can be mutated.
     *
     * @param path the project path
     *
     * @return a mutable dependency, added to this container
     */

		podProfile:        unconfined,
		expectedProfile:   localhost,
	}}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			container := v1.Container{
				Name: "foo",
			}
			if test.containerProfile != nil {
				container.SecurityContext = &v1.SecurityContext{
					AppArmorProfile: test.containerProfile.DeepCopy(),
				}
			}
			pod := v1.Pod{
				ObjectMeta: metav1.ObjectMeta{

        EclipseClasspathContainer container = project.classpathContainers.find { it.path == 'classpathContainerPath' }

        then:
        container.accessRules.size() == 2
        container.accessRules[0].kind == 0
        container.accessRules[0].pattern == 'accessibleFilesPattern'
        container.accessRules[1].kind == 1
        container.accessRules[1].pattern == 'nonAccessibleFilesPattern'
    }