client.listener.assertFailure(IOException::class.java, "source is closed")
    assertThat(client.closed).isTrue()
  }

  @Test
  fun pingOnInterval() {
    client.initWebSocket(random, pingIntervalMillis = 500)
    taskFaker.advanceUntil(ns(500L))
    server.processNextFrame() // Ping.
    client.processNextFrame() // Pong.
    taskFaker.advanceUntil(ns(1000L))
    server.processNextFrame() // Ping.

      writeTimeoutMillis = writeTimeoutMillis,
      socketConnectTimeoutMillis = socketConnectTimeoutMillis,
      socketReadTimeoutMillis = socketReadTimeoutMillis,
      pingIntervalMillis = pingIntervalMillis,
      retryOnConnectionFailure = retryOnConnectionFailure,
      user = user,
      routePlanner = routePlanner,
      route = route,
      routes = routes,
      attempt = attempt,

      }

    fun pushObserver(pushObserver: PushObserver) =
      apply {
        this.pushObserver = pushObserver
      }

    fun pingIntervalMillis(pingIntervalMillis: Int) =
      apply {
        this.pingIntervalMillis = pingIntervalMillis
      }

    fun flowControlListener(flowControlListener: FlowControlListener) =
      apply {
        this.flowControlListener = flowControlListener
      }

    val http2Connection =
      Http2Connection
        .Builder(client = true, taskRunner)
        .socket(socket, route.address.url.host)
        .listener(this)
        .pingIntervalMillis(pingIntervalMillis)
        .flowControlListener(flowControlListener)
        .build()
    this.http2Connection = http2Connection
    this.allocationLimit = Http2Connection.DEFAULT_SETTINGS.getMaxConcurrentStreams()

          noContextTakeover = extensions.noContextTakeover(client),
          minimumDeflateSize = minimumDeflateSize,
        )
      this.writerTask = WriterTask()
      if (pingIntervalMillis != 0L) {
        val pingIntervalNanos = MILLISECONDS.toNanos(pingIntervalMillis)
        taskQueue.schedule("$name ping", pingIntervalNanos) {
          writePingFrame()
          return@schedule pingIntervalNanos
        }
      }

          writeTimeoutMillis = client.writeTimeoutMillis,
          socketConnectTimeoutMillis = chain.connectTimeoutMillis,
          socketReadTimeoutMillis = chain.readTimeoutMillis,
          pingIntervalMillis = client.pingIntervalMillis,
          retryOnConnectionFailure = client.retryOnConnectionFailure,
          fastFallback = client.fastFallback,
          address = client.address(request.url),

      RealWebSocket(
        taskRunner = taskRunner,
        originalRequest = fancyRequest,
        listener = webSocketResponse.webSocketListener!!,
        random = SecureRandom(),
        pingIntervalMillis = 0,
        extensions = WebSocketExtensions.parse(webSocketResponse.headers),
        // Compress all messages if compression is enabled.
        minimumDeflateSize = 0L,

	public fun newBuilder ()Lokhttp3/OkHttpClient$Builder;
	public fun newCall (Lokhttp3/Request;)Lokhttp3/Call;
	public fun newWebSocket (Lokhttp3/Request;Lokhttp3/WebSocketListener;)Lokhttp3/WebSocket;
	public final fun pingIntervalMillis ()I
	public final fun protocols ()Ljava/util/List;
	public final fun proxy ()Ljava/net/Proxy;
	public final fun proxyAuthenticator ()Lokhttp3/Authenticator;
	public final fun proxySelector ()Ljava/net/ProxySelector;

	public fun newBuilder ()Lokhttp3/OkHttpClient$Builder;
	public fun newCall (Lokhttp3/Request;)Lokhttp3/Call;
	public fun newWebSocket (Lokhttp3/Request;Lokhttp3/WebSocketListener;)Lokhttp3/WebSocket;
	public final fun pingIntervalMillis ()I
	public final fun protocols ()Ljava/util/List;
	public final fun proxy ()Ljava/net/Proxy;
	public final fun proxyAuthenticator ()Lokhttp3/Authenticator;
	public final fun proxySelector ()Ljava/net/ProxySelector;