return (h && !u) || (!h && u);
        });

        boolean result = transport.disconnect(hard, inuse);

        assertEquals(expected, result);
        verify(transport, times(1)).disconnect(hard, inuse);
    }

    // Error case: disconnect throws IOException
    @Test
    @DisplayName("disconnect throws IOException when underlying close fails")
    void disconnect_throwsIOException() throws Exception {

        }
    }

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

    /**

import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Tree Disconnect request message.
 *
 * This command is used to disconnect from a previously
 * connected tree (shared resource).
 *
 * @author mbechler
 */
public class Smb2TreeDisconnectRequest extends ServerMessageBlock2Request<Smb2TreeDisconnectResponse> {

    /**
     * Creates a new SMB2 tree disconnect request to close a tree connection.
     *

        @Test
        @DisplayName("disconnect should succeed when connected")
        void shouldDisconnectWhenConnected() throws IOException {
            transport.setState(3); // Connected
            assertFalse(transport.disconnect(false));
            assertEquals(6, transport.state); // Should be disconnected
        }

        @Test
        @DisplayName("disconnect should force hard disconnect from run connected 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");

        }
    }

    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 {

		return pongMsg{Err: &err}
	default:
		atomic.StoreInt64(&m.LastPing, time.Now().Unix())
		return pongMsg{}
	}
}

// disconnect will disconnect the mux.
// m.recvMu must be locked when calling this function.
func (m *muxServer) disconnect(msg string, locked bool) {
	if debugPrint {
		fmt.Println("Mux", m.ID, "disconnecting. Reason:", msg)
	}
	if msg != "" {

    }

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

    /**

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