*/
    public int rdmaRead(ByteBuffer buffer, long remoteAddress, int remoteKey, int length) throws IOException {
        if (!isRdmaConnected()) {
            throw new IOException("RDMA connection not available");
        }

        try {
            statistics.recordReadRequest(length);
            long startTime = System.nanoTime();

   * {@code long} value in little-endian order.
   *
   * @throws IllegalStateException if {@code bits() < 64}
   */
  public abstract long asLong();

  /**
   * If this hashcode has enough bits, returns {@code asLong()}, otherwise returns a {@code long}
   * value with {@code asBytes()} as the least-significant bytes and {@code 0x00} as the remaining

        "type": "keyword"
      },
      "expiredTime": {
        "type": "long"
      },
      "createdBy": {
        "type": "keyword"
      },
      "createdTime": {
        "type": "long"
      },
      "updatedBy": {
        "type": "keyword"
      },
      "updatedTime": {
        "type": "long"
      }
    }

        long maxTime = System.currentTimeMillis() + 1000000000000L;
        SMBUtil.writeTime(maxTime, buffer, 8); // creationTime
        SMBUtil.writeTime(maxTime, buffer, 16); // lastAccessTime
        SMBUtil.writeTime(maxTime, buffer, 24); // lastWriteTime
        SMBUtil.writeTime(maxTime, buffer, 32); // changeTime
        SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 40); // endOfFile

    /** Time taken for the operation in milliseconds. */
    protected final long took;

    /**
     * Constructor for SuggestDeleteResponse.
     * @param errors A list of Throwables representing errors.
     * @param took The time taken for the operation in milliseconds.
     */
    protected SuggestDeleteResponse(final List<Throwable> errors, final long took) {
        this.took = took;
        if (errors != null && !errors.isEmpty()) {

     * zero and negative capacities.
     */
    @ParameterizedTest
    @ValueSource(longs = { 0L, -1L, Long.MAX_VALUE })
    @DisplayName("capacity may be any long value")
    void testCapacityEdgeValues(long capacity) {
        when(mockAllocInfo.getCapacity()).thenReturn(capacity);
        assertEquals(capacity, mockAllocInfo.getCapacity());
    }

    /**

     */
    public boolean isExpired(long timeoutMs) {
        return System.currentTimeMillis() - lastHeartbeat > timeoutMs;
    }

    // Getters and setters

    /**
     * Gets the last heartbeat timestamp.
     *
     * @return the last heartbeat timestamp in milliseconds
     */
    public long getLastHeartbeat() {
        return lastHeartbeat;
    }

    /**

    assertThat(Adapters.INTEGER_AS_LONG.fromDer(bytes)).isEqualTo(-256L)
  }

  @Test fun `max long`() {
    val bytes = "02087fffffffffffffff".decodeHex()
    assertThat(Adapters.INTEGER_AS_LONG.fromDer(bytes)).isEqualTo(Long.MAX_VALUE)
    assertThat(Adapters.INTEGER_AS_LONG.toDer(Long.MAX_VALUE)).isEqualTo(bytes)
  }

  @Test fun `min long`() {
    val bytes = "02088000000000000000".decodeHex()

 * maximumSize}, {@link #maximumWeight(long) maximumWeight}, {@link #expireAfterWrite
 * expireAfterWrite}, {@link #expireAfterAccess expireAfterAccess}, {@link #weakKeys weakKeys},
 * {@link #weakValues weakValues}, or {@link #softValues softValues} are requested.
 *
 * <p>If {@link #maximumSize(long) maximumSize} or {@link #maximumWeight(long) maximumWeight} is

/**
 * @param <ENTITY> The type of entity.
 * @author ESFlute (using FreeGen)
 */
public class EsPagingResultBean<ENTITY> extends PagingResultBean<ENTITY> {

    private static final long serialVersionUID = 1L;

    protected long took;
    private int totalShards;
    private int successfulShards;
    private int failedShards;
    private TotalHits totalHits;
    private Aggregations aggregations;