self.active_connections: list[WebSocket] = []

    async def connect(self, websocket: WebSocket):
        await websocket.accept()
        self.active_connections.append(websocket)

    def disconnect(self, websocket: WebSocket):
        self.active_connections.remove(websocket)

    async def send_personal_message(self, message: str, websocket: WebSocket):
        await websocket.send_text(message)

        }
    }

    class MockHttpURLConnection extends HttpURLConnection {

        MockHttpURLConnection(URL u) {
            super(u);
        }

        @Override
        public void disconnect() {
            // Do Nothing
        }

        @Override
        public boolean usingProxy() {
            return false;
        }

        @Override
        public void connect() throws IOException {

    async def receive():  # type: ignore[no-untyped-def]
        # Simulate a client that never disconnects, rely on cancellation
        await anyio.sleep(float("inf"))
        return {"type": "http.disconnect"}  # pragma: no cover

    async def send(message: dict) -> None:  # type: ignore[type-arg]
        if message["type"] == "http.response.body":
            chunks.append(message.get("body", b""))

    scope = {

{* ../../docs_src/custom_docs_ui/tutorial002_py310.py hl[39:41] *}

### Test Static Files UI { #test-static-files-ui }

Now, you should be able to disconnect your WiFi, go to your docs at [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs), and reload the page.

                exceptionListener.accept(new CurlException("Failed to access to " + finalUrl, e));
            } finally {
                if (connection != null) {
                    connection.disconnect();
                }
            }
        };
        if (threadPool != null) {
            threadPool.execute(task);
        } else {
            task.run();
        }
    }

    /**

          suppressTlsFallbackClientSocketFactory(),
          handshakeCertificates.trustManager,
        ).build()
    assertContent("abc", getResponse(newRequest("/")))

    // Give the server time to disconnect.
    Thread.sleep(500)
    assertContent("def", getResponse(newRequest("/")))
    val tlsVersions: Set<TlsVersion?> =
      EnumSet.of(
        TlsVersion.TLS_1_0,
        TlsVersion.TLS_1_2,

  }

  @Test
  fun responseBodyFailHttp() {
    responseBodyFail(Protocol.HTTP_1_1)
  }

  private fun responseBodyFail(expectedProtocol: Protocol?) {
    // Use a 2 MiB body so the disconnect won't happen until the client has read some data.
    val responseBodySize = 2 * 1024 * 1024 // 2 MiB
    server.enqueue(
      MockResponse
        .Builder()

  }

  @Test
  fun serverDisconnectsPrematurelyWithNoLengthHeaders() {
    // Intentionally empty. This case doesn't make sense because there's no
    // such thing as a premature disconnect when the disconnect itself
    // indicates the end of the data stream.
  }

  private fun testServerPrematureDisconnect(transferKind: TransferKind) {
    val mockResponse = MockResponse.Builder()

    cookieJar.assertResponseCookies("a=b; path=/")
  }

  @Test
  fun cancelWithStreamNotCompleted() {
    server.enqueue(MockResponse(body = "abc"))
    server.enqueue(MockResponse(body = "def"))

    // Disconnect before the stream is created. A connection is still established!
    val call1 = client.newCall(Request(server.url("/")))
    val response = call1.execute()
    call1.cancel()