assertThat(map.needsAllocArrays()).isTrue();
    assertThat(map.entries).isNull();
    assertThat(map.keys).isNull();
    assertThat(map.values).isNull();

    map.put(1, "1");
    assertThat(map.needsAllocArrays()).isFalse();
    assertThat(map.entries).hasLength(CompactHashing.DEFAULT_SIZE);
    assertThat(map.keys).hasLength(CompactHashing.DEFAULT_SIZE);
    assertThat(map.values).hasLength(CompactHashing.DEFAULT_SIZE);
  }

	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 {

  public void testPutPresentKeyPropagatesToGet() {
    List<K> keys = copyToList(multimap().keySet());
    for (K key : keys) {
      resetContainer();

      int size = getNumElements();

      Collection<V> collection = multimap().get(key);
      Collection<V> expectedCollection = copyToList(collection);

      multimap().put(key, v3());
      expectedCollection.add(v3());

  public void testPutPresentKeyPropagatesToGet() {
    List<K> keys = copyToList(multimap().keySet());
    for (K key : keys) {
      resetContainer();

      int size = getNumElements();

      Collection<V> collection = multimap().get(key);
      Collection<V> expectedCollection = copyToList(collection);

      multimap().put(key, v3());
      expectedCollection.add(v3());

    public static List<KerberosAuthData> parse ( int authType, byte[] token, Map<Integer, KerberosKey> keys ) throws PACDecodingException {

        List<KerberosAuthData> authorizations = new ArrayList<>();

        switch ( authType ) {
        case KerberosConstants.AUTH_DATA_RELEVANT:
            authorizations = new KerberosRelevantAuthData(token, keys).getAuthorizations();
            break;
        case KerberosConstants.AUTH_DATA_PAC:

    /**
     * @param type
     * @param keys
     * @return the calculated mac
     * @throws PACDecodingException
     */
    public static byte[] calculateMac ( int type, Map<Integer, KerberosKey> keys, byte[] data ) throws PACDecodingException {
        try {
            int usage = 17;
            if ( type == PacSignature.KERB_CHECKSUM_HMAC_MD5 ) {
                KerberosKey key = keys.get(PacSignature.ETYPE_ARCFOUR_HMAC);

	}

	// Check returned key list is correct
	if test.wantKeyNames != nil {
		keys := []madmin.KMSKeyInfo{}
		err := json.Unmarshal(rec.Body.Bytes(), &keys)
		if err != nil {
			t.Fatal(err)
		}
		if len(keys) != len(test.wantKeyNames) {
			t.Fatalf("want %d keys, got %d", len(test.wantKeyNames), len(keys))
		}

		for i, want := range keys {
			if want.CreatedBy != kms.StubCreatedBy {

  Multiset<K> createKeys() {
    return new Keys();
  }

  @WeakOuter
  class Keys extends Multimaps.Keys<K, V> {
    Keys() {
      super(FilteredEntryMultimap.this);
    }

    @Override
    public int remove(@CheckForNull Object key, int occurrences) {
      checkNonnegative(occurrences, "occurrences");
      if (occurrences == 0) {
        return count(key);
      }

	}
	keys := make([]ObjectKey, 0, len(metadata))
	for i := range metadata {
		key, err := s3.UnsealObjectKey(k, metadata[i], buckets[i], objects[i])
		if err != nil {
			return nil, err
		}
		keys = append(keys, key)
	}
	return keys, nil
}

// CreateMetadata encodes the sealed object key into the metadata and returns

@SuppressWarnings ( "javadoc" )
public class KerberosApRequest {

    private byte apOptions;
    private KerberosTicket ticket;


    public KerberosApRequest ( byte[] token, KerberosKey[] keys ) throws PACDecodingException {
        this(parseSequence(token), keys);
    }

    private static ASN1Sequence parseSequence(byte[] token) throws PACDecodingException {
        if ( token.length <= 0 )