* @return tree connection with increased usage count
     */
    public SmbTreeConnection acquire() {
        final long usage = this.usageCount.incrementAndGet();
        if (log.isTraceEnabled()) {
            log.trace("Acquire tree connection " + usage + " " + this);
        }

        if (usage == 1) {
            synchronized (this) {
                try (SmbTreeImpl t = getTree()) {

    }

    /**
     * Constructs a new CrawlerSystemException with the specified detail message and controls suppression and stack trace writing.
     *
     * @param message the detail message
     * @param enableSuppression whether or not suppression is enabled
     * @param writableStackTrace whether or not the stack trace should be writable
     */

        assertSame(root, ex.getRootCause());
    }

    /**
     * Verify that {@link #toString()} includes a stack trace when a root cause
     * is present.
     */
    @Test
    @DisplayName("toString with root cause contains stack trace")
    void testToStringWithRootCause() {
        RuntimeException cause = new RuntimeException("boom");
        SmbException ex = new SmbException(0, cause);

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import jcifs.CIFSContext;
import jcifs.Configuration;
import jcifs.Credentials;

/**
 * Security-focused test cases for SmbSessionImpl to verify race condition fixes.
 */
public class SmbSessionImplSecurityTest {

    private CIFSContext mockContext;
    private SmbTransportImpl mockTransport;
    private Configuration mockConfig;

        return actionClass;
    }

    /**
     * Overrides fillInStackTrace to return null for performance optimization.
     * This prevents stack trace generation for this exception type.
     *
     * @return null to skip stack trace generation
     */
    @Override
    public synchronized Throwable fillInStackTrace() {
        return null;
    }

            writer.accept("Thread: " + entry.getKey());
            final StackTraceElement[] trace = entry.getValue();
            for (final StackTraceElement element : trace) {
                writer.accept("\tat " + element);
            }
        }
    }

            assertTrue(result.contains(message));
            assertFalse(result.contains("\n"));
        }

        @Test
        @DisplayName("Should include stack trace when root cause exists")
        void testToStringWithRootCause() {
            String message = "Transport error";
            String rootMessage = "Root cause error";

        dstIndex += 2;
        if (this.digest != null) {
            SMB1SigningDigest.writeUTime(getConfig(), this.lastWriteTime, dst, dstIndex);
        } else {
            log.trace("SmbComClose without a digest");
        }
        return 6;
    }

    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override

    public String getUserId() {
        return username;
    }

    /**
     * Returns a string representation of this credential.
     *
     * @return A string representation containing the username in braces
     */
    @Override
    public String toString() {
        return "{" + username + "}";
    }

     *
     * @param message the detail message describing the exception
     * @param enableSuppression whether suppression is enabled or disabled
     * @param writableStackTrace whether the stack trace should be writable
     */
    protected FessSystemException(final String message, final boolean enableSuppression, final boolean writableStackTrace) {
        super(message, null, enableSuppression, writableStackTrace);
    }