try {
            handshake();
        } catch (final IOException ex) {}
        return connection.getResponseMessage();
    }

    @Override
    public void disconnect() {
        connection.disconnect();
        handshakeComplete = false;
        connected = false;
    }

    @Override
    public boolean usingProxy() {
        return connection.usingProxy();
    }

        }

        // Request/response reset should happen on retry
        verify(req, atLeastOnce()).reset();
        verify(resp, atLeastOnce()).reset();
        // Verify disconnect was called on retry
        verify(c, atLeastOnce()).disconnect(eq(true));
    }

    @Test
    @DisplayName("send honors NO_RETRY and propagates error immediately")
    void send_noRetry_param() throws Exception {

        
        executor.submit(() -> {
            try {
                log.info("Attempting to recover channel {}", channel.getChannelId());
                
                // Disconnect existing transport
                channel.getTransport().disconnect();
                
                // Create new transport
                SmbTransport newTransport = manager.createTransport(
                    channel.getLocalInterface(),

        }
    }

    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 {

        try {
            // Create new transport to new address
            SmbTransport newTransport = new SmbTransport(context, newAddress, transport.getPort());
            
            // Disconnect old transport
            transport.disconnect();
            
            // Replace with new transport
            this.transport = newTransport;
            newTransport.connect();
            

            throw new IOException("Timeout waiting for RDMA send credit");
        }
    }
    
    @Override
    public void disconnect() throws IOException {
        try {
            rdmaConnection.close();
        } finally {
            bufferManager.cleanup();
            super.disconnect();
        }
    }
    
    public RdmaProvider getProvider() {
        return provider;
    }
    

    @Override
    public String getResponseMessage() throws IOException {
        handshake();
        return this.connection.getResponseMessage();
    }

    @Override
    public void disconnect() {
        this.connection.disconnect();
        this.handshakeComplete = false;
        this.connected = false;
    }

    @Override
    public boolean usingProxy() {
        return this.connection.usingProxy();
    }

        assertEquals(2, tree.connectionState);
        assertEquals(456, tree.tid);
        assertEquals("testService", tree.service);
        assertTrue(tree.inDfs);

        // Test tree disconnect
        tree.treeDisconnect(false);
        assertEquals(0, tree.connectionState);
    }

    @Test
    void testTreeConnectFailure() throws Exception {

        SmbException ex = assertThrows(SmbException.class, sut::watch, "Expected SmbException when handle invalid");
        assertTrue(ex.getMessage().contains("Watch was broken by tree disconnect"));
    }

    // Happy path for SMB2: a response is received and the list is returned; tree is closed
    @Test
    @DisplayName("watch() SMB2 happy path returns notifications and closes tree")

        Smb2TreeDisconnectRequest request = new Smb2TreeDisconnectRequest(mockConfig);

        // When
        int size = request.size();

        // Then
        // SMB2_HEADER_LENGTH + 4 bytes for tree disconnect structure
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 4;
        // size8 method aligns to 8-byte boundary
        int alignedSize = (expectedSize + 7) & ~7;
        assertEquals(alignedSize, size);
    }