assertTrue(session.isInUse(), "New session should be in use due to transport acquisition");

        // Test additional acquire
        session.acquire();
        assertTrue(session.isInUse(), "Session should still be in use after additional acquire");

        // Test release (still in use because of initial transport acquire)
        session.release();

        // Act: create wrapper using delegate, then acquire and release once
        SmbTreeConnectionTrace wrapper = new SmbTreeConnectionTrace(delegate);
        wrapper.acquire();
        wrapper.release();

        // Assert: delegate interactions occur when usage transitions happen
        verify(delegate, times(1)).acquire();
        verify(delegate, times(1)).release();
    }

    @Test

     *
     * @param tf the CIFS context to use
     * @param name the server name or address
     * @param port the port number
     * @param exclusive whether to acquire an unshared connection
     * @param forceSigning whether to enforce SMB signing
     * @return a connected transport
     * @throws UnknownHostException if the host cannot be resolved

        }
    }

    /**
     * @return a file handle with increased usage count
     */
    public SmbFileHandleImpl acquire() {
        final long usage = this.usageCount.incrementAndGet();
        if (log.isTraceEnabled()) {
            log.trace(String.format("Acquire %s (%d)", this, usage));
        }
        return this;
    }

    /**
     *
     */
    public void markClosed() {

                }
            }
            tree.unwrap(CustomSmbTree.class);
        });
    }

    // Test case for acquire and release methods
    @Test
    void testAcquireAndRelease() {
        SmbTreeImpl tree = new SmbTreeImpl(session, "SHARE", "A:");
        tree.acquire();
        tree.release();
    }

    // Test case for isConnected method
    @Test

    @Nested
    @DisplayName("Resource management tests")
    class ResourceManagementTests {

        @Test
        @DisplayName("acquire should increment usage count")
        void shouldIncrementUsageCount() {
            long initial = transport.getUsageCount();
            transport.acquire();
            assertEquals(initial + 1, transport.getUsageCount());
        }

        @Test

        } else {
            throw new SmbException("The requested list operations is invalid: " + locator.getURL());
        }
        this.response = new NetServerEnum2Response(th.getConfig());

        this.treeHandle = th.acquire();
        try {
            this.next = open();
        } catch (final Exception e) {
            this.treeHandle.release();
            throw e;
        }

    }

        this.parent = parent;
        this.wildcard = wildcard;
        this.nameFilter = filter;
        this.searchAttributes = searchAttributes;

        this.treeHandle = th.acquire();
        try {
            this.next = open();
            if (this.next == null) {
                doClose();
            }
        } catch (final Exception e) {
            doClose();
            throw e;

/**
 * Abstract base class for admin API actions in Fess.
 * This class extends FessApiAction to provide admin-specific functionality
 * including enhanced access control for administrative operations.
 *
 * <p>Admin API actions require special permissions and access tokens
 * that are validated against the admin role configuration.</p>
 */
public abstract class FessApiAdminAction extends FessApiAction {

    /** Logger instance for this class. */

     * Create an authenticator using the JAAS service <code>jcifs</code>
     *
     * This will require that a keytab is configured in this service.
     *
     *
     */
    public JAASAuthenticator() {
        this("jcifs");
    }

    /**
     * Create an authenticator using the given JAAS service
     *
     * This will require that a keytab is configured in this service.
     *
     * @param serviceName