// to currentFuture doesn't race with itself so that currentFuture is assigned in the
        // correct order.
        Throwable scheduleFailure = null;
        Cancellable toReturn;
        lock.lock();
        try {
          toReturn = initializeOrUpdateCancellationDelegate(schedule);
        } catch (Throwable e) {
          // Any Exception is either a RuntimeException or sneaky checked exception.
          //

      this.delegate = null
      delegate.onClosed(webSocket, code, reason)
    } else {
      events.add(Closed(code, reason))
    }
  }

  override fun onFailure(
    webSocket: WebSocket,
    t: Throwable,
    response: Response?,
  ) {
    Platform.get().log("[WS $name] onFailure", Platform.INFO, t)
    val delegate = delegate
    if (delegate != null) {
      this.delegate = null

                  // which case we should skip right down to shutdown.
                  if (isRunning()) {
                    try {
                      AbstractExecutionThreadService.this.run();
                    } catch (Throwable t) {
                      restoreInterruptIfIsInterruptedException(t);
                      try {
                        shutDown();
                      } catch (Exception ignored) {

      this.runtime = runtime;
    }

    @Override
    public void uncaughtException(Thread t, Throwable e) {
      try {
        logger
            .get()
            .log(
                SEVERE,
                String.format(Locale.ROOT, "Caught an exception in %s.  Shutting down.", t),
                e);
      } catch (Throwable errorInLogging) { // sneaky checked exception

    AtomicBoolean actualIsOccupied = new AtomicBoolean();
    AtomicBoolean actualIsOccupiedByCurrentThread = new AtomicBoolean();
    AtomicInteger actualOccupiedDepth = new AtomicInteger();
    AtomicReference<Throwable> thrown = new AtomicReference<>();
    joinUninterruptibly(
        startThread(
            new Runnable() {
              @Override
              public void run() {
                try {

    AtomicBoolean actualIsOccupied = new AtomicBoolean();
    AtomicBoolean actualIsOccupiedByCurrentThread = new AtomicBoolean();
    AtomicInteger actualOccupiedDepth = new AtomicInteger();
    AtomicReference<Throwable> thrown = new AtomicReference<>();
    joinUninterruptibly(
        startThread(
            new Runnable() {
              @Override
              public void run() {
                try {

     */
    public ClUnsupportedOperationException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Creates a {@link ClUnsupportedOperationException}.
     *
     * @param cause the underlying exception
     */
    public ClUnsupportedOperationException(final Throwable cause) {
        super(cause);
    }

    get().log("[ES] onClosed", Platform.INFO, null)
    events.add(Closed)
    drainCancelQueue(eventSource)
  }

  override fun onFailure(
    eventSource: EventSource,
    t: Throwable?,
    response: Response?,
  ) {
    get().log("[ES] onFailure", Platform.INFO, t)
    events.add(Failure(t, response, t?.message ?: response?.body?.string()))
    drainCancelQueue(eventSource)
  }

      return sizeIfKnown.get() == 0L;
    }
    Closer closer = Closer.create();
    try {
      InputStream in = closer.register(openStream());
      return in.read() == -1;
    } catch (Throwable e) {
      throw closer.rethrow(e);
    } finally {
      closer.close();
    }
  }

  /**
   * Returns the size of this source in bytes, if the size can be easily determined without actually

    }

    @Override
    public OptionalThing<ApiResponse> handleServerException(final ApiFailureResource resource, final Throwable cause) {
        return OptionalThing.of(asJson(createFailureBean(Status.SYSTEM_ERROR, createMessage(resource, cause))));
    }

    // ===================================================================================