private final Queue<HashMap<String, Object>> mapPool = new ConcurrentLinkedQueue<>();

    // Asynchronous logging
    private final BlockingQueue<AuditEntry> logQueue = new LinkedBlockingQueue<>(10000); // Bounded queue
    private final ExecutorService logExecutor = Executors.newSingleThreadExecutor(r -> {
        Thread t = new Thread(r, "SecurityAuditLogger");
        t.setDaemon(true);
        return t;
    });

     *
     *
     * @return timeout for SMB sessions, in milliseconds
     */
    int getSessionTimeout();

    /**
     *
     * Property {@code jcifs.smb.client.responseTimeout} (int, default 30000)
     *
     * @return timeout for SMB responses, in milliseconds
     */
    int getResponseTimeout();

    /**
     *
     * Property {@code jcifs.smb.client.lport} (int)
     *

        super.setUp();
        generator = new CommandGenerator();
    }

    // Basic setter tests
    public void test_setCommandTimeout() throws Exception {
        final long timeout = 5000L;
        generator.setCommandTimeout(timeout);
        assertTrue(true);
    }

    public void test_setCommandDestroyTimeout() throws Exception {
        final long timeout = 2000L;

    protected boolean aes256Enabled = true;
    /** Whether to use SMB2/SMB3 leases for caching */
    protected boolean useLease = true;
    /** Lease timeout in milliseconds */
    protected int leaseTimeout = 30000;
    /** Maximum number of concurrent leases */
    protected int maxLeases = 1000;
    /** Preferred lease version (1 or 2) */
    protected int leaseVersion = 2;
    /** Lease break timeout in seconds (per MS-SMB2 spec) */

 */

public class NbtSocket extends Socket {

    private static final int SSN_SRVC_PORT = 139;
    private static final int BUFFER_SIZE = 512;
    private static final int DEFAULT_SO_TIMEOUT = 5000;

    private static LogStream log = LogStream.getInstance();

    private NbtAddress address;
    private Name calledName;
    private int soTimeout;

    /**
     * Constructs an unconnected NbtSocket.

    for (int exponent : asList(2, 3, 4, 9, 15, 16, 17, 24, 25, 30)) {
      int x = 1 << exponent;
      intValues.add(x, x + 1, x - 1);
    }
    intValues.add(9999).add(10000).add(10001).add(1000000); // near powers of 10
    intValues.add(5792).add(5793); // sqrt(2^25) rounded up and down
    POSITIVE_INTEGER_CANDIDATES = intValues.build();
    NEGATIVE_INTEGER_CANDIDATES =

          println("Follow instructions at https://github.com/neykov/extract-tls-secrets for TLSv1.3")
          println("Pid: ${ProcessHandle.current().pid()}")

          Thread.sleep(10000)
        }
      }
      CommandLine -> {
        return ProcessBuilder(
          "tshark",
          "-l",
          "-V",
          "-o",
          "tls.keylog_file:$logFile",
          "-Y",

    int DEFAULT_PORT = 445;

    /** Default maximum multiplex count */
    int DEFAULT_MAX_MPX_COUNT = 10;
    /** Default response timeout in milliseconds */
    int DEFAULT_RESPONSE_TIMEOUT = 30000;
    /** Default socket timeout in milliseconds */
    int DEFAULT_SO_TIMEOUT = 35000;
    /** Default receive buffer size in bytes */
    int DEFAULT_RCV_BUF_SIZE = 60416;
    /** Default send buffer size in bytes */

        assertEquals(FileInformation.FILE_ENDOFFILE_INFO, fileInfo.getFileInformationLevel());

        // Test with parameterized constructor
        FileEndOfFileInformation info = new FileEndOfFileInformation(5000L);
        assertEquals(FileInformation.FILE_ENDOFFILE_INFO, info.getFileInformationLevel());
    }

    @Test
    @DisplayName("Test size method returns 8")
    void testSize() {

        @Test
        @DisplayName("Should handle very long messages")
        void testVeryLongMessage() {
            StringBuilder longMessage = new StringBuilder();
            for (int i = 0; i < 10000; i++) {
                longMessage.append("x");
            }
            String message = longMessage.toString();

            TransportException exception = new TransportException(message);