}
}
// 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[]

		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'
    }

// tag::container-api[]
tasks.create("greeting") {
    doLast { println("Hello, World!") }
}
// end::container-api[]

// tag::typed-container-api[]
tasks.create<Zip>("docZip") {
    archiveFileName = "doc.zip"
    from("doc")
}

    DefaultPublicationContainer container = instantiator.newInstance(DefaultPublicationContainer, instantiator, CollectionCallbackActionDecorator.NOOP)

    def "exception is thrown on unknown access"() {
        given:
        container.add(publication("foo"))

        expect:
        container.foo instanceof Publication

        when:
        container.getByName("notHere")

        then:

		done; \
	done
	docker manifest push --purge ${IMAGE}:${TAG}

all-container-docker: $(addprefix sub-container-docker-,$(ALL_OS_ARCH.linux))
all-container-registry: $(addprefix sub-container-registry-,$(ALL_OS_ARCH))

# split words on hyphen, access by 1-index
word-hyphen = $(word $2,$(subst -, ,$1))
sub-container-%:

// DeviceRunContainerOptions contains the combined container runtime settings to consume its allocated devices.
type DeviceRunContainerOptions struct {
	// The environment variables list.
	Envs []kubecontainer.EnvVar
	// The mounts for the container.
	Mounts []kubecontainer.Mount
	// The host devices mapped into the container.
	Devices []kubecontainer.DeviceInfo
	// The Annotations for the container
	Annotations []kubecontainer.Annotation