buffer.put((byte) 0x01); // SubAuthorityCount
        buffer.put(new byte[] { 0, 0, 0, 0, 0, 2 }); // IdentifierAuthority
        buffer.putInt(0); // SubAuthority

        // DACL at offset 60
        buffer.position(60);
        buffer.put((byte) 0x02); // AclRevision
        buffer.put((byte) 0x00); // Padding
        buffer.putShort((short) 8); // AclSize
        buffer.putShort((short) 0); // AceCount

     */
    public static final int DFS_VOLUME_FLAVOR_AD_BLOB = 0x200;
    /**
     * DFS storage state indicating offline status
     */
    public static final int DFS_STORAGE_STATE_OFFLINE = 0x0001;
    /**
     * DFS storage state indicating online status
     */
    public static final int DFS_STORAGE_STATE_ONLINE = 0x0002;
    /**
     * DFS storage state indicating active status
     */

        assertEquals("abc", StringUtil.substringToLast("abc", "dddd"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testToHex() throws Exception {
        assertEquals("010203", StringUtil.toHex(new byte[] { 1, 2, 3 }));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testToHex2() throws Exception {
        assertEquals("0001", StringUtil.toHex(1));

        assertEquals(expectedHigh, buffer[offset + 3]);
    }

    private static Stream<Arguments> provideFidTestCases() {
        return Stream.of(Arguments.of(0x0000, (byte) 0x00, (byte) 0x00), Arguments.of(0x00FF, (byte) 0xFF, (byte) 0x00),
                Arguments.of(0xFF00, (byte) 0x00, (byte) 0xFF), Arguments.of(0xFFFF, (byte) 0xFF, (byte) 0xFF),
                Arguments.of(0x1234, (byte) 0x34, (byte) 0x12));
    }

    @Test

        }

        @Test
        @DisplayName("Should handle ciphers with maximum value")
        void testMaximumCipherValues() throws SMBProtocolDecodingException {
            int[] ciphers = { 0xFFFF, 0x0000, 0x7FFF };
            EncryptionNegotiateContext originalContext = new EncryptionNegotiateContext(mockConfig, ciphers);

            int encoded = originalContext.encode(buffer, 0);

        byte[] data1 = { 0x00, 0x01, 0x02, 0x03 };
        assertEquals("00", Hexdump.toHexString(data1, 0, 2)); // 2 chars = 1 byte
        assertEquals("000", Hexdump.toHexString(data1, 0, 3)); // 3 chars = 1.5 bytes (rounds up to 2)
        assertEquals("0001", Hexdump.toHexString(data1, 0, 4)); // 4 chars = 2 bytes
        assertEquals("000102", Hexdump.toHexString(data1, 0, 6)); // 6 chars = 3 bytes

        int bytesWritten = request.writeBytesWireFormat(buffer, offset);

        // Then
        assertEquals(4, bytesWritten);

        // Expected wire format: [0x04, 0x00, 0x00, 0x00]
        byte[] expected = new byte[] { 0x04, 0x00, 0x00, 0x00 };
        assertArrayEquals(expected, buffer);
    }

    @Test
    @DisplayName("Should always return 0 for readBytesWireFormat")
    void testReadBytesWireFormat() {

        // recordType (2 bytes)
        src[srcIndex + 2] = 0x00;
        src[srcIndex + 3] = 0x20; // NB (0x0020)
        // recordClass (2 bytes)
        src[srcIndex + 4] = 0x00;
        src[srcIndex + 5] = 0x01; // IN (0x0001)
        // ttl (4 bytes)
        src[srcIndex + 6] = 0x00;
        src[srcIndex + 7] = 0x00;
        src[srcIndex + 8] = 0x00;
        src[srcIndex + 9] = 0x00;
        // rDataLength (2 bytes)

        assertNotNull(result);
        assertTrue(result.contains("FileNotifyInformation"));
        assertTrue(result.contains("nextEntry=0"));
        assertTrue(result.contains("action=0x0000")); // Hexdump.toHexString produces 4-char padded hex
        assertTrue(result.contains("file=null"));
    }

    @ParameterizedTest
    @DisplayName("Test decode with aligned next entry offsets")

        assertArrayEquals(expectedDescrBytes, actualDescrBytes);

        // Verify level (0x0001)
        int descrEnd = 2 + expectedDescrBytes.length;
        assertEquals(0x01, dst[descrEnd]);
        assertEquals(0x00, dst[descrEnd + 1]);

        // Verify maxDataCount (16384)
        assertEquals(16384, SMBUtil.readInt2(dst, descrEnd + 2));