// CAP_LARGE_WRITE
        if (th.hasCapability(SmbConstants.CAP_LARGE_WRITEX) && !th.areSignaturesActive()) {
            this.writeSizeFile = Math.min(th.getConfig().getSendBufferSize() - 70, 0xFFFF - 70);
        } else {
            log.debug("No support or SMB signing is enabled, not enabling large writes");
            this.writeSizeFile = this.writeSize;
        }

        if (log.isDebugEnabled()) {

            bb.putShort((short) 0xFFFE); // Max even pathConsumed
            bb.putShort((short) 0); // numReferrals
            bb.putShort((short) 0xFFFF); // Max tflags
            bb.putShort((short) 0); // tflags high bytes

            buffer.decode(testBuffer, 0, testBuffer.length);

            assertEquals(32767, buffer.getPathConsumed()); // 65534 / 2

      return
    }

    if (length % 6 != 0) throw IOException("TYPE_SETTINGS length % 6 != 0: $length")
    val settings = Settings()
    for (i in 0 until length step 6) {
      val id = source.readShort() and 0xffff
      val value = source.readInt()

      when (id) {
        // SETTINGS_HEADER_TABLE_SIZE
        1 -> {
        }

        // SETTINGS_ENABLE_PUSH
        2 -> {

        // Set security buffer length to excessive size (> 64KB)
        SMBUtil.writeInt2(128, buffer, 56); // Security buffer offset
        // writeInt2(100000) will truncate to 100000 & 0xFFFF = 34464
        SMBUtil.writeInt2(100000, buffer, 58); // This becomes 34464 due to 16-bit truncation

        // Since 34464 is within the 16-bit range but could still be considered excessive for security buffer,

                }
            }
            resolveOrder = new int[i];
            System.arraycopy(tmp, 0, resolveOrder, 0, i);
        }
    }

    int getNextNameTrnId() {
        if ((++nextNameTrnId & 0xFFFF) == 0) {
            nextNameTrnId = 1;
        }
        return nextNameTrnId;
    }

    void ensureOpen(final int timeout) throws IOException {
        closeTimeout = 0;
        if (SO_TIMEOUT != 0) {

    }

    @Test
    @DisplayName("Test createCancel with maximum MID value")
    void testCreateCancelWithMaxMid() {
        // Set MID to maximum value
        int maxMid = 0xFFFF;
        transaction.setMid(maxMid);

        // Create cancel request
        CommonServerMessageBlockRequest cancelRequest = transaction.createCancel();

    private int pad2 = 0;
    private boolean hasMore = true;
    private boolean isPrimary = true;
    private int bufParameterOffset;
    private int bufDataOffset;

    static final int TRANSACTION_BUF_SIZE = 0xFFFF;

    /**
     * SMB TRANS2 subcommand for finding first matching files
     */
    public static final byte TRANS2_FIND_FIRST2 = (byte) 0x01;
    /**
     * SMB TRANS2 subcommand for finding next matching files

    }

    @Test
    @DisplayName("Test close flags with different values")
    void testCloseFlagsWithDifferentValues() {
        // Test with different flag values
        int[] testFlagValues = { 0x0000, 0x0001, 0xFFFF };

        for (int flagValue : testFlagValues) {
            request.setCloseFlags(flagValue);

            byte[] buffer = new byte[256];
            request.writeBytesWireFormat(buffer, 0);

    /**
     * Count of data bytes in the SMB message.
     */
    protected int byteCount;
    /**
     * Tree identifier for the connected share.
     */
    protected int tid = 0xFFFF;
    private boolean useUnicode, forceUnicode, extendedSecurity;
    private volatile boolean received;
    private int signSeq;
    private boolean verifyFailed;
    /**

    /** Maximum buffer size for IO operations */
    protected int maximumBufferSize = 0x10000;
    /** Maximum buffer size for SMB transaction operations */
    protected int transactionBufferSize = 0xFFFF - 512;
    /** Number of buffers to keep in cache */
    protected int bufferCacheSize = 16;
    /** Maximum size for list operations */
    protected int smbListSize = 65435;