@Nullable Object[] alternatingKeysAndValues;
    int size;
    boolean entriesUsed;

    /**
     * If non-null, a duplicate key we found in a previous buildKeepingLast() or buildOrThrow()
     * call. A later buildOrThrow() can simply report this duplicate immediately.
     */
    @Nullable DuplicateKey duplicateKey;

    /**

     *
     * <p>Prefer the equivalent method {@link #buildOrThrow()} to make it explicit that the method
     * will throw an exception if there are duplicate keys. The {@code build()} method will soon be
     * deprecated.
     *
     * @throws IllegalArgumentException if duplicate keys were added
     */
    public ImmutableMap<K, V> build() {
      return buildOrThrow();
    }

    /**

            .put("SEC_WEBSOCKET_VERSION", "Sec-WebSocket-Version")
            .put("X_WEBKIT_CSP", "X-WebKit-CSP")
            .put("X_WEBKIT_CSP_REPORT_ONLY", "X-WebKit-CSP-Report-Only")
            .buildOrThrow();
    ImmutableSet<String> uppercaseAcronyms =
        ImmutableSet.of(
            "CDN", "CH", "ID", "DNT", "DNS", "DPR", "ECT", "GPC", "HTTP2", "IP", "MD5", "P3P",

                .put("one", 1)
                .put("two", 2)
                .put("three", 3)
                .put("four", 4)
                .put("five", 5)
                .buildOrThrow());
    assertMapEquals(bimap, "one", 1, "two", 2, "three", 3, "four", 4, "five", 5);
    assertMapEquals(bimap.inverse(), 1, "one", 2, "two", 3, "three", 4, "four", 5, "five");
  }

   *         .put(1, "one")
   *         .put(2, "two")
   *         .put(3, "three")
   *         .buildOrThrow();
   * }
   *
   * <p>For <i>small</i> immutable sorted maps, the {@code ImmutableSortedMap.of()} methods are even
   * more convenient.
   *
   * <p>Builder instances can be reused - it is safe to call {@link #buildOrThrow} multiple times to
   * build multiple maps in series. Each map is a superset of the maps created before it.

      return buildOrThrow();
    }

    private ImmutableMap<K, V> build(boolean throwIfDuplicateKeys) {
      if (valueComparator != null) {
        Collections.sort(entries, Ordering.from(valueComparator).onResultOf(Entry::getValue));
      }
      return fromEntryList(throwIfDuplicateKeys, entries);
    }

    public ImmutableMap<K, V> buildOrThrow() {

    }

    @Override
    public ImmutableSortedMap<K, V> build() {
      return buildOrThrow();
    }

    @Override
    public ImmutableSortedMap<K, V> buildOrThrow() {
      SortedMap<K, V> delegate = newModifiableDelegate(comparator);
      for (Entry<? extends K, ? extends V> entry : entries) {
        putEntryWithChecks(delegate, entry);

   *         .put(1, "one")
   *         .put(2, "two")
   *         .put(3, "three")
   *         .buildOrThrow();
   * }
   *
   * <p>For <i>small</i> immutable sorted maps, the {@code ImmutableSortedMap.of()} methods are even
   * more convenient.
   *
   * <p>Builder instances can be reused - it is safe to call {@link #buildOrThrow} multiple times to
   * build multiple maps in series. Each map is a superset of the maps created before it.

    ImmutableSortedMap<String, Integer> expected =
        ImmutableSortedMap.<String, Integer>naturalOrder()
            .put("one", 1)
            .put("three", 3)
            .put("two", 2)
            .buildOrThrow();
    CollectorTester.of(collector, equivalence)
        .expectCollects(expected, mapEntry("one", 1), mapEntry("two", 2), mapEntry("three", 3));
  }

  public void testToImmutableSortedMap_withComparator() {

          .put("HmacSHA1", SHA1_KEY, hmacSha1(SHA1_KEY))
          .put("HmacSHA256", SHA256_KEY, hmacSha256(SHA256_KEY))
          .put("HmacSHA512", SHA512_KEY, hmacSha512(SHA512_KEY))
          .buildOrThrow();

  public void testNulls() {
    NullPointerTester tester =
        new NullPointerTester().setDefault(String.class, "HmacMD5").setDefault(Key.class, MD5_KEY);