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")

        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() {

            createContainer(k, creator)
        }

        // Calculate the value after adding the entry to the map, so that the value container can take care of thread synchronization
        valueContainer.finalizeIfNotAlready()
        return valueContainer.get()
    }

    private
    fun createContainer(k: K, creator: () -> V): CalculatedValueContainer<BlockAddress, *> =

            @Unmanaged
            List getRawWidgets()
            void setRawWidgets(List l)
        }

        class Rules extends RuleSource {
            @Model
            void createContainer(Container c) {
                c.items = []
                c.widgets = []
                c.rawWidgets = []
            }

            @Mutate
            void addItems(Container c) {

	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

        dependsOn("dockerUp")     // dependsOn createContainer mustRunAfter removeContainer
        finalizedBy("dockerStop") // dependsOn removeContainer
    }

    register("dockerUp") {
        dependsOn("createContainer")
    }

    register("dockerStop") {
        dependsOn("removeContainer")
    }

    register("createContainer") {
        mustRunAfter("removeContainer")
    }