@DisplayName("Should handle hexdump with offset")
    void testHexdumpWithOffset() {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(baos);

        // Create test data and dump from offset
        byte[] data = createTestData(64);
        int offset = 16;
        int length = 32;

        Hexdump.hexdump(ps, data, offset, length);

            // Verify all chunks
            int offset = HEADER_SIZE;
            assertEquals(0L, SMBUtil.readInt8(buffer, offset));
            assertEquals(1024L, SMBUtil.readInt8(buffer, offset + 8));
            assertEquals(4096, SMBUtil.readInt4(buffer, offset + 16));

            offset += CHUNK_SIZE;
            assertEquals(4096L, SMBUtil.readInt8(buffer, offset));

        final int ownerUOffset = ServerMessageBlock.readInt4(buffer, bufferIndex); // offset to owner sid
        bufferIndex += 4;
        final int ownerGOffset = ServerMessageBlock.readInt4(buffer, bufferIndex); // offset to group sid
        bufferIndex += 4;
        final int saclOffset = ServerMessageBlock.readInt4(buffer, bufferIndex); // offset to sacl
        bufferIndex += 4;

    @Test
    @DisplayName("Test writeSetupWireFormat with offset")
    void testWriteSetupWireFormatWithOffset() {
        trans2SetFileInfo = new Trans2SetFileInformation(config, TEST_FID, mockFileInfo);

        byte[] buffer = new byte[256];
        int offset = 50;
        int written = trans2SetFileInfo.writeSetupWireFormat(buffer, offset);

        // Should write 2 bytes at offset
        assertEquals(2, written);

func (b *streamingBitrotReader) ReadAt(buf []byte, offset int64) (int, error) {
	var err error
	if offset%b.shardSize != 0 {
		// Offset should always be aligned to b.shardSize
		// Can never happen unless there are programmer bugs
		return 0, errUnexpected
	}
	if b.rc == nil {
		// For the first ReadAt() call we need to open the stream for reading.
		b.currOffset = offset
		streamOffset := (offset/b.shardSize)*int64(b.h.Size()) + offset

        }
        return start;
    }

    @Override
    public int getOffset() {
        if (offset == null) {
            offset = 0;
        }
        return offset;
    }

    @Override
    public int getPageSize() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        if (num == null) {

func (d *naughtyDisk) ReadFile(ctx context.Context, volume string, path string, offset int64, buf []byte, verifier *BitrotVerifier) (n int64, err error) {
	if err := d.calcError(); err != nil {
		return 0, err
	}
	return d.disk.ReadFile(ctx, volume, path, offset, buf, verifier)
}

func (d *naughtyDisk) ReadFileStream(ctx context.Context, volume, path string, offset, length int64) (io.ReadCloser, error) {
	if err := d.calcError(); err != nil {

    }

    // Helper method to extract string from buffer
    private String extractStringFromBuffer(byte[] buffer, int offset, int maxLen) {
        int end = offset;
        while (end < offset + maxLen && buffer[end] != 0) {
            end++;
        }
        return new String(buffer, offset, end - offset, StandardCharsets.UTF_8);
    }

     * @param offset
     *            The starting offset in the input data
     * @param len
     *            The length of data to process
     */
    public void update(final byte[] input, final int offset, final int len) {
        if (log.isTraceEnabled()) {
            log.trace("update: " + this.updates + " " + offset + ":" + len);

            // Reflectively inspect the private 'offset' field to assert it used the advanced fp
            Field offField = Smb2ReadRequest.class.getDeclaredField("offset");
            offField.setAccessible(true);
            long offVal = offField.getLong(req);
            assertEquals(2L, offVal, "Request offset should match skipped bytes");
        }

        @Test