}

    // Error case: disconnect throws IOException
    @Test
    @DisplayName("disconnect throws IOException when underlying close fails")
    void disconnect_throwsIOException() throws Exception {
        doThrow(new java.io.IOException("close error")).when(transport).disconnect(true, true);
        java.io.IOException ex = assertThrows(java.io.IOException.class, () -> transport.disconnect(true, true));

                thread = null;
            }
        }
    }

    /**
     * Disconnects from the remote endpoint.
     *
     * @param hard if true, disconnect immediately without waiting for outstanding requests
     * @throws IOException if an I/O error occurs during disconnection
     */
    public synchronized void disconnect(boolean hard) throws IOException {
        IOException ioe = null;

        switch (state) {

            // Disconnect and try again from scratch.

            if (log.isDebugEnabled()) {
                log.debug(String.format("Retrying (%d/%d) request %s", retries, maxRetries, request));
            }

            // should we disconnect the transport here? otherwise we make an additional attempt to detect that if the

        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");

        }
    }

    /**
     * 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);
    }

    /**

                     * Someone removed the share while we were
                     * connected. Bastards! Disconnect this tree
                     * so that it reconnects cleanly should the share
                     * reappear in this client's lifetime.
                     */
                    log.debug("Disconnect tree on NT_STATUS_NETWORK_NAME_DELETED");
                    treeDisconnect(true, true);
                }

        return responseData;
    }

    /**
     * Disconnects the internal FTP client and logs any errors.
     * This method is used to clean up failed connections.
     *
     * @param client The FTP client to disconnect
     */
    protected void disconnectInternalClient(final FTPClient client) {
        try {
            client.disconnect();
        } catch (final IOException e) {

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

    }

    /**
     * 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
    }

    /**

	}
	if debugPrint {
		fmt.Println("Connecting Mux", m.MuxID, ",to", m.parent.Remote)
	}

	// Space for one message and an error.
	responseCh := make(chan Response, 1)

	// Spawn simple disconnect
	if requests == nil {
		go m.handleOneWayStream(responseCh, responses)
		return &Stream{responses: responseCh, Requests: nil, ctx: m.ctx, cancel: m.cancelFn, muxID: m.MuxID}, nil
	}