assertTrue(n > 0);
        // Common AndX header: command at +1, reserved at +2, offset at +3/+4
        assertEquals((byte) 0xFF, buf[1], "AndX command should be 0xFF when no chaining");
        assertEquals((byte) 0x00, buf[2], "Reserved byte must be 0");
        assertEquals((byte) 0xDE, buf[3], "Sentinel low offset when no chaining");
        assertEquals((byte) 0xDE, buf[4], "Sentinel high offset when no chaining");

            /* 01234567
             * 00SSFSMB
             * 0 - 0's
             * S - size of payload
             * FSMB - 0xFF SMB magic #
             */

            if (sbuf[0] == (byte) 0x00 && sbuf[1] == (byte) 0x00 && sbuf[4] == (byte) 0xFF && sbuf[5] == (byte) 'S' && sbuf[6] == (byte) 'M'
                    && sbuf[7] == (byte) 'B') {
                break; /* all good */
            }
            /* out of phase maybe? */

            // Test with various wildcard patterns and attribute masks
            String[] wildcards = { "*.txt", "test*", null };
            int[] attributes = { 0x10, 0x20, 0x07 };

            for (int i = 0; i < wildcards.length; i++) {
                DosFileFilter dos = new DosFileFilter(wildcards[i], attributes[i]);

        assertArrayEquals(maxFileId, copiedFileId);

        // Test with file ID having minimum byte values
        byte[] minFileId = new byte[16];
        Arrays.fill(minFileId, (byte) 0x00);
        Smb2FlushRequest minRequest = new Smb2FlushRequest(mockConfig, minFileId);

        written = minRequest.writeBytesWireFormat(buffer, 0);

        assertEquals(24, written);

        int testCapabilities = 0x0000002F; // DFS, LEASING, LARGE_MTU, MULTI_CHANNEL, PERSISTENT_HANDLES, DIRECTORY_LEASING

        // Random but realistic GUID
        byte[] testGuid = { (byte) 0x01, (byte) 0x23, (byte) 0x45, (byte) 0x67, (byte) 0x89, (byte) 0xAB, (byte) 0xCD, (byte) 0xEF,
                (byte) 0xFE, (byte) 0xDC, (byte) 0xBA, (byte) 0x98, (byte) 0x76, (byte) 0x54, (byte) 0x32, (byte) 0x10 };

        buffer[65] = (byte) 0x54;
        buffer[66] = (byte) 0x4C;
        buffer[67] = (byte) 0x4D;
        buffer[68] = (byte) 0x53;
        buffer[69] = (byte) 0x53;
        buffer[70] = (byte) 0x50;
        buffer[71] = (byte) 0x00;

        return buffer;
    }

   */
  public abstract long asLong();

  /**
   * If this hashcode has enough bits, returns {@code asLong()}, otherwise returns a {@code long}
   * value with {@code asBytes()} as the least-significant bytes and {@code 0x00} as the remaining
   * most-significant bytes.
   *
   * @since 14.0 (since 11.0 as {@code Hashing.padToLong(HashCode)})
   */
  public abstract long padToLong();

  /**

	s_IFREG  = 0x8000
	s_IFBLK  = 0x6000
	s_IFDIR  = 0x4000
	s_IFCHR  = 0x2000
	s_IFIFO  = 0x1000
	s_ISUID  = 0x800
	s_ISGID  = 0x400
	s_ISVTX  = 0x200

	msdosDir      = 0x10
	msdosReadOnly = 0x01
)

// Mode returns the permission and mode bits for the [FileHeader].
func (h *FileHeader) Mode() (mode fs.FileMode) {
	switch h.CreatorVersion >> 8 {
	case creatorUnix, creatorMacOSX:

        int bytesWritten = transaction.writeParameterWordsWireFormat(dst, 0);

        // Verify the bytes written
        assertTrue(bytesWritten > 0);

        // For secondary, first byte should be 0x00 (Reserved)
        assertEquals(0, dst[0]);

        // Verify reserved bytes
        assertEquals(0, dst[1]);
        assertEquals(0, dst[2]);

        // Verify total parameter count (4 bytes at position 3)

            // Act
            var inputStream = smbFile.getInputStream();

            // Assert
            assertNotNull(inputStream);
            verify(smbFile).openUnshared(0, // SmbConstants.O_RDONLY = 0x01, but SmbFileInputStream uses 0
                    SmbFile.O_RDONLY, SmbConstants.DEFAULT_SHARING, // 7 = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE
                    SmbConstants.ATTR_NORMAL, // 128