return unsafeDelegateList(list);
  }

  public static <E> Builder<E> builder() {
    return new Builder<E>();
  }

  public static <E> Builder<E> builderWithExpectedSize(int expectedSize) {
    return new Builder<E>(expectedSize);
  }

  public static final class Builder<E> extends ImmutableCollection.Builder<E> {
    private final ArrayList<E> contents;

    public Builder() {

        // Expected size: 24 (fixed) + 2 * number of dialects
        int expectedSize = 24 + 2 * defaultDialects.length;
        assertEquals(expectedSize, request.size());
    }

    @Test
    @DisplayName("Test size calculation with single dialect")
    void testSizeWithSingleDialect() {

          Integer.MAX_VALUE - 1,
          Integer.MAX_VALUE
        };
    for (int expectedSize : largeExpectedSizes) {
      int capacity = Maps.capacity(expectedSize);
      assertTrue(
          "capacity (" + capacity + ") must be >= expectedSize (" + expectedSize + ")",
          capacity >= expectedSize);
    }
  }

  public void testLinkedHashMap() {

    public Builder(Comparator<? super E> comparator) {
      this.comparator = checkNotNull(comparator);
    }

    Builder(Comparator<? super E> comparator, int expectedSize) {
      super(expectedSize);
      this.comparator = checkNotNull(comparator);
    }

    @CanIgnoreReturnValue
    @Override
    public Builder<E> add(E element) {
      super.add(element);
      return this;

          Integer.MAX_VALUE - 1,
          Integer.MAX_VALUE
        };
    for (int expectedSize : largeExpectedSizes) {
      int capacity = Maps.capacity(expectedSize);
      assertTrue(
          "capacity (" + capacity + ") must be >= expectedSize (" + expectedSize + ")",
          capacity >= expectedSize);
    }
  }

  public void testLinkedHashMap() {

        builderMap = result;
      }
      return result;
    }

    ImmutableCollection.Builder<V> newValueCollectionBuilderWithExpectedSize(int expectedSize) {
      return ImmutableList.builderWithExpectedSize(expectedSize);
    }

    /**
     * Provides a hint for how many values will be associated with each key newly added to the

        void testSizeWithVariousCombinations(int algoCount, int saltSize, int expectedSize) {
            int[] hashAlgos = algoCount > 0 ? new int[algoCount] : null;
            byte[] salt = saltSize > 0 ? new byte[saltSize] : null;
            PreauthIntegrityNegotiateContext context = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

            assertEquals(expectedSize, context.size());
        }

        builderMap = result;
      }
      return result;
    }

    ImmutableCollection.Builder<V> newValueCollectionBuilderWithExpectedSize(int expectedSize) {
      return ImmutableList.builderWithExpectedSize(expectedSize);
    }

    /**
     * Provides a hint for how many values will be associated with each key newly added to the

// checkPart is a light check of an existing and size of a part, without doing a bitrot operation
// For any unexpected error, return checkPartUnknown (zero)
func (s *xlStorage) checkPart(volumeDir, path, dataDir string, partNum int, expectedSize int64, skipAccessCheck bool) (resp int) {
	partPath := pathJoin(path, dataDir, fmt.Sprintf("part.%d", partNum))
	filePath := pathJoin(volumeDir, partPath)
	st, err := Lstat(filePath)
	if err != nil {

   */
  @DoNotCall("Use naturalOrder (which does not accept an expected size)")
  @Deprecated
  public static <K, V> ImmutableSortedMap.Builder<K, V> builderWithExpectedSize(int expectedSize) {
    throw new UnsupportedOperationException();
  }

  /**
   * Not supported. <b>You are attempting to create a map that may contain a non-{@code Comparable}