would never call back if it crashed with an unchecked throwable, such as a
    `NullPointerException` or `OutOfMemoryError`. We now call `Callback.onFailure()` with an
    `IOException` that reports the call as canceled. The triggering exception is still delivered to
    the thread's `UncaughtExceptionHandler`.

        if (failure != null) {
          callback.onFailure(failure);
          return;
        }
      }
      final V value;
      try {
        value = getDone(future);
      } catch (ExecutionException e) {
        callback.onFailure(e.getCause());
        return;
      } catch (Throwable e) {

    requestCanceledLatch: CountDownLatch?,
  ) {
    val call = client.newCall(Request(server.url("/")))
    val latch = CountDownLatch(1)
    call.enqueue(
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          latch.countDown()
        }

        override fun onResponse(
          call: Call,
          response: Response,

        if (failure != null) {
          callback.onFailure(failure);
          return;
        }
      }
      final V value;
      try {
        value = getDone(future);
      } catch (ExecutionException e) {
        callback.onFailure(e.getCause());
        return;
      } catch (Throwable e) {

     * assume that connectivity has been lost. When this happens on a web socket the connection is
     * canceled and its listener is [notified][WebSocketListener.onFailure]. When it happens on an
     * HTTP/2 connection the connection is closed and any calls it is carrying
     * [will fail with an IOException][java.io.IOException].
     *

        Request.Builder()
          .url(server.url("/"))
          .build(),
      )
    val completionLatch = CountDownLatch(1)
    val callback: Callback =
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          completionLatch.countDown()
        }

        override fun onResponse(
          call: Call,
          response: Response,

	public static final field TYPE_AAAA I
	public abstract fun query (Ljava/lang/String;Lokhttp3/AsyncDns$Callback;)V
}

public abstract interface class okhttp3/AsyncDns$Callback {
	public abstract fun onFailure (Ljava/lang/String;Ljava/io/IOException;)V
	public abstract fun onResponse (Ljava/lang/String;Ljava/util/List;)V
}

public final class okhttp3/AsyncDns$Companion {
	public static final field TYPE_A I

                    logger.debug(() -> "Refreshed " + stream(indices).get(stream -> stream.collect(Collectors.joining(", "))));
                }
            }

            @Override
            public void onFailure(final Exception e) {
                logger.error(() -> "Failed to refresh " + stream(indices).get(stream -> stream.collect(Collectors.joining(", "))), e);
            }
        });

    }