return unmodifiableValueCollection(delegate.get(key));
    }

    @Override
    public Multiset<K> keys() {
      Multiset<K> result = keys;
      if (result == null) {
        keys = result = Multisets.unmodifiableMultiset(delegate.keys());
      }
      return result;
    }

    @Override
    public Set<K> keySet() {
      Set<K> result = keySet;

      return unmodifiableValueCollection(delegate.get(key));
    }

    @Override
    public Multiset<K> keys() {
      Multiset<K> result = keys;
      if (result == null) {
        keys = result = Multisets.unmodifiableMultiset(delegate.keys());
      }
      return result;
    }

    @Override
    public Set<K> keySet() {
      Set<K> result = keySet;

				accessKeys.STSKeys = append(accessKeys.STSKeys, madmin.ServiceAccountInfo{
					AccessKey:  sts.AccessKey,
					Expiration: &sts.Expiration,
				})
			}
			// if only STS keys, skip if user has no STS keys
			if !listServiceAccounts && len(stsKeys) == 0 {
				continue
			}
		}

		if listServiceAccounts {
			serviceAccounts, err := globalIAMSys.ListServiceAccounts(ctx, internalDN)

	}
	if v != "val1" {
		t.Fatalf("value differs from expected")
	}

	if !reflect.DeepEqual(lc.Keys(), []string{"key1"}) {
		t.Fatalf("value differs from expected")
	}
	if lc.Len() != 1 {
		t.Fatalf("length differs from expected")
	}

	lc.Add("key2", "val2")
	if !reflect.DeepEqual(lc.Keys(), []string{"key1", "key2"}) {
		t.Fatalf("value differs from expected")
	}
	if lc.Len() != 2 {

		tag, _ := tags.ParseObjectTags(userTags)
		if tag != nil {
			tagMap := tag.ToMap()
			keys := make([]string, 0, len(tagMap))
			for k, v := range tagMap {
				args[pathJoin("ExistingObjectTag", k)] = []string{v}
				args[pathJoin("RequestObjectTag", k)] = []string{v}
				keys = append(keys, k)
			}
			args["RequestObjectTagKeys"] = keys
		}
	}

	for _, objLock := range []string{
		xhttp.AmzObjectLockMode,

  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})
  public void testReplaceNonEmptyValues() {
    List<K> keys = copyToList(multimap().keySet());
    List<V> values = asList(v0(), v2(), v3());

    for (K k : keys) {
      resetContainer();

      int size = multimap().size();
      Collection<V> oldKeyValues = copyToList(multimap().get(k));

    assertEquals(multimap(), getSubjectGenerator().create());
    assertEmpty(multimap().entries());
    assertEmpty(multimap().asMap());
    assertEmpty(multimap().keySet());
    assertEmpty(multimap().keys());
    assertEmpty(multimap().values());
    for (K key : sampleKeys()) {
      assertGet(key);
    }
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testClear() {
    multimap().clear();

   * a map serialized by {@link #writeMap(Map, ObjectOutputStream)}, the number of distinct elements
   * in a multiset serialized by {@link #writeMultiset(Multiset, ObjectOutputStream)}, or the number
   * of distinct keys in a multimap serialized by {@link #writeMultimap(Multimap,
   * ObjectOutputStream)}.
   */
  static int readCount(ObjectInputStream stream) throws IOException {
    return stream.readInt();
  }

  /**

public class LoadingCacheSingleThreadBenchmark {
  @Param({"1000", "2000"})
  int maximumSize;

  @Param("5000")
  int distinctKeys;

  @Param("4")
  int segments;

  // 1 means uniform likelihood of keys; higher means some keys are more popular
  // tweak this to control hit rate
  @Param("2.5")
  double concentration;

  Random random = new Random();

  LoadingCache<Integer, Integer> cache;

  int max;

    }

    /** Case 5: Overwrite processing for multiple fields, existing overwrite keys are also properly removed */
    public void test_mergeResponseData_multipleOverwrite() {
        Map<String, Object> dataMap = new HashMap<>();
        // Case where the initial dataMap also contains overwrite keys
        dataMap.put("m", "M0");
        dataMap.put("n.overwrite", "N0_old");