final List<QueryBuilder> queryBuilderList = cb.query().getQueryBuilderList();
        assertEquals(2, queryBuilderList.size());
        assertEquals("TermQueryBuilder", queryBuilderList.get(0).getClass().getSimpleName());
        assertEquals("BoolQueryBuilder", queryBuilderList.get(1).getClass().getSimpleName());
        final List<FieldSortBuilder> fieldSortBuilderList = cb.query().getFieldSortBuilderList();

                    }
                }
                query = buf.toString();
                request.setAttribute(key, query);
            }
            return query;
        }).orElse(null);
    }

    private static String createForm(final String key, final String prefix) {
        return LaRequestUtil.getOptionalRequest().map(request -> {
            String query = (String) request.getAttribute(key);

            final OptionalThing<FessUserBean> userBean) {
        return searchRequestBuilder -> {
            ComponentUtil.getQueryHelper().processSearchPreference(searchRequestBuilder, userBean, query);
            return SearchConditionBuilder.builder(searchRequestBuilder).query(query).offset(params.getStartPosition())

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

import org.dbflute.exception.InvalidQueryRegisteredException;
import org.opensearch.index.query.QueryBuilder;
import org.opensearch.search.aggregations.AbstractAggregationBuilder;
import org.opensearch.search.aggregations.AggregationBuilders;
import org.opensearch.search.aggregations.bucket.filter.FilterAggregationBuilder;

import org.codelibs.fess.util.MemoryUtil;
import org.opensearch.action.admin.indices.refresh.RefreshResponse;
import org.opensearch.action.search.SearchResponse;
import org.opensearch.index.query.QueryBuilder;
import org.opensearch.index.query.QueryBuilders;

public class IndexingHelper {
    private static final Logger logger = LogManager.getLogger(IndexingHelper.class);

    protected int maxRetryCount = 5;

            assertEquals(expected.get(i), subRangeMap.get(i));
          }

          for (Range<Integer> query : RANGES) {
            assertEquals(
                expected.asMapOfRanges().get(query), subRangeMap.asMapOfRanges().get(query));
          }
        }
      }
    }
  }

  public void testSubSubRangeMap() {

        }
    }

    protected List<BoostDocumentRule> getAvailableBoostDocumentRuleList() {
        return ComponentUtil.getComponent(BoostDocumentRuleBhv.class).selectList(cb -> {
            cb.query().matchAll();
            cb.query().addOrderBy_SortOrder_Asc();
            cb.fetchFirst(ComponentUtil.getFessConfig().getPageDocboostMaxFetchSizeAsInteger());
        });
    }

    protected void deleteCrawlData(final String sid) {

          Supplier<M> multisetSupplier) {
    return CollectCollectors.toMultiset(elementFunction, countFunction, multisetSupplier);
  }

  /**
   * Returns an unmodifiable view of the specified multiset. Query operations on the returned
   * multiset "read through" to the specified multiset, and attempts to modify the returned multiset
   * result in an {@link UnsupportedOperationException}.
   *

   * by applying the given {@code AsyncFunction} to the result of the original {@code Future}.
   * Example usage:
   *
   * <pre>{@code
   * FluentFuture<RowKey> rowKeyFuture = FluentFuture.from(indexService.lookUp(query));
   * ListenableFuture<QueryResult> queryFuture =
   *     rowKeyFuture.transformAsync(dataService::readFuture, executor);
   * }</pre>
   *

 */
@DoNotMock("Use ImmutableMultimap, HashMultimap, or another implementation")
@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface Multimap<K extends @Nullable Object, V extends @Nullable Object> {
  // Query Operations

  /**
   * Returns the number of key-value pairs in this multimap.
   *
   * <p><b>Note:</b> this method does not return the number of <i>distinct keys</i> in the multimap,