*     without resizing
   * @throws IllegalArgumentException if {@code expectedSize} is negative
   */
  @SuppressWarnings("NonApiType") // acts as a direct substitute for a constructor call
  public static <E extends @Nullable Object> HashSet<E> newHashSetWithExpectedSize(
      int expectedSize) {
    return new HashSet<>(Maps.capacity(expectedSize));
  }

  /**

   *
   * @param expectedSize the initial capacity of this {@code CompactHashMap}.
   */
  CompactHashMap(int expectedSize) {
    init(expectedSize);
  }

  /** Pseudoconstructor for serialization support. */
  void init(int expectedSize) {
    Preconditions.checkArgument(expectedSize >= 0, "Expected size must be >= 0");

    // Save expectedSize for use in allocArrays()

      map.put(1, Integer.toString(1));
      assertThat(map.needsAllocArrays()).isFalse();
      int expectedSize = max(1, i);
      assertThat(map.entries).hasLength(expectedSize);
      assertThat(map.keys).hasLength(expectedSize);
      assertThat(map.values).hasLength(expectedSize);
      assertThat(map.links).hasLength(expectedSize);
    }
  }

  static byte[] toByteArray(InputStream in, long expectedSize) throws IOException {
    checkArgument(expectedSize >= 0, "expectedSize (%s) must be non-negative", expectedSize);
    if (expectedSize > MAX_ARRAY_LEN) {
      throw new OutOfMemoryError(expectedSize + " bytes is too large to fit in a byte array");
    }

    byte[] bytes = new byte[(int) expectedSize];
    int remaining = (int) expectedSize;

    while (remaining > 0) {

    MinMaxPriorityQueue<Integer> queue = MinMaxPriorityQueue.expectedSize(8).create();
    assertEquals(8, queue.capacity());
    checkUnbounded(queue);
    checkNatural(queue);
  }

  public void testCreation_expectedSize_comparator() {
    MinMaxPriorityQueue<Integer> queue =
        MinMaxPriorityQueue.orderedBy(SOME_COMPARATOR).expectedSize(8).create();
    assertEquals(8, queue.capacity());

   * @since 23.1
   */
  public static <K, V> Builder<K, V> builderWithExpectedSize(int expectedSize) {
    checkNonnegative(expectedSize, "expectedSize");
    return new Builder<>(expectedSize);
  }

  static void checkNoConflict(
      boolean safe, String conflictDescription, Object entry1, Object entry2) {
    if (!safe) {
      throw conflictException(conflictDescription, entry1, entry2);
    }
  }

  }

  public static <K, V> Builder<K, V> builder() {
    return new Builder<K, V>();
  }

  public static <K, V> Builder<K, V> builderWithExpectedSize(int expectedSize) {
    return new Builder<K, V>(expectedSize);
  }

  static <K, V> Entry<K, V> entryOf(K key, V value) {
    checkEntryNotNull(key, value);
    return Maps.immutableEntry(key, value);
  }

    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() {

   * @throws ClassCastException if a data element has the wrong type
   */
  protected abstract Table<String, Integer, C> create(@Nullable Object... data);

  protected void assertSize(int expectedSize) {
    assertEquals(expectedSize, table.size());
  }

  @Override
  public void setUp() throws Exception {
    super.setUp();
    table = create();
  }

  public void testContains() {

    }

    @Override
    ImmutableCollection.Builder<V> newValueCollectionBuilderWithExpectedSize(int expectedSize) {
      return (valueComparator == null)
          ? ImmutableSet.builderWithExpectedSize(expectedSize)
          : new ImmutableSortedSet.Builder<V>(valueComparator, expectedSize);
    }

    @Override
    int expectedValueCollectionSize(int defaultExpectedValues, Iterable<?> values) {