byte[] buffer = new byte[100];
        int offset = 10;

        // When
        int bytesWritten = request.writeBytesWireFormat(buffer, offset);

        // Then
        assertEquals(4, bytesWritten, "Should write 4 bytes");
        // Check that structure size (4) is written as 2-byte little-endian
        assertEquals(4, buffer[offset] | (buffer[offset + 1] << 8), "Structure size should be 4");

	}
	return n, err
}

func (d *DummyDataGen) Seek(offset int64, whence int) (int64, error) {
	switch whence {
	case io.SeekStart:
		if offset < 0 {
			return 0, errors.New("Invalid offset")
		}
		d.idx = offset
	case io.SeekCurrent:
		if d.idx+offset < 0 {
			return 0, errors.New("Invalid offset")
		}
		d.idx += offset
	case io.SeekEnd:
		if d.length+offset < 0 {
			return 0, errors.New("Invalid offset")
		}

     * @param pageSize the number of records per page
     * @param offset the offset value for pagination
     */
    protected QueryResponseList(final List<Map<String, Object>> documentList, final int start, final int pageSize, final int offset) {
        parent = documentList;
        this.offset = offset;
        this.start = start;
        this.pageSize = pageSize;
    }

    /**

  /** Private constructor for built-in DiscreteDomains supporting fast offset. */
  private DiscreteDomain(boolean supportsFastOffset) {
    this.supportsFastOffset = supportsFastOffset;
  }

  /**
   * Returns, conceptually, "origin + distance", or equivalently, the result of calling {@link
   * #next} on {@code origin} {@code distance} times.
   */
  C offset(C origin, long distance) {
    C current = origin;

            // 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

    private final transient @Nullable Object[] alternatingKeysAndValues;
    private final transient int offset;
    private final transient int size;

    KeysOrValuesAsList(@Nullable Object[] alternatingKeysAndValues, int offset, int size) {
      this.alternatingKeysAndValues = alternatingKeysAndValues;
      this.offset = offset;
      this.size = size;
    }

    @Override
    public Object get(int index) {

            assertEquals(12, bytesWritten);
            assertEquals(1, SMBUtil.readInt2(buffer, offset));
            assertEquals(6, SMBUtil.readInt2(buffer, offset + 2));
            assertEquals(PreauthIntegrityNegotiateContext.HASH_ALGO_SHA512, SMBUtil.readInt2(buffer, offset + 4));
            assertArrayEquals(salt, Arrays.copyOfRange(buffer, offset + 6, offset + 12));
        }

            // 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));

    }

    @Test
    @DisplayName("Test decode with buffer offset")
    void testDecodeWithBufferOffset() throws SMBProtocolDecodingException {
        // Prepare test data with offset
        int offset = 10;
        String expectedFilename = "offsetfile.txt";
        byte[] buffer = new byte[200 + offset];
        byte[] dataBuffer = createValidBuffer(expectedFilename, "OFFSET~1.TXT", true);

        @Test
        @DisplayName("Should handle offset correctly in verify")
        void testVerifyWithOffset() throws Exception {
            byte[] largeData = new byte[256];
            int offset = 64;
            Arrays.fill(largeData, (byte) 0x00);

            // Set signed flag at correct offset
            SMBUtil.writeInt4(ServerMessageBlock2.SMB2_FLAGS_SIGNED, largeData, offset + 16);

            // Create valid signature