frameLength = (b1 and B1_MASK_LENGTH).toLong()
    if (frameLength == PAYLOAD_SHORT.toLong()) {
      frameLength = (source.readShort() and 0xffff).toLong() // Value is unsigned.
    } else if (frameLength == PAYLOAD_LONG.toLong()) {
      frameLength = source.readLong()
      if (frameLength < 0L) {
        throw ProtocolException(

            // Given
            byte[] buffer = new byte[60];
            SMBUtil.writeInt2(60, buffer, 0);
            SMBUtil.writeInt2(0xFFFF, buffer, 2); // Max flags
            SMBUtil.writeInt4(0xFFFFFFFF, buffer, 4); // Max reserved (ignored)
            SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 8); // Max times

        String str = info.toString();
        assertTrue(str.contains(specialName));
        assertTrue(str.contains(specialRemark));
    }

    @Test
    @DisplayName("Test type masking with 0xFFFF")
    void testTypeMasking() {
        // Test that only lower 16 bits are considered for type determination
        int typeWithUpperBits = 0xFFFF0001; // Should be treated as type 1 (printer)

     * according to the XML 1.0 specification. Valid characters include:
     * - Tab (0x9)
     * - Line feed (0xA)
     * - Carriage return (0xD)
     * - Any character between 0x20 and 0xD7FF
     * - Any character between 0xE000 and 0xFFFD
     * - Any character between 0x10000 and 0x10FFFF
     *
     * @param in the input string to be processed
     * @return a new string with invalid XML characters removed, or the original

     */
    public void enc_ndr_small(final int s) {
        buf[index] = (byte) (s & 0xFF);
        advance(1);
    }

    /**
     * Decodes a small integer (1 byte) from NDR format.
     *
     * @return the decoded small integer value
     */
    public int dec_ndr_small() {
        final int val = buf[index] & 0xFF;
        advance(1);
        return val;
    }

    /**

	SUBS	$0xffff0, R6, RSP                                // ERROR "illegal destination register"
	SUBS	$0x1000100010001000, R6, RSP                     // ERROR "illegal destination register"
	SUBS	$0x10001000100011, R6, RSP                       // ERROR "illegal destination register"
	SUBSW	$0xff, R6, RSP                                   // ERROR "illegal destination register"

            jcifs.internal.smb1.com.SmbComReadAndX req = cap.getValue();
            assertEquals(0x12345 & 0xFFFF, req.getMaxCount(), "maxCount should contain lower 16 bits");
            assertEquals(0x12345, req.getMinCount(), "minCount should remain original full value");
        }

        @Test

   */
  internal const val PAYLOAD_SHORT = 126

  /** Maximum length of a frame payload to be denoted as [PAYLOAD_SHORT]. */
  internal const val PAYLOAD_SHORT_MAX = 0xffffL

  /**
   * Value for [B1_MASK_LENGTH] which indicates the next eight bytes are the unsigned
   * length.
   */
  internal const val PAYLOAD_LONG = 127

            assertEquals(newFilename, actualFilename);
        }
    }

    @Test
    void testLargeBatchParameters() {
        // Test with maximum allowed values
        int maxSid = 0xFFFF;
        int maxResumeKey = 0x7FFFFFFF;
        int maxBatchCount = 65535;
        int maxBatchSize = 65535;

     * @return the unsigned short value as an integer
     * @throws IOException if an I/O error occurs
     */
    public int readUnsignedShort() throws IOException {
        return readShort() & 0xffff;
    }

    /**
     * Reads a Windows FILETIME value and converts it to a Date.
     * @return the Date object, or null if the time represents infinity
     * @throws IOException if an I/O error occurs
     */