// Encode test data
        int offset = 0;
        SMBUtil.writeInt8(expectedAllocationSize, buffer, offset);
        offset += 8;
        SMBUtil.writeInt8(expectedEndOfFile, buffer, offset);
        offset += 8;
        SMBUtil.writeInt4(expectedNumberOfLinks, buffer, offset);
        offset += 4;
        buffer[offset++] = (byte) (expectedDeletePending ? 1 : 0);
        buffer[offset++] = (byte) (expectedDirectory ? 1 : 0);

        offset += 8;

        // sectorsPerAllocationUnit (4 bytes)
        SMBUtil.writeInt4(16, buffer, offset);
        offset += 4;

        // bytesPerSector (4 bytes)
        SMBUtil.writeInt4(4096, buffer, offset);
        offset += 4;

        // Set dataCount using reflection
        setDataCount(response, offset);

        int bytesRead = response.readDataWireFormat(buffer, 0, offset);

        buffer[offset + 3] = 0;
        SMBUtil.writeInt4(0x1234, buffer, offset + 4);
        SMBUtil.writeInt4(0x5678, buffer, offset + 8);
        SMBUtil.writeInt4(0x9ABC, buffer, offset + 12);

        // When
        int bytesRead = response.readBytesWireFormat(buffer, offset);

        // Then
        assertEquals(16, bytesRead);
        assertEquals((byte) 0x02, response.getShareType());

            // DFS alternate path offset (2 bytes)
            SMBUtil.writeInt2(0, buffer, offset + 14);

            // Network address offset (2 bytes)
            SMBUtil.writeInt2(0, buffer, offset + 16);

            // Padding
            buffer[offset + 18] = 0;
            buffer[offset + 19] = 0;

            // Write string data at stringOffset

        @DisplayName("Should handle various buffer offsets")
        void testVariousBufferOffsets(int offset) {
            byte[] largeBuffer = new byte[512];
            int result = testRequest.encode(largeBuffer, offset);

            assertTrue(result > 0);
            // Verify header at correct offset
            for (int i = offset; i < offset + 8; i++) {
                assertEquals((byte) 0xFF, largeBuffer[i]);

     *
     * @param data the data buffer
     * @param offset the offset in the buffer
     * @param length the length of data to compress
     * @param algorithm the compression algorithm to use
     * @return the compressed data
     * @throws CIFSException if compression fails
     */
    byte[] compress(byte[] data, int offset, int length, int algorithm) throws CIFSException;

	}

	// To generate random offset/length.
	r := rand.New(rand.NewSource(UTCNow().UnixNano()))

	buf := &bytes.Buffer{}

	// Verify erasure.Decode() for random offsets and lengths.
	for range iterations {
		offset := r.Int63n(length)
		readLen := r.Int63n(length - offset)

		expected := data[offset : offset+readLen]

		// Get the checksums of the current part.

  }

  private static long hashLength33To64(byte[] bytes, int offset, int length) {
    long z = load64(bytes, offset + 24);
    long a = load64(bytes, offset) + (length + load64(bytes, offset + length - 16)) * K0;
    long b = rotateRight(a + z, 52);
    long c = rotateRight(a, 37);
    a += load64(bytes, offset + 8);
    c += rotateRight(a, 7);
    a += load64(bytes, offset + 16);
    long vf = a + z;

        // Verify notify flags
        assertEquals(Smb2ChangeNotifyRequest.SMB2_WATCH_TREE, SMBUtil.readInt2(buffer, offset + 2));

        // Verify output buffer length
        assertEquals(8192, SMBUtil.readInt4(buffer, offset + 4));

        // Verify file ID
        byte[] readFileId = new byte[16];
        System.arraycopy(buffer, offset + 8, readFileId, 0, 16);

        // Length = 5, Offset = 8
        ByteBuffer buffer = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN);
        buffer.putShort(0, (short) content.length); // Length
        buffer.putShort(2, (short) content.length); // MaxLength (not used by readSecurityBuffer, but typically same as length)
        buffer.putInt(4, 8); // Offset