SocketPolicy.KEEP_OPEN -> KeepOpen
    SocketPolicy.DISCONNECT_AT_END -> DisconnectAtEnd
    SocketPolicy.DISCONNECT_AT_START -> DisconnectAtStart
    SocketPolicy.DISCONNECT_AFTER_REQUEST -> DisconnectAfterRequest
    SocketPolicy.DISCONNECT_DURING_REQUEST_BODY -> DisconnectDuringRequestBody
    SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY -> DisconnectDuringResponseBody

                /* If just a timeout, try to disconnect gracefully
                 */
                boolean hard = timeout == false;

                if (!timeout && log.level >= 3)
                    ex.printStackTrace( log );

                try {
                    disconnect( hard );
                } catch( IOException ioe ) {

 */
package okhttp3.mockwebserver

enum class SocketPolicy {
  SHUTDOWN_SERVER_AFTER_RESPONSE,
  KEEP_OPEN,
  DISCONNECT_AT_END,
  UPGRADE_TO_SSL_AT_END,
  DISCONNECT_AT_START,
  DISCONNECT_AFTER_REQUEST,
  DISCONNECT_DURING_REQUEST_BODY,
  DISCONNECT_DURING_RESPONSE_BODY,
  DO_NOT_READ_REQUEST_BODY,
  FAIL_HANDSHAKE,
  SHUTDOWN_INPUT_AT_END,
  SHUTDOWN_OUTPUT_AT_END,
  STALL_SOCKET_AT_START,

        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)

func (m *muxServer) checkSeq(seq uint32) (ok bool) {
	if seq != m.RecvSeq {
		if debugPrint {
			fmt.Printf("expected sequence %d, got %d\n", m.RecvSeq, seq)
		}
		m.disconnect(fmt.Sprintf("receive sequence number mismatch. want %d, got %d", m.RecvSeq, seq))
		return false
	}
	m.RecvSeq++
	return true
}

func (m *muxServer) message(msg message) {
	if debugPrint {

                case ServerMessageBlock.SMB_COM_READ_ANDX:
                case ServerMessageBlock.SMB_COM_WRITE_ANDX:
                case ServerMessageBlock.SMB_COM_CLOSE:
                case ServerMessageBlock.SMB_COM_TREE_DISCONNECT:
                    break;
                case ServerMessageBlock.SMB_COM_TRANSACTION:
                case ServerMessageBlock.SMB_COM_TRANSACTION2:

 */
public class SmbComTreeDisconnect extends ServerMessageBlock {

    /**
     * 
     * @param config
     */
    public SmbComTreeDisconnect ( Configuration config ) {
        super(config, SMB_COM_TREE_DISCONNECT);
    }


    @Override
    protected int writeParameterWordsWireFormat ( byte[] dst, int dstIndex ) {
        return 0;
    }


    @Override

    completed: bool


app = FastAPI()


@app.on_event("startup")
async def startup():
    await database.connect()


@app.on_event("shutdown")
async def shutdown():
    await database.disconnect()


@app.get("/notes/", response_model=List[Note])
async def read_notes():
    query = notes.select()
    return await database.fetch_all(query)


@app.post("/notes/", response_model=Note)

    /**
     * @param config
     */
    public Smb2TreeDisconnectRequest ( Configuration config ) {
        super(config, SMB2_TREE_DISCONNECT);
    }


    @Override
    protected Smb2TreeDisconnectResponse createResponse ( CIFSContext tc, ServerMessageBlock2Request<Smb2TreeDisconnectResponse> req ) {

        }
    }

    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 {