}

  @GwtIncompatible // maximumWeight
  public void testMaximumWeight_setTwice() {
    CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder().maximumWeight(16);
    assertThrows(IllegalStateException.class, () -> builder.maximumWeight(16));
    assertThrows(IllegalStateException.class, () -> builder.maximumSize(16));
  }

        IllegalArgumentException.class, () -> ImmutableMultimap.builder().expectedValuesPerKey(-1));
  }

  public void testBuilderWithExpectedValuesPerKeyZero() {
    ImmutableMultimap.Builder<String, String> builder =
        ImmutableMultimap.<String, String>builder().expectedValuesPerKey(0);
    builder.put("key", "value");
    assertThat(builder.build().entries()).containsExactly(immutableEntry("key", "value"));
  }

Jesse Wilson <******@****.***> 1749917366 -0600

Yuri Schimke <******@****.***> 1746875714 +0100

    return new AbstractMap.SimpleImmutableEntry<>(key, value);
  }

  /**
   * Returns a new builder. The generated builder is equivalent to the builder created by the {@link
   * Builder} constructor.
   */
  public static <K, V> Builder<K, V> builder() {
    return new Builder<>();
  }

  /**
   * Returns a new builder, expecting the specified number of entries to be added.
   *

    assertThat(builder.status).isEqualTo("HTTP/1.1 202 That'll do pig")
  }

  @Test
  fun setBodyAdjustsHeaders() {
    val builder = MockResponse.Builder().body("ABC")
    assertThat(headersToList(builder)).containsExactly("Content-Length: 3")
    val response = builder.build()
    val body = Buffer()
    response.body!!.writeTo(body)

    ImmutableSetMultimap.Builder<K, V> builder = ImmutableSetMultimap.builder();
    builder.put(k1, v1);
    builder.put(k2, v2);
    builder.put(k3, v3);
    builder.put(k4, v4);
    builder.put(k5, v5);
    return builder.build();
  }

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

  /** Returns a new {@link Builder}. */
  public static <K, V> Builder<K, V> builder() {

        .signedBy(intermediateCa)
        .serialNumber(3L)
        .commonName(server.hostName)
        .build()
    val certificatePinner =
      CertificatePinner
        .Builder()
        .add(server.hostName, pin(rootCa.certificate))
        .build()
    val handshakeCertificates =
      HandshakeCertificates
        .Builder()
        .addTrustedCertificate(rootCa.certificate)
        .build()
    val client =

        .dns(DoubleInetAddressDns()) // Two routes!
        .build()
    server.enqueue(
      MockResponse
        .Builder()
        .onRequestStart(CloseStream(ErrorCode.REFUSED_STREAM.httpCode))
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .onRequestStart(CloseStream(ErrorCode.REFUSED_STREAM.httpCode))
        .build(),
    )
    server.enqueue(
      MockResponse

    assertFalse(pin.matchesCertificate(certB1.certificate))
  }

  @Test fun pinList() {
    val builder =
      CertificatePinner
        .Builder()
        .add("example.com", CertificatePinnerTest.certA1Sha256Pin)
        .add("www.example.com", CertificatePinnerTest.certA1Sha256Pin)
    val certificatePinner = builder.build()

    val expectedPins =
      listOf(