var keys []string
	keyval := make(map[string]string, len(headers))
	for key := range headers {
		lkey := strings.ToLower(key)
		if !strings.HasPrefix(lkey, "x-amz-") {
			continue
		}
		keys = append(keys, lkey)
		keyval[lkey] = strings.Join(headers[key], ",")
	}
	sort.Strings(keys)
	var canonicalHeaders []string
	for _, key := range keys {

    for (K key : multimap().keySet()) {
      SortedSet<V> valueSet = (SortedSet<V>) multimap().asMap().get(key);
      assertEquals(multimap().valueComparator(), valueSet.comparator());
    }
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testAsMapRemoveImplementsSortedSet() {
    List<K> keys = new ArrayList<>(multimap().keySet());
    for (K key : keys) {
      resetCollection();

                for (KerberosKey key : keys) {
                    keysByAlgo.put(key.getKeyType(), key);
                }

                KerberosKey serverKey = keysByAlgo.get(encType.getValue().intValue());
                if (keysByAlgo.isEmpty() || serverKey == null) {
                    throw new PACDecodingException("Kerberos key not found for eType " + encType.getValue());
                }

        # String columns may not be needed
        # to be set these condition-keys basically.
        #; GreaterThan = map:{}
        #; LessThan = map:{}
        #; GreaterEqual = map:{}
        #; LessEqual = map:{}

        # [Exclude]
        # Common columns of String type may not be needed
        # to be set these condition-keys basically.
        #; !NotEqual = map:{ $$ALL$$ = list:{ $$CommonColumn$$ } }

      return;
    }

    Set<K> keys = map.keySet();
    K key = keys.iterator().next();
    if (supportsRemove) {
      int initialSize = map.size();
      keys.remove(key);
      assertEquals(initialSize - 1, map.size());
      assertFalse(map.containsKey(key));
    } else {
      assertThrows(UnsupportedOperationException.class, () -> keys.remove(key));
    }
    assertInvariants(map);
  }

// and options for generating data keys.
type GenerateKeyRequest struct {
	// Name is the name of the master key used to generate
	// the data key.
	Name string

	// AssociatedData is optional data that is cryptographically
	// associated with the generated data key. The same data
	// must be provided when decrypting an encrypted data key.
	//
	// Typically, associated data is some metadata about the

        val unrecognizedContributors = contributorsFromPullRequests.keys - contributorsInReleaseNotes.keys
        if (unrecognizedContributors.isNotEmpty()) {
            val contributorsToUpdate = contributorsInReleaseNotes + unrecognizedContributors.map { it to contributorsFromPullRequests[it]!! }
            val sortedContributors = contributorsToUpdate.entries.sortedBy { (it.value.name ?: it.key).lowercase() }

export MINIO_ROOT_PASSWORD=minio123`,
			false,
			[]envKV{
				{
					Key:   "MINIO_ROOT_USER",
					Value: "minio",
				},
				{
					Key:   "MINIO_ROOT_PASSWORD",
					Value: "minio123",
				},
			},
		},
		// Value with double quotes
		{
			`export MINIO_ROOT_USER="minio"`,
			false,
			[]envKV{
				{
					Key:   "MINIO_ROOT_USER",
					Value: "minio",
				},
			},
		},

     * Constructs KerberosEncData from encrypted token bytes.
     *
     * @param token the encrypted Kerberos token
     * @param keys map of encryption keys indexed by key type
     * @throws PACDecodingException if decoding fails
     */
    public KerberosEncData(byte[] token, Map<Integer, KerberosKey> keys) throws PACDecodingException {
        ASN1InputStream stream = new ASN1InputStream(new ByteArrayInputStream(token));

     * Puts multiple values for a given key in the metadata.
     *
     * @param key the metadata key
     * @param values the values to associate with the key
     */
    public void putValues(final String key, final String[] values) {
        metadata.put(key, values);
    }

    /**
     * Puts a single value for a given key in the metadata.
     *
     * @param key the metadata key