super(delegate);
  }

  RegularImmutableMap(Entry<? extends K, ? extends V>... entries) {
    this(/* throwIfDuplicateKeys= */ true, entries);
  }

  RegularImmutableMap(boolean throwIfDuplicateKeys, Entry<? extends K, ? extends V>[] entries) {
    super(throwIfDuplicateKeys, entries);
  }

    return populate(new HashMap<String, String>(), entries);
  }

  // TODO: call conversion constructors or factory methods instead of using
  // populate() on an empty map
  @CanIgnoreReturnValue
  private static <T, M extends Map<T, String>> M populate(M map, Entry<T, String>[] entries) {
    for (Entry<T, String> entry : entries) {
      map.put(entry.getKey(), entry.getValue());

  static final ImmutableMultiset<Object> EMPTY = create(ImmutableList.<Entry<Object>>of());

  static <E> ImmutableMultiset<E> create(Collection<? extends Entry<? extends E>> entries) {
    int distinct = entries.size();
    @SuppressWarnings({"unchecked", "rawtypes"})
    ImmutableEntry<E>[] entryArray = new ImmutableEntry[distinct];
    if (distinct == 0) {

    void testGetResultsReturnsDecodedEntries() throws Exception {
        response = new Smb2QueryDirectoryResponse(mockConfig, (byte) 0x03);

        // Use reflection to set the results field
        Field resultsField = Smb2QueryDirectoryResponse.class.getDeclaredField("results");
        resultsField.setAccessible(true);

  /**
   * Resizes the internal entries array to the specified capacity, which may be greater or less than
   * the current capacity.
   */
  void resizeEntries(int newCapacity) {
    this.keys = Arrays.copyOf(keys, newCapacity);
    this.values = Arrays.copyOf(values, newCapacity);
    long[] entries = this.entries;
    int oldCapacity = entries.length;
    entries = Arrays.copyOf(entries, newCapacity);

        if (entries == entryArray) {
          // Temporary variable is necessary to defeat bad smartcast (entries adopting the type of
          // entryArray) in the Kotlin translation.
          Entry<K, V>[] originalEntries = entries;
          entries = originalEntries.clone();
        }
      }
      entries[entryIndex] = effectiveEntry;
    }
    if (duplicates != null) {

    @Param(value = { "10000000" })
    int entries;

    private StreamInput streamInput;

    @Setup
    public void initResults() throws IOException {
        final BytesStreamOutput tmp = new BytesStreamOutput();
        for (int i = 0; i < entries / 2; i++) {
            tmp.writeVInt(i);
        }
        for (int i = 0; i < entries / 2; i++) {
            tmp.writeVInt(Integer.MAX_VALUE - i);
        }

    @Param(value = { "10000000" })
    int entries;

    private StreamInput streamInput;

    @Setup
    public void initResults() throws IOException {
        final BytesStreamOutput tmp = new BytesStreamOutput();
        for (int i = 0; i < entries / 2; i++) {
            tmp.writeVLong(i);
        }
        for (int i = 0; i < entries / 2; i++) {
            tmp.writeVLong(Long.MAX_VALUE - i);
        }

	}
}

var ssecUnsealObjectKeyTests = []struct {
	Headers        http.Header
	Bucket, Object string
	Metadata       map[string]string

	ExpectedErr error
}{
	{ // 0 - Valid HTTP headers and valid metadata entries for bucket/object
		Headers: http.Header{
			"X-Amz-Server-Side-Encryption-Customer-Algorithm": []string{"AES256"},
			"X-Amz-Server-Side-Encryption-Customer-Key":       []string{"MzJieXRlc2xvbmdzZWNyZXRrZXltdXN0cHJvdmlkZWQ="},

                new TestStringBiMapGenerator() {
                  @Override
                  protected BiMap<String, String> create(Entry<String, String>[] entries) {
                    BiMap<String, String> bimap = HashBiMap.create(entries.length);
                    for (Entry<String, String> entry : entries) {
                      checkArgument(!bimap.containsKey(entry.getKey()));
                      bimap.put(entry.getKey(), entry.getValue());