*/
package okhttp3.slack;

import java.io.Closeable;
import java.io.IOException;
import okhttp3.WebSocket;
import okhttp3.Response;
import okhttp3.WebSocketListener;

/** A realtime messaging session. */
public final class RtmSession extends WebSocketListener implements Closeable {
  private final SlackApi slackApi;

  /** Guarded by this. */
  private WebSocket webSocket;

  public RtmSession(SlackApi slackApi) {

    settings = mockResponse.settings
    mockResponse =
      mockResponse.withWebSocketUpgrade(
        object : WebSocketListener() {
        },
      )
    var webSocketListener: WebSocketListener? = mockResponse.webSocketListener
    webSocketListener = mockResponse.webSocketListener
  }

  @Test
  fun mockWebServer() {
    val mockWebServer: MockWebServer = MockWebServer()

	public final fun getThrottleBytesPerPeriod ()J
	public final fun getThrottlePeriod (Ljava/util/concurrent/TimeUnit;)J
	public final fun getTrailers ()Lokhttp3/Headers;
	public final fun getWebSocketListener ()Lokhttp3/WebSocketListener;
	public final fun headers (Lokhttp3/Headers;)V
	public final fun http2ErrorCode (I)V
	public final fun removeHeader (Ljava/lang/String;)Lokhttp3/mockwebserver/MockResponse;

      delegate.shutdown()
    }
  }
}

internal fun MockResponse.wrap(): mockwebserver3.MockResponse {
  val result = mockwebserver3.MockResponse.Builder()
  val copyFromWebSocketListener = webSocketListener
  if (copyFromWebSocketListener != null) {
    result.webSocketUpgrade(copyFromWebSocketListener)
  }

  val body = getBody()
  if (body != null) result.body(body)

  for (pushPromise in pushPromises) {

	public final fun getThrottlePeriodNanos ()J
	public final fun getTrailers ()Lokhttp3/Headers;
	public final fun getTrailersDelayNanos ()J
	public final fun getWebSocketListener ()Lokhttp3/WebSocketListener;
	public final fun newBuilder ()Lmockwebserver3/MockResponse$Builder;
	public fun toString ()Ljava/lang/String;
}

public final class mockwebserver3/MockResponse$Builder : java/lang/Cloneable {
	public fun <init> ()V

      | * Response.cacheResponse
      | * Response.networkResponse
      | * Response.priorResponse
      | * EventSourceListener
      | * WebSocketListener
      |(It is safe to call contentType() and contentLength() on these response bodies.)
      """.trimMargin(),
    )

  override fun timeout() = Timeout.NONE

  override fun close() {
  }
}

     * notified. The caller must either close or cancel the returned web socket when it is no longer
     * in use.
     */
    fun newWebSocket(
      request: Request,
      listener: WebSocketListener,
    ): WebSocket
  }

import okhttp3.Call
import okhttp3.Callback
import okhttp3.EventListener
import okhttp3.OkHttpClient
import okhttp3.Protocol
import okhttp3.Request
import okhttp3.Response
import okhttp3.WebSocket
import okhttp3.WebSocketListener
import okhttp3.internal.closeQuietly
import okhttp3.internal.concurrent.Lockable
import okhttp3.internal.concurrent.Task
import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.concurrent.assertLockHeld

  override fun newCall(request: Request): Call = RealCall(this, request, forWebSocket = false)

  /** Uses [request] to connect a new web socket. */
  override fun newWebSocket(
    request: Request,
    listener: WebSocketListener,
  ): WebSocket {
    val webSocket =
      RealWebSocket(
        taskRunner = taskRunner,
        originalRequest = request,
        listener = listener,
        random = Random(),

          requestWantsSocket &&
            "websocket".equals(request.headers["Upgrade"], ignoreCase = true)
        val responseWantsSocket = response.socketHandler != null
        val responseWantsWebSocket = response.webSocketListener != null
        if (requestWantsWebSocket && responseWantsWebSocket) {
          handleWebSocketUpgrade(socket, request, response)
          reuseSocket = false