builder.append(value);
        return this;
    }

    public Ansi a(long value) {
        flushAttributes();
        builder.append(value);
        return this;
    }

    public Ansi a(Object value) {
        flushAttributes();
        builder.append(value);
        return this;
    }

    public Ansi a(StringBuffer value) {
        flushAttributes();
        builder.append(value);

    // Setting a low transfer speed ensures that stream discarding will time out.
    val builder =
      MockResponse.Builder()
        .throttleBody(6, 1, TimeUnit.SECONDS)
    transferKind.setBody(builder, "ABCDE\nFGHIJKLMNOPQRSTUVWXYZ", 1024)
    server.enqueue(builder.build())
    server.enqueue(
      MockResponse.Builder()
        .body("Request #2")
        .build(),
    )
    val response1 = get(server.url("/"))

    Escapers.Builder builder = Escapers.builder();
    builder.setSafeRange('a', 'z');
    builder.setUnsafeReplacement("X");
    assertEquals("XheXXuickXXrownXXoxX", builder.build().escape("The Quick Brown Fox!"));
    // Explicit replacements take priority over unsafe characters.
    builder.addEscape(' ', "_");
    builder.addEscape('!', "_");

    public SortedMap<String, String> create(Entry<String, String>[] entries) {
      ImmutableSortedMap.Builder<String, String> builder = ImmutableSortedMap.naturalOrder();
      for (Entry<String, String> entry : entries) {
        checkNotNull(entry);
        builder.put(entry.getKey(), entry.getValue());
      }
      return builder.build();
    }
  }

  public static class ImmutableSortedMapCopyOfEntriesGenerator

        try (OutputStream out = SearchEngineUtil.getXContentBuilderOutputStream((builder, params) -> {
            builder.startObject();
            if (fieldSet.contains(CLUSTER_NAME)) {
                builder.field(CLUSTER_NAME, response.getClusterName());
            }
            if (fieldSet.contains(STATUS)) {
                builder.field(STATUS, response.getStatus().name().toLowerCase(Locale.ROOT));
            }

func (onConflict OnConflict) Build(builder Builder) {
	if onConflict.OnConstraint != "" {
		builder.WriteString("ON CONSTRAINT ")
		builder.WriteString(onConflict.OnConstraint)
		builder.WriteByte(' ')
	} else {
		if len(onConflict.Columns) > 0 {
			builder.WriteByte('(')
			for idx, column := range onConflict.Columns {
				if idx > 0 {
					builder.WriteByte(',')
				}
				builder.WriteQuoted(column)
			}

    CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder();
    assertThrows(IllegalArgumentException.class, () -> builder.initialCapacity(-1));
  }

  public void testInitialCapacity_setTwice() {
    CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder().initialCapacity(16);
    assertThrows(IllegalStateException.class, () -> builder.initialCapacity(16));
  }

  @GwtIncompatible // CacheTesting

[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.

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

  /**

    this.streamHandler = builder.streamHandler
    this.webSocketListener = builder.webSocketListener
    this.inTunnel = builder.inTunnel
    this.informationalResponses = builder.informationalResponses.toList()
    this.throttleBytesPerPeriod = builder.throttleBytesPerPeriod
    this.throttlePeriodNanos = builder.throttlePeriodNanos
    this.socketPolicy = builder.socketPolicy
    this.bodyDelayNanos = builder.bodyDelayNanos