}

        try {
            T result = callable.call();
            onSuccess();
            return result;
        } catch (Exception e) {
            onFailure();
            throw e;
        }
    }

    /**
     * Execute a runnable through the circuit breaker
     *
     * @param runnable the runnable to execute

        .url(url)
        .build()

    val promise = CompletableFuture<Response>()

    val call = client.newCall(request)
    call.enqueue(
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          promise.completeExceptionally(e)
        }

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

              return
            }

          // Apply the extensions. If they're unacceptable initiate a graceful shut down.
          // TODO(jwilson): Listeners should get onFailure() instead of onClosing() + onClosed(1010).
          val extensions = WebSocketExtensions.parse(response.headers)
          ******@****.***ions = extensions
          if (!extensions.isValid()) {

    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`.

                } else {
                    deferred.resolve(createResponse(searchResponse));
                }
            }

            @Override
            public void onFailure(final Exception e) {
                deferred.reject(e);
            }
        });
    }

    @Override
    protected String getValidationError() {
        return null;
    }

    /**

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

    failures: MutableList<Exception>,
  ) {
    val latch = CountDownLatch(networkRequests.size)

    for (call in networkRequests) {
      call.enqueue(
        object : Callback {
          override fun onFailure(
            call: Call,
            e: IOException,
          ) {
            synchronized(failures) {
              failures.add(e)
            }
            latch.countDown()
          }

                } else {
                    deferred.resolve(createResponse(searchResponse));
                }
            }

            @Override
            public void onFailure(final Exception e) {
                deferred.reject(new SuggesterException(e.getMessage(), e));
            }
        });
    }

    private boolean isSingleWordQuery(final String query) {

        override fun clone(): Call = TODO()
      }
  }

  @Test
  fun callback() {
    val callback =
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) = TODO()

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

 *   public void onResponse(Call call, Response response) throws IOException {
 *     try (ResponseBody responseBody = response.body()) {
 *     ... // Use the response.
 *     }
 *   }
 *
 *   public void onFailure(Call call, IOException e) {
 *   ... // Handle the failure.
 *   }
 * });
 * ```
 *
 * These examples will not work if you're consuming the response body on another thread. In such