Handler: mux,
	}
	go func() {
		server.Serve(l)
	}()

	recordOperation("create_container", time.Now())
	runtimeOperationsCounterExpected := "kubelet_runtime_operations_total{operation_type=\"create_container\"} 1"
	runtimeOperationsDurationExpected := "kubelet_runtime_operations_duration_seconds_count{operation_type=\"create_container\"} 1"

	assert.HTTPBodyContains(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

	recordError(operation, err)
	return out, err
}

func (in instrumentedRuntimeService) CreateContainer(ctx context.Context, podSandboxID string, config *runtimeapi.ContainerConfig, sandboxConfig *runtimeapi.PodSandboxConfig) (string, error) {
	const operation = "create_container"
	defer recordOperation(operation, time.Now())

	out, err := in.service.CreateContainer(ctx, podSandboxID, config, sandboxConfig)
	recordError(operation, err)
	return out, err

        then:
        container == createContainer()
    }

    def canWriteToXml() {
        Node rootNode = new Node(null, 'root')

        when:
        createContainer().appendNode(rootNode)

        then:
        new Container(rootNode.classpathentry[0]) == createContainer()
    }

    def equality() {
        Container container = createContainer()
        container.nativeLibraryLocation += 'x'

        }
    }

    DefaultReportContainer createContainer(Closure cl) {
        try {
            TestUtil.instantiatorFactory().decorateLenient().newInstance(TestReportContainer, cl)
        } catch (ObjectInstantiationException e) {
            throw e.cause
        }
    }

    DefaultReportContainer container

    def setup() {
        container = createContainer {
            createReport("a")

        ImmutableList.Builder<ClasspathEntry> entries = ImmutableList.builder();
        entries.add(createOutput());
        entries.addAll(createSourceFolders());
        entries.addAll(createContainers());
        entries.addAll(createDependencies());
        entries.addAll(createClassFolders());
        return entries.build();
    }

    private ClasspathEntry createOutput() {

        buildScript """

        @Managed
        interface Container {
            $type<String> getItems()
        }

        class Rules extends RuleSource {
            @Model
            void createContainer(Container c) {}

            @Mutate
            void addItems(Container c) {
                c.items.add 'foo'
            }

            @Mutate

            task dockerTest(type: BreakingTask) {
                dependsOn 'dockerUp'     // dependsOn createContainer mustRunAfter removeContainer
                finalizedBy 'dockerStop' // dependsOn removeContainer
            }

            task dockerUp(type: BreakingTask) {
                dependsOn 'createContainer'
            }

            task dockerStop(type: BreakingTask) {

class TaskReportContainerTest extends Specification {

    final Project project = ProjectBuilder.builder().build()
    final TestTask task = project.task("testTask", type: TestTask)

    def container = createContainer {
        dir("b")
        file("a")
    }

    static class TestTask extends DefaultTask {
        @Nested
        TaskReportContainer<Report> reports
    }

    def barney = new DefaultPerson(name: "barney")
    def agedBarney = new DefaultAgeAwarePerson(name: "barney", age: 42)

    def container = createContainer()

    private DefaultPolymorphicDomainObjectContainer<Person> createContainer() {

See the License for the specific language governing permissions and
limitations under the License.
*/

package events

// Container event reason list
const (
	CreatedContainer        = "Created"
	StartedContainer        = "Started"
	FailedToCreateContainer = "Failed"
	FailedToStartContainer  = "Failed"
	KillingContainer        = "Killing"
	PreemptContainer        = "Preempting"