}

  // looking for of() with > 10 entries? Use the builder instead.

  @SafeVarargs
  public static <K, V> ImmutableMap<K, V> ofEntries(Entry<? extends K, ? extends V>... entries) {
    return new RegularImmutableMap<>(entries);
  }

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

  public static <K, V> Builder<K, V> builderWithExpectedSize(int expectedSize) {

    @Override
    protected List<String> create(String[] elements) {
      ImmutableList.Builder<String> builder = ImmutableList.<String>builder();
      for (String element : elements) {
        builder.add(element);
      }
      return builder.build();
    }
  }

  public static class BuilderAddAllListGenerator extends TestStringListGenerator {
    @Override

        () -> builder.build(CacheLoader.from(Suppliers.ofInstance(null))));
  }

  @SuppressWarnings("ReturnValueIgnored")
  public void testMaximumSize_withWeigher() {
    CacheBuilder<Object, Object> builder = CacheBuilder.from(parse("maximumSize=9000"));
    builder.weigher(constantWeigher(42)).build(CacheLoader.from(Suppliers.ofInstance(null)));
  }

  @SuppressWarnings("ReturnValueIgnored")

          Response
            .Builder()
            .request(chain.request())
            .protocol(Protocol.HTTP_1_1)
            .code(200)
            .message("OK")
            .body("Hello".toResponseBody())
            .header("Content-Encoding", "piedpiper")
            .build()
        }.build()

    ImmutableSortedSet.Builder<LegacyComparable> builder =
        ImmutableSortedSet.<LegacyComparable>naturalOrder();

    builder.addAll(LegacyComparable.VALUES_BACKWARD);
    builder.add(LegacyComparable.X);
    builder.add(LegacyComparable.Y, LegacyComparable.Z);

    ImmutableSortedSet<LegacyComparable> set = builder.build();
    assertTrue(elementsEqual(LegacyComparable.VALUES_FORWARD, set));

  public void testBuilder_presize_zero() {
    ImmutableDoubleArray.Builder builder = ImmutableDoubleArray.builder(0);
    builder.add(5.0);
    ImmutableDoubleArray array = builder.build();
    assertThat(array.asList()).containsExactly(5.0);
  }

  public void testBuilder_presize_negative() {
    assertThrows(IllegalArgumentException.class, () -> ImmutableDoubleArray.builder(-1));
  }

  /**

    val request =
      Request
        .Builder()
        .url("https://server/robots.txt")
        .build()
    val response =
      Response
        .Builder()
        .request(request)
        .code(401)
        .header("WWW-Authenticate", "Basic realm=\"User Visible Realm\"")
        .protocol(HTTP_2)
        .message("Unauthorized")
        .build()

    ImmutableList.Builder<String> httpHeaders = ImmutableList.builder();
    for (Field field : httpHeadersFields()) {
      httpHeaders.add((String) field.get(null));
    }
    assertThat(httpHeaders.build()).containsNoDuplicates();
  }

  private static ImmutableSet<Field> httpHeadersFields() {
    ImmutableSet.Builder<Field> builder = ImmutableSet.builder();

  public static final MediaType MEDIA_TYPE_JSON = MediaType.get("application/json");

  private final OkHttpClient client = new OkHttpClient.Builder()
      .addInterceptor(new GzipRequestInterceptor())
      .build();
  private final Moshi moshi = new Moshi.Builder().build();
  private final JsonAdapter<Map<String, String>> mapJsonAdapter = moshi.adapter(
      Types.newParameterizedType(Map.class, String.class, String.class));

                .userToolchainsSource(userToolchainsSource)
                .build();
    }

    @Nonnull
    static ToolchainsBuilderRequest build(
            @Nonnull ProtoSession session,
            @Nullable Path installationToolchainsFile,
            @Nullable Path userToolchainsPath) {
        return builder()
                .session(requireNonNull(session, "session cannot be null"))