when:
        container.addRule(rule1)
        container.addClassRule(rule2)

        then:
        !container.isEmpty()
        !container.isClassBasedRulesOnly()
        def iterator = container.iterator()
        def ruleWrapper = iterator.next()
        !ruleWrapper.isClassBased()
        ruleWrapper.rule == rule1
        def ruleWrapper2 = iterator.next()
        ruleWrapper2.isClassBased()

        when:
        container.library('someLib')
        container.project('otherProject').library('someLib')
        container.project('otherProject')

        container.library('someLib')
        container.library('someLib').project('otherProject')
        container.project('otherProject')

        then:
        container.dependencies.size() == 3

	var providersHints []map[string][]TopologyHint

	for _, provider := range s.hintProviders {
		// Get the TopologyHints for a Container from a provider.
		hints := provider.GetTopologyHints(pod, container)
		providersHints = append(providersHints, hints)
		klog.InfoS("TopologyHints", "hints", hints, "pod", klog.KObj(pod), "containerName", container.Name)
	}

    /**
     * Returns an empty mutable attribute container.
     */
    AttributeContainerInternal mutable();

    /**
     * Returns an empty mutable attribute container with the given fallback.
     */
    AttributeContainerInternal mutable(AttributeContainerInternal fallback);

    /**
     * Returns a new attribute container which attaches a primary container and a fallback container. Changes

        Container container = createContainer()
        container.nativeLibraryLocation += 'x'

        expect:
        container != createContainer()
    }

    private Container createContainer() {
        Container container = new Container('somePath')
        container.exported = true
        container.nativeLibraryLocation = 'mynative'
        container.accessRules += [new AccessRule('nonaccessible', 'secret**')]

        def action = Mock(Action)
        container.beforeCollectionChanges(action)

        when:
        container.removeAll(["a", "b"])

        then:
        1 * action.execute(null)
        0 * _
    }

    def callsVetoActionOnceBeforeCollectionIsIntersected() {
        def action = Mock(Action)
        container.add("a")
        container.add("b")
        container.beforeCollectionChanges(action)

		},
		{
			pod: newPod("best-effort-hugepages", []v1.Container{
				newContainer("best-effort", addResource("hugepages-2Mi", "1Gi", getResourceList("0", "0")), addResource("hugepages-2Mi", "1Gi", getResourceList("0", "0"))),
			}),
			expected: v1.PodQOSBestEffort,
		},
		{
			pod: newPodWithInitContainers("init-container",
				[]v1.Container{

        }

        // regular syntax
        container.getByName("alice") {
            foo = "alice-foo"
        }
        container.create("bob") {
            foo = "bob-foo"
        }
        container.maybeCreate("john")

        container.named("marty")
        container.register("doc")

        // invoke syntax
        container {
            getByName("alice") {
                foo = "alice-foo"

						{}, {},
					},
				},
			},
			// should accumulate once per container without a request
			expected: map[v1.ResourceName]int64{
				v1.ResourceCPU:    2 * util.DefaultMilliCPURequest,
				v1.ResourceMemory: 2 * util.DefaultMemoryRequest,
			},
		},
		{
			name: "request container + requestless container",
			pod: v1.Pod{
				Spec: v1.PodSpec{
					Containers: []v1.Container{
						{

		PodTerminationGracePeriod: pod.Spec.TerminationGracePeriodSeconds,
		Hash:                      kubecontainer.HashContainer(container),
		RestartCount:              restartCount,
		TerminationMessagePath:    container.TerminationMessagePath,
		PreStopHandler:            container.Lifecycle.PreStop,
	}

	featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.InPlacePodVerticalScaling, true)