def "can create container with fixed value"() {
        def container = new CalculatedValueContainer(Describables.of("thing"), "value")

        expect:
        container.get() == "value"
        container.getValue().get() == "value"
    }

    def "calculates and caches value"() {
        def calculator = Mock(ValueCalculator)

        when:

        container.getByName("foo") == extension
        container.findByName("bar") == barExtension

        container.getByType(BarExtension) == barExtension
        container.findByType(FooExtension) == extension

        container.findByType(SomeExtension) == null
        container.findByName("i don't exist") == null
    }

    def "throws when unknown exception wanted by name"() {
        container.add("foo", extension)

// within the given pod. Returns an error if the reference can't be constructed or the
// container doesn't actually belong to the pod.
func GenerateContainerRef(pod *v1.Pod, container *v1.Container) (*v1.ObjectReference, error) {
	fieldPath, err := fieldPath(pod, container)
	if err != nil {
		// TODO: figure out intelligent way to refer to containers that we implicitly

        container.withType(container.type).named("a", getType(), method)
        then:
        ex = thrown(Throwable)
        assertDoesNotAllowMethod(ex, methodUnderTest)

        when:
        container.matching({ it in container.type }).named("a").configure(method)
        then:
        ex = thrown(Throwable)
        assertDoesNotAllowMethod(ex, methodUnderTest)

        when:

        parent.collect({it.name}).containsAll(["created1", "created2", "created3"])

        and:
        container.getByName("created1").value == "original"
        container.getByName("created2").value == "changed"
        container.getByName("created3").value == "actioned"
    }

    def "can create and configure via DSL"() {
        when:

                }
            }

            def container = project.container(Bean)
            container.create("one") {
                assert name == "one"
            }
        """

        expect:
        succeeds()
        outputContains("got it")
    }

    def "fails when container element requests unknown service"() {
        buildFile """
            interface Unknown { }

    def "container with attribute which doesn't use @Incubating is not reported"() {
        def container = new DefaultMutableAttributeContainer(attributesFactory)
        container.attribute(Usage.USAGE_ATTRIBUTE, TestUtil.objectFactory().named(Usage, Usage.JAVA_API))

        expect:
        !IncubatingAttributesChecker.isAnyIncubating(container)
    }

    def "container with @Incubating attribute is reported"() {

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

			"pod", klog.KObj(pod), "containerName", container.Name)
	}
	if effectiveSc.SELinuxOptions != nil {
		klog.InfoS("Windows container does not support SecurityContext.SELinuxOptions, please use SecurityContext.WindowsOptions",
			"pod", klog.KObj(pod), "containerName", container.Name)
	}
	if effectiveSc.RunAsGroup != nil {

        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