boolQueryBuilder.add(new TermQuery(new Term("should" + i, "value" + i)), BooleanClause.Occur.SHOULD);
            boolQueryBuilder.add(new TermQuery(new Term("mustNot" + i, "value" + i)), BooleanClause.Occur.MUST_NOT);
        }

        BooleanQuery booleanQuery = boolQueryBuilder.build();
        QueryContext context = new QueryContext("test", false);

                    break;
                case SHOULD:
                    boolQuery.should(queryBuilder);
                    break;
                case MUST_NOT:
                    boolQuery.mustNot(queryBuilder);
                    break;
                default:
                    break;
                }
            }
        }
        if (boolQuery.hasClauses()) {

        final BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
        queryBuilder.must(QueryBuilders.termQuery(FieldNames.KINDS, SuggestItem.Kind.QUERY.toString()));
        queryBuilder.mustNot(QueryBuilders.existsQuery(FieldNames.READING_PREFIX + "1"));
        queryBuilder.must(QueryBuilders.rangeQuery(FieldNames.QUERY_FREQ).gte(queryFreqThreshold));
        if (!tags.isEmpty()) {

        boolQueryBuilder.must(QueryBuilders.termQuery(FieldNames.KINDS, SuggestItem.Kind.DOCUMENT.toString()));
        boolQueryBuilder.mustNot(QueryBuilders.termQuery(FieldNames.KINDS, SuggestItem.Kind.QUERY.toString()));
        boolQueryBuilder.mustNot(QueryBuilders.termQuery(FieldNames.KINDS, SuggestItem.Kind.USER.toString()));

        final List<JobLog> list = jobLogBhv.selectList(cb -> {
            cb.query().bool((must, should, mustNot, filter) -> {
                must.setLastUpdated_LessEqual(expiry);
                mustNot.setEndTime_Exists();
            });
        });
        if (!list.isEmpty()) {
            list.forEach(jobLog -> {

                .must(QueryBuilders.rangeQuery(FieldNames.DOC_FREQ).gte(1))
                .mustNot(QueryBuilders.matchPhraseQuery(FieldNames.KINDS, SuggestItem.Kind.QUERY.toString()))
                .mustNot(QueryBuilders.matchPhraseQuery(FieldNames.KINDS, SuggestItem.Kind.USER.toString())));
        if (deleteResponse.hasError()) {

                    .mustNot(QueryBuilders.termQuery(fessConfig.getIndexFieldSegment(), sessionId));
            if (!Constants.FALSE.equals(initParamMap.getAsString(KEEP_EXPIRES_DOCS))) {
                final QueryBuilder expiresCheckQuery = QueryBuilders.boolQuery()//
                        .mustNot(QueryBuilders.rangeQuery(fessConfig.getIndexFieldExpires()).gt("now"))//

        // Check that the boolean query has the correct number of clauses
        assertFalse(boolQueryBuilder.must().isEmpty());
        assertFalse(boolQueryBuilder.should().isEmpty());
        assertFalse(boolQueryBuilder.mustNot().isEmpty());
    }

    public void test_execute_withZeroBoost() {
        // Test executing BoostQuery with zero boost value
        Term term = new Term("field", "zero");

        roleSet.stream().forEach(name -> roleQuery.should(QueryBuilders.termQuery(roleField, name)));
        final String deniedPrefix = fessConfig.getRoleSearchDeniedPrefix();
        roleSet.stream().forEach(name -> roleQuery.mustNot(QueryBuilders.termQuery(roleField, deniedPrefix + name)));
        boolQuery.filter(roleQuery);
    }

    /**
     * Builds boost query functions to modify document scoring based on various factors.

      if (set == null) {
        return ImmutableSet.of();
      }
      ImmutableSet<E> ret = ImmutableEnumSet.asImmutable(set);
      set = null; // subsequent manual manipulation of the accumulator mustn't affect ret
      return ret;
    }
  }

  @GwtIncompatible
  @SuppressWarnings({"rawtypes", "unchecked"})
  static <E extends Comparable<? super E>>