return delegate.hasCapability(cap);
    }

    @Override
    public boolean isDisconnected() {
        return delegate.isDisconnected();
    }

    @Override
    public boolean disconnect(boolean hard, boolean inuse) throws IOException {
        synchronized (connectionLock) {
            if (rdmaConnection != null) {
                try {
                    rdmaConnection.close();

import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Tree Disconnect response message.
 *
 * This response confirms that the tree connection
 * has been successfully disconnected.
 *
 * @author mbechler
 */
public class Smb2TreeDisconnectResponse extends ServerMessageBlock2Response {

    /**
     * Creates a new SMB2 tree disconnect response.
     *
     * @param config the CIFS configuration
     */

    }

    /**
     * Test that disconnect() calls disconnect() on the underlying connection and resets state.
     */
    @Test
    void testDisconnect() throws Exception {
        // Act
        ntlmConnection.disconnect();

        // Assert
        verify(mockConnection).disconnect();
        // Connection should be closed after disconnect
    }

    /**

            try {
                conn.disconnect(true, true);
            } catch (Exception e) {
                log.debug("Error closing connection: {}", e.getMessage());
            }
        });
        connections.clear();

        nonPooledConnections.forEach(conn -> {
            try {
                conn.disconnect(true, true);
            } catch (Exception e) {

        }
        ftpAuthenticationHolder = null;
        for (final FTPClient ftpClient : ftpClientQueue) {
            try {
                ftpClient.disconnect();
            } catch (final IOException e) {
                logger.debug("Failed to disconnect FTPClient.", e);
            }
        }
    }

    /*
     * (non-Javadoc)
     *

                     */
                    try {
                        log.warn("Exception during SSP authentication", se);
                        trans.disconnect(true);
                    } catch (IOException ioe) {
                        log.debug("Disconnect failed");
                    }
                    setUid(0);
                    throw se;
                }

                if (token != null) {

    }

    private void attemptRecovery(ChannelInfo channel, FailoverState state) {
        try {
            log.info("Attempting to recover channel {}", channel.getChannelId());

            // Disconnect existing transport
            SmbTransport oldTransport = channel.getTransport();
            if (oldTransport != null) {
                try {
                    oldTransport.close();

                                 * sent. Unfortunately calling disconnect() doesn't always
                                 * actually shutdown the connection before other threads
                                 * have committed themselves (e.g. InterruptTest example).
                                 */
                                try {
                                    transport.disconnect(true);

 * It releases the tree ID and terminates access to the share.
 */
public class SmbComTreeDisconnect extends ServerMessageBlock {

    /**
     * Constructs a tree disconnect request to close a connection to a shared resource.
     *
     * @param config the configuration to use
     */
    public SmbComTreeDisconnect(final Configuration config) {
        super(config, SMB_COM_TREE_DISCONNECT);

        }

        // 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 {