final String[] fields) {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

        final long numFound = getDocumentSizeByQuery(searchEngineClient, queryBuilder, fessConfig);
        final long maxSearchDocSize = fessConfig.getIndexerMaxSearchDocSizeAsInteger().longValue();
        final boolean exceeded = numFound > maxSearchDocSize;
        if (exceeded) {

            long totalSavings,
            List<ValueFrequency> mostFrequentValues) {}

    record PathAnalysis(
            String path,
            long uniqueStrings,
            long totalOccurrences,
            long totalMemory,
            long potentialSavings,
            double duplicationRatio,
            List<ValueFrequency> mostFrequentValues) {}

        return this;
    }

    public void setCreatedTime_Equal(Long createdTime) {
        setCreatedTime_Term(createdTime, null);
    }

    public void setCreatedTime_Equal(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setCreatedTime_Term(createdTime, opLambda);
    }

    public void setCreatedTime_Term(Long createdTime) {
        setCreatedTime_Term(createdTime, null);
    }

        // Test minimum value
        event.setVersionNo(Long.MIN_VALUE);
        assertEquals(Long.valueOf(Long.MIN_VALUE), event.getVersionNo());

        // Test zero
        event.setVersionNo(0L);
        assertEquals(Long.valueOf(0L), event.getVersionNo());

        // Test maximum value
        event.setVersionNo(Long.MAX_VALUE);
        assertEquals(Long.valueOf(Long.MAX_VALUE), event.getVersionNo());
    }

    protected boolean existPrevPage;

    /** The record number of the first record on the current page (1-based). */
    protected long currentStartRecordNumber;

    /** The record number of the last record on the current page (1-based). */
    protected long currentEndRecordNumber;

    /** A list of page numbers for pagination display (typically a range around the current page). */

    /** createdBy */
    protected String createdBy;

    /** createdTime */
    protected Long createdTime;

    /** sortOrder */
    protected Integer sortOrder;

    /** updatedBy */
    protected String updatedBy;

    /** updatedTime */
    protected Long updatedTime;

    /** urlExpr */
    protected String urlExpr;

    // [Referrers] *comment only

      Runnable command, long initialDelay, long period, TimeUnit unit);

  /**
   * @since 15.0 (previously returned ScheduledFuture)
   */
  @Override
  ListenableScheduledFuture<?> scheduleWithFixedDelay(
      Runnable command, long initialDelay, long delay, TimeUnit unit);

   *
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  static long toNanosSaturated(Duration duration) {
    // Using a try/catch seems lazy, but the catch block will rarely get invoked (except for

  @Throws(Exception::class)
  fun run() {
    val progressListener =
      object : ProgressListener {
        private var firstUpdate = true

        override fun update(
          bytesWritten: Long,
          contentLength: Long,
          done: Boolean,
        ) {
          if (done) {
            println("completed")
          } else {
            if (firstUpdate) {
              firstUpdate = false

     */
    private final long timeout;

    /**
     * The timestamp when this handle was created
     */
    private final long createTime;

    /**
     * The timestamp of the last access to this handle
     */
    private volatile long lastAccessTime;

    /**
     * The associated lease key if this handle has an SMB2 lease
     */