* value. Otherwise, a call that passes one {@code loader} may return the result of another call
   * with a differently behaving {@code loader}. For example, a call that requests a short timeout
   * for an RPC may wait for a similar call that requests a long timeout, or a call by an
   * unprivileged user may return a resource accessible only to a privileged user making a similar

  @Synchronized
  override fun onFailure(
    call: Call,
    e: IOException,
  ) {
    responses.add(RecordedResponse(call.request(), null, null, null, e))
    (this as Object).notifyAll()
  }

  @Synchronized
  override fun onResponse(
    call: Call,
    response: Response,
  ) {
    val body = response.body.string()
    responses.add(RecordedResponse(call.request(), response, null, body, null))

     *     {@link #whenAllComplete(Iterable)} or {@link #whenAllComplete(Iterable)}
     * @throws IllegalStateException if called outside of a call to {@link
     *     CombiningCallable#call(DeferredCloser, Peeker)} or {@link
     *     AsyncCombiningCallable#call(DeferredCloser, Peeker)}
     */
    @ParametricNullness
    public final <D extends @Nullable Object> D getDone(ClosingFuture<D> closingFuture)

    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) {

  @Test
  fun testFinish() {
    val okhttp = OkHttpClient()
    val callback =
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {}

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          response.close()
        }
      }
    repeat(10_000) {

    .help("Maximum time allowed for reading data (seconds)")
    .int()
    .default(DEFAULT_TIMEOUT)

  val callTimeout: Int by option(
    "--call-timeout",
  ).help(
    "Maximum time allowed for the entire call (seconds)",
  ).int()
    .default(DEFAULT_TIMEOUT)

  val followRedirects: Boolean by option("-L", "--location").help("Follow redirects").flag()

    client.newCall(Request(url)).enqueue(
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          println("failed: $e")
        }

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          println("response: ${response.code}")
          response.close()
        }
      },

      for (PerListenerQueue<L> queue : listeners) {
        queue.add(event, label);
      }
    }
  }

  /**
   * Dispatches all events enqueued prior to this call, serially and in order, for every listener.
   *
   * <p>Note: this method is idempotent and safe to call from any thread
   */
  public void dispatch() {
    // iterate by index to avoid concurrent modification exceptions

    var shouldClose: Boolean = false
    var lastSocket: Socket? = null

    override fun connectionAcquired(
      call: Call,
      connection: Connection,
    ) {
      lastSocket = connection.socket()
    }

    override fun requestHeadersStart(call: Call) {
      if (shouldClose) {
        lastSocket!!.close()
      }
    }
  }

  @Test
  fun socketFailureOnLargeRequestHeaders() {

   * {@link MoreExecutors#directExecutor}. Normally, when the first future completes, all the other
   * tasks would be called recursively. Here, we detect that the delegate executor is executing
   * inline, and maintain a queue to dispatch tasks iteratively. There is one instance of this class
   * per call to submit() or submitAsync(), and each instance supports only one call to execute().
   *