outputContains "Supplying metadata for module org:testA:3"
        outputContains "Supplying metadata for module org:testA:2"
        outputContains "Supplying metadata for module org:testA:1"
        outputContains "Listing versions for module testB"
        outputContains "Listed [2, 1] for org:testB"
        outputContains "Supplying metadata for module org:testB:2"

)

var isMultipartTests = []struct {
	Metadata  map[string]string
	Multipart bool
}{
	{Multipart: true, Metadata: map[string]string{MetaMultipart: ""}},                          // 0
	{Multipart: true, Metadata: map[string]string{"X-Minio-Internal-Encrypted-Multipart": ""}}, // 1
	{Multipart: true, Metadata: map[string]string{MetaMultipart: "some-value"}},                // 2

//     -        metadata <- IV
//     -        metadata <- KeyID
//     -        metadata <- EncKey
//     -        metadata <- SealedKey
//     Output: enc_object_data, metadata
//
//  2. Decrypt:
//     Input: bucket, object, metadata, enc_object_data
//     -      KeyID  <- metadata
//     -      EncKey <- metadata
//     -          IV <- metadata
//     -   SealedKey <- metadata

apiVersion: v1
kind: Service
metadata:
  name: gce-metadata-server
  labels:
    app: gce-metadata
spec:
  # Use LB service so it can be reached cross cluster
  type: LoadBalancer
  ports:
  - name: http
    port: 8080
  - name: http-vm
    port: 8081
  selector:
    app: gce-metadata
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: gce-metadata-server
spec:
  replicas: 1

        }
    }

    def "parses minimal metadata resource"() {
        def metadata = Mock(MutableModuleComponentResolveMetadata)

        when:
        parser.parse(resource('{ "formatVersion": "1.1" }'), metadata)

        then:
        1 * metadata.getMutableVariants()
        0 * metadata._
    }

    def "parses minimal metadata with identity and producer information"() {

        and:
        metadata.size() == 3
        metadata[0].installDir == dir1
        metadata[0].visualCppDir == new File(dir1, "VC")
        metadata[0].visualCppVersion == VersionNumber.parse("14.0")
        metadata[0].version == VersionNumber.parse("14.0")
        metadata[0].compatibility == LEGACY

        metadata[1].installDir == dir2
        metadata[1].visualCppDir == new File(dir2, "VC")

            versioning.setRelease(version);
        }
        versioning.updateTimestamp();

        Metadata metadata = new Metadata();
        metadata.setGroupId(groupId);
        metadata.setArtifactId(artifactId);
        metadata.setVersioning(versioning);
        return metadata;
    }

        deps.each { name ->
            defaultVariant.addDependency("org.test", name, new DefaultMutableVersionConstraint("1.0"), [], null, ImmutableAttributes.EMPTY, [], false, null)
        }
        defaultVariant.addFile("producer-1.0.jar", "producer-1.0.jar")
        metadata
    }

    def "variant file metadata rules are evaluated once and lazily for #metadataType metadata"() {
        given:

        given:
        def metadata = new DirectDependencyMetadataImpl("g", "a", "v")

        when:
        metadata.endorseStrictVersions()
        metadata.doNotEndorseStrictVersions()

        then:
        metadata.endorsingStrictVersions == false
    }

    def "no selectors for newly added dependencies"() {
        given:
        def metadata = new DirectDependencyMetadataImpl("g", "a", "v")

		b    string
		want any
	}{
		{
			desc: "empty string into nil",
			a:    `metadata: ""`,
			b:    `metadata: `,
			want: ``,
		},
		{
			desc: "empty array into nil",
			a:    `metadata: []`,
			b:    `metadata: `,
			want: ``,
		},
		{
			desc: "empty map into nil",
			a:    `metadata: {}`,
			b:    `metadata: `,
			want: ``,
		},
		{
			desc: "two additional",