call: Call,
          e: IOException,
        ) {
          exceptionRef.set(e)
          latch.countDown()
        }

        @Throws(IOException::class)
        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          response.close()
          latch.countDown()
        }
      },
    )
    latch.await()

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

      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          continuation.resumeWithException(e)
        }

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          continuation.resume(response) { _, value, _ ->
            value.closeQuietly()
          }
        }
      },
    )

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

  @Volatile private var canceled = false

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

  internal fun processResponse(response: Response) {
    response.use {
      if (!response.isSuccessful) {

      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()
        }
      },
    )
  }

      object : Callback {
        override fun onFailure(
          call: Call,
          e: okio.IOException,
        ) {
          callFailure.complete(e)
        }

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

    // This should fail the Call, but not cause an unhandled Exception bubbling up

      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          promise.completeExceptionally(e)
        }

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          promise.complete(response)
        }
      },
    )

    val response = promise.get(4, SECONDS)

    var afterCallbackOnResponse: () -> Unit = {}

    override fun cancel() {
      canceled = true
    }

    override fun enqueue(responseCallback: Callback) {
      responseCallback.onResponse(this, response)
      afterCallbackOnResponse()
    }
  }

        } else {
            builder.setQuery(queryBuilder);
        }

        builder.execute(new ActionListener<SearchResponse>() {
            @Override
            public void onResponse(final SearchResponse searchResponse) {
                if (searchResponse.getFailedShards() > 0) {
                    deferred.reject(new SuggesterException("Search failure. Failed shards num:" + searchResponse.getFailedShards()));

        builder.setQuery(buildQuery());
        builder.setRescorer(buildRescore(), windowSize);

        builder.execute(new ActionListener<SearchResponse>() {
            @Override
            public void onResponse(final SearchResponse searchResponse) {
                if (searchResponse.getFailedShards() > 0) {
                    deferred.reject(new SuggesterException("Search failure. Failed shards num:" + searchResponse.getFailedShards()));