void testTreeConnectAndDisconnect() throws Exception {
        SmbTree tree = new SmbTree(session, "testShare", "testService");

        // Mock transport.connect() to succeed
        doNothing().when(transport).connect();

        // Setup response for tree connect
        doAnswer(invocation -> {
            ServerMessageBlock request = invocation.getArgument(0);
            ServerMessageBlock response = invocation.getArgument(1);

    }

    /**
     * Test for isConnected() method.
     * Verifies that the method returns the correct connected status.
     */
    @Test
    void testIsConnected() {
        when(smbTreeHandle.isConnected()).thenReturn(true);
        assertTrue(smbTreeHandle.isConnected(), "isConnected() should return true");
        when(smbTreeHandle.isConnected()).thenReturn(false);

        }

        // Wait for an in-flight connect to complete or fail.
        if (connectResult == null) {
          connectResult = awaitTcpConnect(awaitTimeoutNanos, TimeUnit.NANOSECONDS) ?: continue
        }

        if (connectResult.isSuccess) {
          // We have a connected TCP connection. Cancel and defer the racing connects that all lost.
          cancelInFlightConnects()

  # By default, Dex will ask for approval to share data with application
  # (approval for sharing data from connected IdP to Dex is separate process on IdP)
  skipApprovalScreen: false
  # If only one authentication method is enabled, the default behavior is to
  # go directly to it. For connected IdPs, this redirects the browser away
  # from application to upstream provider such as the Google login page

            socketChannel.close();
        }
        connect();
    }

    @Override
    public int read(ByteBuffer buffer, long remoteAddress, int remoteKey, int length) throws IOException {
        if (state != RdmaConnectionState.ESTABLISHED && state != RdmaConnectionState.CONNECTED) {
            throw new IOException("Connection not established");
        }

        try {

    Configuration cfg;

    @Mock
    SmbTreeHandleImpl tree;

    private void stubValidTree(long treeId, boolean connected, boolean smb2) {
        lenient().when(tree.acquire()).thenReturn(tree);
        lenient().when(tree.getTreeId()).thenReturn(treeId);
        lenient().when(tree.isConnected()).thenReturn(connected);
        lenient().when(tree.isSMB2()).thenReturn(smb2);
    }

    @Test

    assertTrue(Range.closed(3, 5).isConnected(Range.open(5, 6)));
    assertTrue(Range.closed(3, 5).isConnected(Range.closed(5, 6)));
    assertTrue(Range.closed(5, 6).isConnected(Range.closed(3, 5)));
    assertTrue(Range.closed(3, 5).isConnected(Range.openClosed(5, 5)));
    assertTrue(Range.open(3, 5).isConnected(Range.closed(5, 6)));
    assertTrue(Range.closed(3, 7).isConnected(Range.open(6, 8)));

            if (n <= 0) {
                break;
            }
            i += n;
        }

        return i;
    }

    /*
     * state values
     * 0 - not connected
     * 1 - connecting
     * 2 - run connected
     * 3 - connected
     * 4 - error
     * 5 - disconnecting
     * 6 - disconnected/invalid
     */
    /**
     * Current state of the transport connection
     */

internal class ReusePlan(
  val connection: RealConnection,
) : RoutePlanner.Plan {
  override val isReady = true

  override fun connectTcp() = error("already connected")

  override fun connectTlsEtc() = error("already connected")

  override fun handleSuccess() = connection

  override fun cancel() = error("unexpected cancel")

  override fun retry() = error("unexpected retry")

    /**
     * Checks if the client is connected to OpenSearch.
     *
     * @return true if connected, false otherwise.
     */
    public boolean connected() {
        return connected;
    }

    /**
     * Connects to the OpenSearch cluster.
     * Creates a new client and waits for cluster health to be yellow or better.
     */
    public void connect() {
        destroy();