QueryBuilder builder = queryCommand.convertTermRangeQuery(context, query, 1.0f);
        assertNotNull(builder);
        assertTrue(builder instanceof RangeQueryBuilder);

        // Query was processed successfully
        RangeQueryBuilder rqb = (RangeQueryBuilder) builder;
        assertEquals("title", rqb.fieldName());
    }

                logger.debug("Base: {} File: {} DocId: {}", b, s, id);
            }
            return id;
        }

        /**
         * Gets the count of processed files.
         *
         * @return the number of files processed
         */
        public long getCount() {
            if (!deletedFileList.isEmpty()) {
                deleteFiles();
            }
            return count;

 */
public class BulkBody {

    /**
     * Creates a new instance of BulkBody.
     */
    public BulkBody() {
        // Default constructor
    }

    /**
     * List of documents to be processed in bulk operations.
     */
    public List<Map<String, Object>> documents;

        /** Indicates that a URL was prepared for crawling. */
        PREPARED,
        /** Indicates that a URL redirect was encountered. */
        REDIRECTED,
        /** Indicates that a URL was processed completely. */
        PROCESSED
    }

            flush();
        }
        return (long) ids.length;
    };

    /**
     * Processes the score boosting.
     * @return The number of processed documents.
     */
    public abstract long process();

    /**
     * Enables this score booster.
     */
    protected void enable() {

     *
     * @param index the name of the index to scroll through
     * @param callback the function to apply to each search hit, returning true to continue or false to stop
     * @return the number of documents processed
     */
    public static long scroll(final String index, final Function<SearchHit, Boolean> callback) {
        final SearchEngineClient client = ComponentUtil.getSearchEngineClient();

  /** Number of bytes to be filled before process() invocation(s). */
  private final int bufferSize;

  /** Number of bytes processed per process() invocation. */
  private final int chunkSize;

  /**
   * Constructor for use by subclasses. This hasher instance will process chunks of the specified
   * size.
   *
   * @param chunkSize the number of bytes available per {@link #process(ByteBuffer)} invocation;
   *     must be at least 4

    val totalBytesToRead = inflater.bytesRead + deflatedBytes.size

    // We cannot read all, as the source does not close.
    // Instead, we ensure that all bytes from source have been processed by inflater.
    do {
      inflaterSource.readOrInflate(buffer, Long.MAX_VALUE)
    } while (inflater.bytesRead < totalBytesToRead && !inflater.finished())
  }

  @Throws(IOException::class)

        return processResponse(searchResponseOpt);
    }

    /**
     * Processes the OpenSearch response and converts it to a SearchResult.
     *
     * @param searchResponseOpt the optional search response from OpenSearch
     * @return the processed search result
     */
    protected SearchResult processResponse(final OptionalEntity<SearchResponse> searchResponseOpt) {

        assertTrue(result.isPresent());

        // Test that we can chain operations
        String processed = result.map(s -> s.toLowerCase()).orElse("default");

        assertEquals("hello world", processed);

        // Test with null value
        String nullValue = null;
        OptionalEntity<String> emptyResult = OptionalUtil.ofNullable(nullValue);