BooleanQuery.Builder innerBoolQueryBuilder = new BooleanQuery.Builder();
        TermQuery innerTermQuery = new TermQuery(new Term("innerField", "innerValue"));
        innerBoolQueryBuilder.add(innerTermQuery, BooleanClause.Occur.MUST);
        BooleanQuery innerBooleanQuery = innerBoolQueryBuilder.build();

        // Create outer BooleanQuery
        BooleanQuery.Builder outerBoolQueryBuilder = new BooleanQuery.Builder();

        ExtendedPluginDescriptor(Builder builder) {
            super(builder);
            this.additionalField = builder.additionalField;
        }

        public String getAdditionalField() {
            return additionalField;
        }

        static class Builder extends PluginDescriptor.Builder {
            protected String additionalField;

            Builder() {
                super(false);

    val headers =
      Headers
        .Builder()
        .add("WWW-Authenticate: Basic realm=\"protected area\"")
        .build()
    assertThat(headers.parseChallenges("WWW-Authenticate"))
      .isEqualTo(listOf(Challenge("Basic", mapOf("realm" to "protected area"))))
  }

  @Test fun basicChallengeWithCharset() {
    val headers =
      Headers
        .Builder()

    @Nonnull
    static ProjectBuilderRequestBuilder builder() {
        return new ProjectBuilderRequestBuilder();
    }

    /**
     * Builder for creating ProjectBuilderRequest instances.
     * This builder provides a fluent API for setting the various properties of a request.
     */
    @NotThreadSafe
    class ProjectBuilderRequestBuilder {
        Session session;
        RequestTrace trace;
        Path path;

  }

  private static final Joiner JOINER = Joiner.on(", ");

  @Override
  protected final void assertMoreInvariants(Map<K, V> map) {
    // TODO: can these be moved to MapInterfaceTest?
    for (Entry<K, V> entry : map.entrySet()) {
      assertThat(entry.toString()).isEqualTo(entry.getKey() + "=" + entry.getValue());
    }

    assertThat(map.toString()).isEqualTo("{" + JOINER.join(map.entrySet()) + "}");

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

            BUILDER builder = call.apply(esEntity);
            if (builder instanceof IndexRequestBuilder) {
                if (builderEntityCall != null) {
                    builderEntityCall.callback(builder);
                }
                bulkBuilder.add((IndexRequestBuilder) builder);
            } else if (builder instanceof UpdateRequestBuilder) {

      )
    for (i in 0..599) {
      val builder = MockResponse.Builder().code(i)
      val expectedReason = reasons[i / 100]
      assertThat(builder.status).isEqualTo("HTTP/1.1 $i $expectedReason")
      assertThat(headersToList(builder)).containsExactly("Content-Length: 0")
    }
  }

  @Test
  fun setStatusControlsWholeStatusLine() {
    val builder = MockResponse.Builder().status("HTTP/1.1 202 That'll do pig")

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

  /**