hmac.engineUpdate((byte) 0x01);
        // No exception means success
    }

    @Test
    void testEngineUpdateByteArray() {
        // Test engineUpdate(byte[] input, int offset, int len)
        HMACT64 hmac = new HMACT64(TEST_KEY);
        hmac.engineUpdate(TEST_DATA, 0, TEST_DATA.length);
        // No exception means success
    }

    @Test
    void testEngineUpdateByteArrayPartial() {

            byte[] buffer = new byte[100];
            int offset = 40;
            ByteBuffer bb = ByteBuffer.wrap(buffer, offset, 24).order(ByteOrder.LITTLE_ENDIAN);
            bb.putLong(5000L);
            bb.putLong(2500L);
            bb.putInt(16);
            bb.putInt(1024);

            // When
            int bytesConsumed = fileFsSizeInfo.decode(buffer, offset, 24);

            // Then

func (client *storageRESTClient) ReadFileStream(ctx context.Context, volume, path string, offset, length int64) (io.ReadCloser, error) {
	values := make(url.Values)
	values.Set(storageRESTVolume, volume)
	values.Set(storageRESTFilePath, path)
	values.Set(storageRESTOffset, strconv.Itoa(int(offset)))
	values.Set(storageRESTLength, strconv.Itoa(int(length)))

    /**
     * Returns the page size.
     *
     * @return The page size.
     */
    public abstract int getPageSize();

    /**
     * Returns the offset.
     *
     * @return The offset.
     */
    public abstract int getOffset();

    /**
     * Returns the extra queries.
     *
     * @return The extra queries.
     */

		}
		o, l, err := rs.GetOffsetLength(resourceSize)
		if err != nil {
			t.Errorf("unexpected err: %v", err)
		}
		if o != testCase.expOffset || l != testCase.expLength {
			t.Errorf("Case %d: got bad offset/length: %d,%d expected: %d,%d",
				i, o, l, testCase.expOffset, testCase.expLength)
		}
	}

	unparsableRangeSpecs := []string{
		"bytes=-",
		"bytes==",
		"bytes==1-10",
		"bytes=",
		"bytes=aa",

     */
    public int size() {
        return 0;
    }

    /**
     * Encode this request (no-op since there's no data)
     *
     * @param dst destination buffer
     * @param dstIndex starting offset
     * @return number of bytes written (always 0)
     */
    public int encode(byte[] dst, int dstIndex) {
        // No data to encode
        return 0;
    }

	if (len(users1) != len(users4)) || (len(users1)-len(users2) != 3) || (len(users1)-len(users3) != 5) {
		t.Errorf("Offset should work")
	}

	DB.Where("name like ?", "OffsetUser%").Order("age desc").Find(&users1).Offset(3).Find(&users2).Offset(5).Find(&users3).Offset(-1).Find(&users4)

    }

    @Test
    @DisplayName("readParametersWireFormat with offset should work correctly")
    void testReadParametersWireFormatWithOffset() {
        // Arrange
        byte[] buffer = new byte[20];
        int bufferIndex = 10;

        // Write data at offset
        SMBUtil.writeInt2(500, buffer, bufferIndex);
        SMBUtil.writeInt2(0, buffer, bufferIndex + 2);

					},
				},
			},
			offset:            19109865,
			startOffset:       0,
			snappyStartOffset: 19109865,
		},
		2: {
			objInfo: ObjectInfo{
				Parts: []ObjectPartInfo{
					{
						Size:       39235668,
						ActualSize: 67108864,
					},
					{
						Size:       19177372,
						ActualSize: 32891137,
					},
				},
			},
			offset:            0,
			startOffset:       0,

at the beginning, as in <code>first_arg+0(FP)</code> and <code>second_arg+8(FP)</code>.
(The meaning of the offset—offset from the frame pointer—distinct
from its use with <code>SB</code>, where it is an offset from the symbol.)
The assembler enforces this convention, rejecting plain <code>0(FP)</code> and <code>8(FP)</code>.