h.acquire();

        // First release: should not close yet
        h.release();
        verify(tree, never()).send(isA(Smb2CloseRequest.class), any());
        verify(tree, never()).send(any(CommonServerMessageBlockRequest.class), any(SmbComBlankResponse.class), any(RequestParam[].class));

        // Second release: should close now via SMB2 path
        h.release();

    @Test
    @DisplayName("close calls release and decrements usage; double release throws")
    void closeAndReleaseBehavior() {
        // Validates usage counting and that an extra release() throws RuntimeCIFSException
        // First close -> usage 1 -> 0, triggers treeConnection.release()
        handle.close();
        verify(treeConnection, times(1)).release();

        // Second release -> usage 0 -> -1 triggers RuntimeCIFSException

    }

    @Test
    @DisplayName("close/release manage usage and transport lifecycle")
    void testReleaseLifecycle() {
        SmbSessionImpl session = newSession();

        // First release drops usage to zero and releases transport
        session.release();
        verify(transport, times(1)).release();
        assertFalse(session.isInUse());

        // Next release goes below zero and throws

        assertEquals("first", it.next().getName());
        assertFalse(it.hasNext()); // After exhaustion, hasNext should return false

        // Assert
        verify(tree, times(1)).release(); // release called in finally exactly once
    }

    @Test
    @DisplayName("remove() throws UnsupportedOperationException with 'remove' message")
    void removeUnsupported() throws Exception {
        // Arrange

        // When - Multiple threads try to release/acquire concurrently
        for (int t = 0; t < threadCount; t++) {
            final boolean shouldRelease = (t < 3); // First 3 threads release, others acquire

            executor.submit(() -> {
                try {
                    startLatch.await();

                    if (shouldRelease) {
                        session.release();

        verify(tree, times(1)).acquire();

        // Act: first release does not release yet (usage -> 1)
        c.release();
        verify(tree, never()).release();

        // Act: second release (usage -> 0) releases the tree
        c.release();
        verify(tree, times(1)).release();
    }

    @Test
    @DisplayName("release below zero throws RuntimeCIFSException")
    void release_belowZero_throws() {

     */
    @Override
    public void close() {
        release(false);
    }

    public void release() {
        release(true);
    }

    /**
     * @param track
     */
    public void release(final boolean track) {
        final long usage = this.usageCount.decrementAndGet();
        if (log.isTraceEnabled()) {
            log.trace("Release tree " + usage + " " + this);
        }

    public synchronized void close() {
        release();
    }

    /**
     * @return tree handle with increased usage count
     */
    public SmbTreeHandleImpl acquire() {
        if (this.usageCount.incrementAndGet() == 1) {
            this.treeConnection.acquire();
        }
        return this;
    }

    @Override
    public void release() {

            this.tree = t;
            if ((old != null) && wasAcquired) {
                // release
                old.release(true);
            }
            if (this.delegate != null && this.delegateAcquired) {
                log.debug("Releasing delegate");
                this.delegateAcquired = false;
                this.delegate.release();
            }
        }
    }

    /**

        verify(tree, times(1)).send(captor.capture(), any());
        assertNotNull(captor.getValue());

        // Tree handle is released after close
        verify(tree, atLeastOnce()).release();
    }

    @Test
    @DisplayName("open(): server returns NO_SUCH_FILE after receiving response -> iterator empty, closed")
    void openHandlesNoSuchFileGracefully() throws Exception {