TermQuery termQuery1 = new TermQuery(new Term("field1", "value1"));
        TermQuery termQuery2 = new TermQuery(new Term("field2", "value2"));
        TermQuery termQuery3 = new TermQuery(new Term("field3", "value3"));

        boolQueryBuilder.add(termQuery1, BooleanClause.Occur.MUST);
        boolQueryBuilder.add(termQuery2, BooleanClause.Occur.SHOULD);

    }

    public void test_execute_withTermQuery() {
        // Test executing BoostQuery with a TermQuery inside
        Term term = new Term("field", "value");
        TermQuery termQuery = new TermQuery(term);
        BoostQuery boostQuery = new BoostQuery(termQuery, 2.5f);

        QueryContext context = new QueryContext("test", false);

                            queryList.add(termQuery);
                        }
                    }
                }
            }
            return queryList;
        }
        if (query instanceof final TermQuery termQuery) {
            for (final String field : fields) {
                if (field.equals(termQuery.getTerm().field())) {

        final String field = getSearchField(context.getDefaultField(), termQuery.getTerm().field());
        final String text = termQuery.getTerm().text();
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        return convertTermQuery(fessConfig, context, termQuery, boost, field, text);
    }

    /**

        QueryBuilder queryBuilder = QueryBuilders.termQuery("field", "value");
        queryContext.setQueryBuilder(queryBuilder);
        assertEquals(queryBuilder, queryContext.getQueryBuilder());
    }

    // Test addFunctionScore
    public void test_addFunctionScore() {
        queryContext = new QueryContext("test", false);
        QueryBuilder initialQuery = QueryBuilders.termQuery("field", "value");

    }

    public void test_execute_withNonWildcardQuery() {
        QueryContext queryContext = new QueryContext("test", false);
        TermQuery termQuery = new TermQuery(new Term("title", "test"));

        try {
            queryCommand.execute(queryContext, termQuery, 1.0f);
            fail("Should throw InvalidQueryException");
        } catch (InvalidQueryException e) {
            // Expected exception

                .setQuery(QueryBuilders.termQuery("sessionId", "id1"))
                .execute()
                .actionGet()
                .getHits()
                .getTotalHits()
                .value() > 0);
        assertTrue(fesenClient.prepareSearch("fess_crawler.queue")
                .setQuery(QueryBuilders.termQuery("sessionId", "id2"))
                .execute()

        // Test with TermQuery
        Term term = new Term("content", "test");
        TermQuery termQuery = new TermQuery(term);
        String[] fields = { "content" };
        List<TermQuery> queryList = SuggestUtil.getTermQueryList(termQuery, fields);
        assertNotNull(queryList);
        assertEquals(1, queryList.size());
        assertEquals(termQuery, queryList.get(0));

    public void test_execute_withNonPhraseQuery() {
        // Test with non-phrase query - should throw InvalidQueryException
        Query termQuery = new TermQuery(new Term("field", "value"));
        QueryContext context = new QueryContext("test", false);

        try {
            queryCommand.execute(context, termQuery, 1.0f);
            fail("Should throw InvalidQueryException for non-phrase query");
        } catch (InvalidQueryException e) {

        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()));