}

    /**
     * This test has
     *   - a BOM import which itself imports the junit BOM which manages the dep to 0.1
     *   - a BOM import to the junit BOM which manages the dep to 0.2
     *   - a direct managed dependency to the dep at 0.3 (as suggested by the warning)
     * This results in 0.3 (explicit managed wins) and no warning
     */
    @Test
    void testManagedDependencyDistanceWithExplicit() throws Exception {

            assert container.size() == 1
        """

        expect:
        succeeds()
    }

    def "plugin can create NamedDomainObjectContainer instances that creates decorated elements of a named managed type"() {
        given:
        buildFile """
            interface NamedThing extends Named {
                Property<String> getProp()
            }

	// OmitManagedFields indicates whether to omit the managed fields of the request
	// and response bodies from being written to the API audit log.
	// This is used as a global default - a value of 'true' will omit the managed fileds,
	// otherwise the managed fields will be included in the API audit log.
	// Note that this can also be specified per rule in which case the value specified

		want     bool
	}{
		{
			label: "Empty managed resources",
			extender: &HTTPExtender{
				managedResources: sets.New[string](),
			},
			pod:  &v1.Pod{},
			want: true,
		},
		{
			label:    "Managed memory, empty resources",
			extender: mem,
			pod:      st.MakePod().Container("app").Obj(),
			want:     false,
		},
		{
			label:    "Managed memory, container memory with Requests",

					"node.alpha.kubernetes.io/ttl":                           "0",
					"volumes.kubernetes.io/controller-managed-attach-detach": "true",
				},
			},
			wantFmtStr: `flannel.alpha.coreos.com/backend-data="{\"VNI\":1,\"VtepMAC\":\"ce:f9:c7:a4:de:64\"}"
flannel.alpha.coreos.com/backend-type="vxlan"
flannel.alpha.coreos.com/kube-subnet-manager="true"
flannel.alpha.coreos.com/public-ip="192.168.19.160"

        buildFile << """
            @Managed
            interface MyModel {
                String value
            }

            // Define some binary and component types.
            interface SampleBinarySpec extends BinarySpec {}
            class DefaultSampleBinary extends BaseBinarySpec implements SampleBinarySpec {}

            @Managed interface SampleComponent extends ComponentSpec{}

    }

    def "creates isolated named managed type"() {
        def instantiator = TestUtil.objectInstantiator()
        def value = instantiator.named(Thing, "value1")

        expect:
        def isolated = isolatableFactory.isolate(value)
        isolated instanceof IsolatedImmutableManagedValue
        isolated.isolate().is(value)
    }

    def "can coerce named managed type"() {

//
// The input limit is provided as bytes, and includes all memory
// mapped, managed, and not released by the Go runtime. Notably, it
// does not account for space used by the Go binary and memory
// external to Go, such as memory managed by the underlying system
// on behalf of the process, or memory managed by non-Go code inside
// the same process. Examples of excluded memory sources include: OS

        result.setArtifactResolutionNodes(set);

        return result;
    }

    /**
     * Get the map of managed versions, removing the originating artifact if it is also in managed versions
     *
     * @param originatingArtifact artifact we are processing
     * @param managedVersions original managed versions
     */
    private ManagedVersionMap getManagedVersionsMap(

    }

    def "managed jvm args includes heap settings"() {
        expect:
        parse("-Xms1G -XX:-PrintClassHistogram -Xmx2G -Dfoo.encoding=blah").managedJvmArgs == ["-Xms1G", "-Xmx2G", "-Dfile.encoding=${defaultCharset}", *localePropertyStrings()]
    }

    def "managed jvm args includes file encoding"() {
        expect: