}

    @Override
    protected Future<V> delegate() {
      return delegate;
    }

    @Override
    public void addListener(Runnable listener, Executor exec) {
      executionList.add(listener, exec);

      // When a listener is first added, we run a task that will wait for the delegate to finish,
      // and when it is done will run the listeners.
      if (hasListeners.compareAndSet(false, true)) {

  }

  @Override
  public final State state() {
    return delegate.state();
  }

  /**
   * @since 13.0
   */
  @Override
  public final void addListener(Listener listener, Executor executor) {
    delegate.addListener(listener, executor);
  }

  /**
   * @since 14.0
   */
  @Override
  public final Throwable failureCause() {
    return delegate.failureCause();
  }

  /**

    }
  }

  /** See https://api.slack.com/rtm. */
  public WebSocket rtm(HttpUrl url, WebSocketListener listener) {
    return httpClient.newWebSocket(new Request.Builder()
        .url(url)
        .build(), listener);
  }

  static final class SlackJsonAdapters {
    @ToJson String urlToJson(HttpUrl httpUrl) {
      return httpUrl.toString();
    }

        return this;
    }

    /**
     * Connects to the URL and executes the request.
     *
     * @param actionListener the action listener for handling the response
     * @param exceptionListener the exception listener for handling exceptions
     */
    public void connect(final Consumer<HttpURLConnection> actionListener, final Consumer<Exception> exceptionListener) {

    }
    responseBody.close()
    assertEquals(if (connectionType == H2) 1 else 0, client.connectionPool.connectionCount())

    cancelLatch.await()

    val events = listener.eventSequence.filter { isConnectionEvent(it) }.map { it.name }
    listener.clearAllEvents()

    assertThat(events).startsWith("CallStart", "ConnectStart", "ConnectEnd", "ConnectionAcquired")
    if (cancelMode == CANCEL) {

  @Synchronized fun receivedPongCount(): Int = receivedPongCount

  @Throws(IOException::class)
  override fun onReadMessage(text: String) {
    listener.onMessage(this, text)
  }

  @Throws(IOException::class)
  override fun onReadMessage(bytes: ByteString) {
    listener.onMessage(this, bytes)
  }

  @Synchronized override fun onReadPing(payload: ByteString) {

        return super.getIfNewer(resourceName, destination, timestamp);
    }

    @Override
    public void addTransferListener(TransferListener listener) {
        if (listener instanceof TestTransferListener t) {
            testTransferListener = t;
        }
        super.addTransferListener(listener);
    }

 * @author Colin Decker
 */
class Subscriber {

  /** Creates a {@code Subscriber} for {@code method} on {@code listener}. */
  static Subscriber create(EventBus bus, Object listener, Method method) {
    return isDeclaredThreadSafe(method)
        ? new Subscriber(bus, listener, method)
        : new SynchronizedSubscriber(bus, listener, method);
  }

  /** The event bus this subscriber belongs to. */
  @Weak private final EventBus bus;

    object : WebSocketListener() {
    }
  val dispatcher = Dispatcher(executor)
  val listener = RecordingEventListener()
  var client =
    clientTestRule
      .newClientBuilder()
      .dns { throw UnknownHostException() }
      .dispatcher(dispatcher)
      .eventListenerFactory(clientTestRule.wrap(listener))
      .build()

  @BeforeEach
  fun setUp() {
    dispatcher.maxRequests = 20

       * lets all futures share the same listener.
       *
       * We store `localFuturesOrNull` inside the listener because `this.futures` might be nulled
       * out by the time the listener runs for the final future -- at which point we need to check
       * all inputs for exceptions *if* we're collecting values. If we're not, then the listener