assertEquals(0xFFFF, SMBUtil.readInt2(buffer, 14));

        // Test different offsets
        for (int offset = 0; offset <= 8; offset++) {
            SMBUtil.writeInt4(0x12345678, buffer, offset);
            assertEquals(0x12345678, SMBUtil.readInt4(buffer, offset));
        }
    }

    @Test
    void testNegativeValueHandling() {
        byte[] buffer = new byte[8];

    @DisplayName("Test decode with buffer offset")
    void testDecodeWithBufferOffset() throws SMBProtocolDecodingException {
        String fileName = "offset_test.txt";
        int action = FileNotifyInformation.FILE_ACTION_MODIFIED;
        int offset = 50;

        byte[] smallBuffer = createValidNotificationBuffer(fileName, action);
        byte[] buffer = new byte[smallBuffer.length + offset + 50];

        if (stopwordsItemList == null) {
            reload(null);
        }

        if (offset >= stopwordsItemList.size() || offset < 0) {
            return new PagingList<>(Collections.<StopwordsItem> emptyList(), offset, size, stopwordsItemList.size());
        }

        int toIndex = offset + size;
        if (toIndex > stopwordsItemList.size()) {

    /**
     * Retrieves a paginated list of dictionary items.
     *
     * @param offset the starting offset for pagination
     * @param size the number of items to retrieve
     * @return a paginated list of dictionary items
     */
    public abstract PagingList<T> selectList(int offset, int size);

    /**
     * Retrieves a dictionary item by its ID.
     *
     * @param id the item ID

            assertEquals(ttl, ref.getTtl());
        }
    }

    // Buffer Offset Tests

    @Test
    public void testDecodeFromNonZeroIndex() {
        int offset = 100;
        ByteBuffer bb = ByteBuffer.wrap(testBuffer).order(ByteOrder.LITTLE_ENDIAN);

        bb.position(offset);
        bb.putShort((short) 1);
        bb.putShort((short) 24);
        bb.putShort((short) 1);

	{file: "myobject", offset: 100, length: 0, algorithm: SHA256, expError: nil},                // 3
	{file: "myobject", offset: 1, length: 120, algorithm: SHA256, expError: errFileCorrupt},     // 4
	{file: "myobject", offset: 3, length: 1100, algorithm: SHA256, expError: nil},               // 5
	{file: "myobject", offset: 2, length: 100, algorithm: SHA256, expError: errFileCorrupt},     // 6

    return db_hero


@app.get("/heroes/", response_model=list[HeroPublic])
def read_heroes(
    session: Session = Depends(get_session),
    offset: int = 0,
    limit: int = Query(default=100, le=100),
):
    heroes = session.exec(select(Hero).offset(offset).limit(limit)).all()
    return heroes


@app.get("/heroes/{hero_id}", response_model=HeroPublic)

    return ImmutableList.of(element);
  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override
  int copyIntoArray(@Nullable Object[] dst, int offset) {
    dst[offset] = element;
    return offset + 1;
  }

  @Override
  public final int hashCode() {
    return element.hashCode();
  }

  @Override
  public String toString() {
    return '[' + element.toString() + ']';

    private final long sourceOffset;
    private final long targetOffset;
    private final int length;

    /**
     * Constructs a server copy chunk descriptor
     * @param soff the source file offset
     * @param toff the target file offset
     * @param len the length of data to copy
     */
    public SrvCopychunk(final long soff, final long toff, final int len) {
        this.sourceOffset = soff;
        this.targetOffset = toff;

        if (stemmerOverrideItemList == null) {
            reload(null);
        }

        if (offset >= stemmerOverrideItemList.size() || offset < 0) {
            return new PagingList<>(Collections.<StemmerOverrideItem> emptyList(), offset, size, stemmerOverrideItemList.size());
        }

        int toIndex = offset + size;