}

        writeInt2(NET_SHARE_ENUM, dst, dstIndex);
        dstIndex += 2;
        System.arraycopy(descr, 0, dst, dstIndex, descr.length);
        dstIndex += descr.length;
        writeInt2(0x0001, dst, dstIndex);
        dstIndex += 2;
        writeInt2(maxDataCount, dst, dstIndex);
        dstIndex += 2;

        return dstIndex - start;
    }

    @Override

        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")

        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

      .isEqualTo(0L)
    assertThat(parse(url, "a=b; Expires=Thu, 01 Jan 1970 00:00:0 GMT")!!.expiresAt)
      .isEqualTo(0L)
    assertThat(parse(url, "a=b; Expires=00:00:00 Thu, 01 Jan 1970 GMT")!!.expiresAt)
      .isEqualTo(0L)
    assertThat(parse(url, "a=b; Expires=00:00:00 1970 Jan 01")!!.expiresAt)
      .isEqualTo(0L)

        assertArrayEquals(expectedDescrBytes, actualDescrBytes);

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

        // Verify maxDataCount (2 bytes)
        int maxDataCount = SMBUtil.readInt2(dst, descrEnd + 2);

            buffer[16 + i] = expectedData[i];
        }

        // Set header values
        SMBUtil.writeInt4(0x100, buffer, 0);
        SMBUtil.writeInt4(0x200, buffer, 4);
        SMBUtil.writeInt4(0x300, buffer, 8);
        SMBUtil.writeInt4(0x400, buffer, 12);

        // Decode
        response.decode(buffer, 0, 32);

        // Verify data integrity

    assertEscaping(e, "%00", '\u0000'); // nul
    assertEscaping(e, "%7F", '\u007f'); // del
    assertEscaping(e, "%C2%80", '\u0080'); // xx-00010,x-000000
    assertEscaping(e, "%DF%BF", '\u07ff'); // xx-11111,x-111111
    assertEscaping(e, "%E0%A0%80", '\u0800'); // xxx-0000,x-100000,x-00,0000
    assertEscaping(e, "%EF%BF%BF", '\uffff'); // xxx-1111,x-111111,x-11,1111
    assertUnicodeEscaping(e, "%F0%90%80%80", '\uD800', '\uDC00');

            // Since FLAGS2_RESOLVE_PATHS_IN_DFS is 0x1000, when cast to byte it becomes 0
            // Therefore the method will always return false unless flags has all 0x00 bits set
            // This test verifies actual behavior
            testBlock.setFlags((byte) 0x00);
            assertFalse(testBlock.isResolveInDfs());

        /**
         * Default constructor for TimeOfDayInfo.
         */
        public TimeOfDayInfo() {
        }

        /**
         * The time elapsed since 00:00:00, January 1, 1970 GMT.
         */
        public int elapsedt;
        /**
         * The number of milliseconds from the start of the current second.
         */
        public int msecs;
        /**

        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() {