// Since index and (dataset.length - 1) are non-negative ints, their product can be expressed
      // as a long, without risk of overflow:
      long numerator = (long) index * (dataset.length - 1);
      // Since scale is a positive int, index is in [0, scale], and (dataset.length - 1) is a
      // non-negative int, we can do long-arithmetic on index * (dataset.length - 1) / scale to get

      "doc_id": {
        "type": "keyword"
      },
      "favorite_count": {
        "type": "long"
      },
      "filename": {
        "type": "keyword"
      },
      "filetype": {
        "type": "keyword"
      },
      "host": {
        "type": "keyword"
      },
      "lang": {
        "type": "keyword"
      },
      "last_modified": {
        "type": "date",

     */
    public RdmaWorkRequest(long requestId, RequestType type, RdmaMemoryRegion memoryRegion) {
        this.requestId = requestId;
        this.type = type;
        this.memoryRegion = memoryRegion;
        this.completed = false;
    }

    /**
     * Get request ID
     *
     * @return unique request identifier
     */
    public long getRequestId() {
        return requestId;
    }

        return connection.getContentEncoding();
    }

    @Override
    public long getExpiration() {
        try {
            handshake();
        } catch (final IOException ex) {}
        return connection.getExpiration();
    }

    @Override
    public long getDate() {
        try {
            handshake();
        } catch (final IOException ex) {}

            }
            return (T) FessFunctions.parseDate(value.toString());
        }
        if (clazz.isAssignableFrom(Long.class)) {
            if (value instanceof Long) {
                return (T) value;
            }
            return (T) Long.valueOf(value.toString());
        }
        if (clazz.isAssignableFrom(Integer.class)) {
            if (value instanceof Integer) {

        return val;
    }

    /**
     * Encodes a long integer (4 bytes) in NDR format.
     *
     * @param l the long integer value to encode
     */
    public void enc_ndr_long(final int l) {
        align(4);
        Encdec.enc_uint32le(l, buf, index);
        advance(4);
    }

    /**
     * Decodes a long integer (4 bytes) from NDR format.
     *

     * Test FileEndOfFileInformation with various end of file values
     */
    @ParameterizedTest
    @ValueSource(longs = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE, 1024L, 1048576L })
    @DisplayName("Test FileEndOfFileInformation with various values")
    void testFileEndOfFileInformationWithVariousValues(long endOfFile) throws SMBProtocolDecodingException {
        FileEndOfFileInformation fileInfo = new FileEndOfFileInformation(endOfFile);

    assertThat(UnsignedBytes.saturatedCast(-1L)).isEqualTo(LEAST);
    assertThat(UnsignedBytes.saturatedCast(Long.MAX_VALUE)).isEqualTo(GREATEST);
    assertThat(UnsignedBytes.saturatedCast(Long.MIN_VALUE)).isEqualTo(LEAST);
  }

  private static void assertCastFails(long value) {
    try {
      UnsignedBytes.checkedCast(value);
      fail("Cast to byte should have failed: " + value);

  }

  private void setSuccessor(int entry, int succ) {
    long succMask = ~0L >>> 32;
    setLink(entry, (link(entry) & ~succMask) | ((succ + 1) & succMask));
  }

  private void setPredecessor(int entry, int pred) {
    long predMask = ~0L << 32;
    setLink(entry, (link(entry) & ~predMask) | ((long) (pred + 1) << 32));
  }

  private void setSucceeds(int pred, int succ) {

    return getBooleanProperty(USE_WITNESS, false);  // Disabled by default
}

public long getWitnessHeartbeatTimeout() {
    return getLongProperty(WITNESS_HEARTBEAT_TIMEOUT, 120000);  // 2 minutes
}

public long getWitnessRegistrationTimeout() {
    return getLongProperty(WITNESS_REGISTRATION_TIMEOUT, 300000);  // 5 minutes
}

public long getWitnessReconnectDelay() {