mapEntry("b", (Collection<String>) ImmutableSortedSet.of("bob", "bagel")),
                        mapEntry("c", (Collection<String>) ImmutableSortedSet.of("carl", "carol")),
                        mapEntry("d", (Collection<String>) ImmutableSortedSet.of("david", "dead")),
                        mapEntry(

        } else {
            buf.append('"').append(StringEscapeUtils.escapeJson(value.toString())).append('"');
        }
        return buf;
    }

    /**
     * Get the write call for search log ndjson.
     * @return The write call.
     */
    public static Consumer<Writer> getSearchLogNdjsonWriteCall() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

   * for APIs like {@link #whenAllComplete whenAllComplete(...)}{@code .}{@link
   * FutureCombiner#call(Callable, Executor) call(...)}, where it is easy to use a new input from
   * the {@code call} implementation but forget to add it to the arguments of {@code
   * whenAllComplete}.
   *

) : EventSource,
  ServerSentEventReader.Callback,
  Callback {
  constructor(call: Call, listener: EventSourceListener) : this(call, call.request(), listener)

  constructor(response: Response, listener: EventSourceListener) : this(null, response.request, listener)

  @Volatile private var canceled = false

  override fun onResponse(
    call: Call,
    response: Response,
  ) {
    processResponse(response)
  }

        newCapacity = Integer.MAX_VALUE; // guaranteed to be >= newCapacity
      }
      return newCapacity;
    }

    /**
     * Returns a new immutable array. The builder can continue to be used after this call, to append
     * more values and build again.
     *
     * <p><b>Performance note:</b> the returned array is backed by the same array as the builder, so

  public void testReturning() throws Exception {
    assertNull(Callables.returning(null).call());

    Object value = new Object();
    Callable<Object> callable = Callables.returning(value);
    assertSame(value, callable.call());
    // Expect the same value on subsequent calls
    assertSame(value, callable.call());
  }

  @J2ktIncompatible
  @GwtIncompatible
  public void testAsAsyncCallable() throws Exception {

        .setSocketPolicy(SocketPolicy.STALL_SOCKET_AT_START),
    )
    server.start()
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    call.enqueue(
      object : Callback {
        override fun onFailure(
          call: Call,
          e: okio.IOException,
        ) {
          callFailure.complete(e)
        }

    ListenableFuture<Boolean> future2 =
        serializer.submit(
            new Callable<Boolean>() {
              @Override
              public Boolean call() {
                return blockingCallable.isRunning();
              }
            },
            directExecutor());

    fun newEventSource(
      request: Request,
      listener: EventSourceListener,
    ): EventSource

    companion object {
      /**
       * Wraps a [Call.Factory] into [EventSource.Factory].
       */
      @JvmStatic
      @JvmName("create")
      fun Call.Factory.asEventSourceFactory(): Factory =
        Factory { request, listener ->
          val actualRequest =
            if (request.header("Accept") == null) {

   * eliminate duplicate keys (for buildKeepingLast()) then we have to ensure that a later call to
   * buildOrThrow() will still throw as if the duplicates had not been eliminated. And the exception
   * message must mention two values that were associated with the duplicate key in two different
   * calls to Builder.put (though we don't really care *which* two values if there were more than