assertThrows(IllegalArgumentException.class, () -> builder.addCopies("a", -2));
  }

  public void testBuilderSetCountHandlesNullsCorrectly() {
    ImmutableSortedMultiset.Builder<String> builder =
        new ImmutableSortedMultiset.Builder<>(Ordering.natural().nullsFirst());
    assertThrows(NullPointerException.class, () -> builder.setCount(null, 2));
  }

    server.enqueue(
      MockResponse
        .Builder()
        .code(301)
        .addHeader("Location", "/foo")
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .body("ABC")
        .build(),
    )
    val call =
      client.newCallWithListener(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),

  }

  private fun newEventSource(accept: String? = null): EventSource {
    val builder =
      Request
        .Builder()
        .url(server.url("/"))
    if (accept != null) {
      builder.header("Accept", accept)
    }
    val request = builder.build()
    val factory = createFactory(client)
    return factory.newEventSource(request, listener)
  }

	public final fun includeIPv6 (Z)Lokhttp3/dnsoverhttps/DnsOverHttps$Builder;
	public final fun post (Z)Lokhttp3/dnsoverhttps/DnsOverHttps$Builder;
	public final fun resolvePrivateAddresses (Z)Lokhttp3/dnsoverhttps/DnsOverHttps$Builder;
	public final fun resolvePublicAddresses (Z)Lokhttp3/dnsoverhttps/DnsOverHttps$Builder;
	public final fun systemDns (Lokhttp3/Dns;)Lokhttp3/dnsoverhttps/DnsOverHttps$Builder;

[builder][held_certificate_builder] to create a self-signed certificate that a test server can use
for HTTPS:

```java
HeldCertificate localhostCertificate = new HeldCertificate.Builder()
    .addSubjectAlternativeName("localhost")
    .build();
```

[`HandshakeCertificates`][handshake_certificates] keeps the certificates for a TLS handshake.

    assertThrows(IllegalArgumentException.class, () -> builder.addCopies("a", -2));
  }

  public void testBuilderSetCountHandlesNullsCorrectly() {
    ImmutableSortedMultiset.Builder<String> builder =
        new ImmutableSortedMultiset.Builder<>(Ordering.natural().nullsFirst());
    assertThrows(NullPointerException.class, () -> builder.setCount(null, 2));
  }

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

    webServer.enqueue(
      MockResponse
        .Builder()
        .code(408)
        .build(),
    )
    webServer.enqueue(
      MockResponse
        .Builder()
        .webSocketUpgrade(serverListener)
        .build(),
    )
    val webSocket: WebSocket = newWebSocket()
    clientListener.assertOpen()
    val server = serverListener.assertOpen()
    webSocket.send("abc")

  public void testBuilder_presize_zero() {
    ImmutableLongArray.Builder builder = ImmutableLongArray.builder(0);
    builder.add(5L);
    ImmutableLongArray array = builder.build();
    assertThat(array.asList()).containsExactly(5L);
  }

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

  /**

      ValueGraph<N, V> graph) {
    // ImmutableMap.Builder maintains the order of the elements as inserted, so the map will have
    // whatever ordering the graph's nodes do, so ImmutableSortedMap is unnecessary even if the
    // input nodes are sorted.
    ImmutableMap.Builder<N, GraphConnections<N, V>> nodeConnections = ImmutableMap.builder();
    for (N node : graph.nodes()) {