* limitations under the License.
 */
package okhttp3

import okio.ByteString

/**
 * A non-blocking interface to a web socket. Use the [factory][WebSocket.Factory] to create
 * instances; usually this is [OkHttpClient].
 *
 * ## Web Socket Lifecycle
 *
 * Upon normal operation each web socket progresses through a sequence of states:
 *

        .webSocketUpgrade(serverListener)
        .build(),
    )
    val webSocket: WebSocket = newWebSocket()
    clientListener.assertOpen()
    val server = serverListener.assertOpen()
    webSocket.send("Hello, WebSockets!")
    serverListener.assertTextMessage("Hello, WebSockets!")
    closeWebSockets(webSocket, server)
  }

  @Test
  fun binaryMessage() {
    webServer.enqueue(

    taskFaker.runTasks()
    server.webSocket!!.tearDown()
    client.webSocket!!.tearDown()
    taskFaker.close()
  }

  @Test
  fun close() {
    client.webSocket!!.close(1000, "Hello!")
    // This will trigger a close response.
    assertThat(server.processNextFrame()).isFalse()
    server.listener.assertClosing(1000, "Hello!")
    server.webSocket!!.finishReader()
    server.webSocket!!.close(1000, "Goodbye!")

          text: String,
        ) {
          webSocket.send(text)
        }

        override fun onClosing(
          webSocket: WebSocket,
          code: Int,
          reason: String,
        ) {
          webSocket.close(1000, null)
          latch.countDown()
        }

        override fun onFailure(
          webSocket: WebSocket,
          t: Throwable,
          response: Response?,

# WebSockets

Bei der Definition von WebSockets deklarieren Sie normalerweise einen Parameter vom Typ `WebSocket` und können damit Daten vom Client lesen und an ihn senden. Er wird direkt von Starlette bereitgestellt, Sie können ihn aber von `fastapi` importieren:

```python
from fastapi import WebSocket
```

!!! tip "Tipp"

{!../../../docs_src/websockets/tutorial001.py!}
```

## Einen `websocket` erstellen

Erstellen Sie in Ihrer **FastAPI**-Anwendung einen `websocket`:

```Python hl_lines="1  46-47"
{!../../../docs_src/websockets/tutorial001.py!}
```

!!! note "Technische Details"
    Sie können auch `from starlette.websockets import WebSocket` verwenden.

    webSocket: WebSocket,
    code: Int,
    reason: String,
  ) {
    Platform.get().log("[WS $name] onClosed $code", Platform.INFO, null)
    val delegate = delegate
    if (delegate != null) {
      this.delegate = null
      delegate.onClosed(webSocket, code, reason)
    } else {
      events.add(Closed(code, reason))
    }
  }

  override fun onFailure(
    webSocket: WebSocket,
    t: Throwable,

   * messages.
   */
  open fun onOpen(
    webSocket: WebSocket,
    response: Response,
  ) {
  }

  /** Invoked when a text (type `0x1`) message has been received. */
  open fun onMessage(
    webSocket: WebSocket,
    text: String,
  ) {
  }

  /** Invoked when a binary (type `0x2`) message has been received. */
  open fun onMessage(
    webSocket: WebSocket,
    bytes: ByteString,
  ) {
  }

  /**

# WebSockets

When defining WebSockets, you normally declare a parameter of type `WebSocket` and with it you can read data from the client and send data to it.

It is provided directly by Starlette, but you can import it from `fastapi`:

```python
from fastapi import WebSocket
```

!!! tip

 * Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits=15
 * Sec-WebSocket-Extensions: permessage-deflate; client_no_context_takeover
 * Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits="15"
 * Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits=15
 * Sec-WebSocket-Extensions: permessage-deflate; server_no_context_takeover
 * Sec-WebSocket-Extensions: permessage-deflate; server_no_context_takeover;