}

    // Edge: disconnected status toggles
    @ParameterizedTest
    @DisplayName("isDisconnected reflects current mocked state")
    @ValueSource(booleans = { true, false })
    void isDisconnected_states(boolean disconnected) {
        when(transport.isDisconnected()).thenReturn(disconnected);
        assertEquals(disconnected, transport.isDisconnected());
        verify(transport, times(1)).isDisconnected();

        }
    }

    /**
     * Disconnect the transport
     *
     * @param hard if true, disconnect immediately without waiting for outstanding requests
     * @return whether connection was in use
     * @throws IOException if an I/O error occurs during disconnection
     */
    public synchronized boolean disconnect(final boolean hard) throws IOException {
        return disconnect(hard, true);
    }

    /**

    @DisplayName("available() on SMB1 returns 0 and marks closed on disconnected statuses")
    void available_smb1_disconnectedStatuses(int status) throws Exception {
        // Verify SMB1 path: disconnected/server-closed statuses yield 0 and mark fd closed
        SmbPipeInputStream stream = newStreamWithInit(false);

                    if ((inUse ? l != 1 : l > 0)) {
                        log.warn("Disconnected tree while still in use " + this);
                        dumpResource();
                        wasInUse = true;
                        if (sess.getConfig().isTraceResourceUsage()) {
                            throw new RuntimeCIFSException("Disconnected tree while still in use");
                        }
                    }

        try (SmbSessionImpl session = getSession()) {
            if (isConnected()) {
                try (SmbTransportImpl transport = session.getTransport()) {
                    if (transport.isDisconnected() || transport.getRemoteHostName() == null) {
                        /*
                         * Tree/session thinks it is connected but transport disconnected
                         * under it, reset tree to reflect the truth.

        when(mockTransport.isDisconnected()).thenReturn(true);
        when(mockTransport.toString()).thenReturn("MockTransport");

        try (RdmaTransport transport = new RdmaTransport(mockTransport, testContext)) {
            assertNotNull(transport, "Transport should not be null");
            assertTrue(transport.isDisconnected(), "Transport should be disconnected initially");

        nonPooledConnections.offer(nonPooledSpy);

        // Mock disconnect behavior
        when(pooledSpy.disconnect(false, false)).thenReturn(true); // In use
        when(nonPooledSpy.disconnect(false, false)).thenReturn(false); // Not in use

        // When: Close the pool
        boolean inUse = pool.close();

        // Then: Should report in-use and call disconnect on all
        assertTrue(inUse, "Should report connections in use");

        assertThrows(SmbException.class, () -> tree.treeConnect(null, null));
        // After failure, state should be reset to disconnected
        assertEquals(0, tree.connectionState);
    }

    @Test
    void testSend() throws SmbException {
        SmbTree tree = new SmbTree(session, "testShare", "A:");

            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;
    }
    

        this.channelId = channelId;
        this.transport = transport;
        this.localInterface = localInterface;
        this.remoteInterface = remoteInterface;
        this.state = ChannelState.DISCONNECTED;
        this.establishedTime = System.currentTimeMillis();
        this.lastActivityTime = establishedTime;

        this.bytesSent = new AtomicLong();
        this.bytesReceived = new AtomicLong();