* @param q The query string.
     * @param fields The fields to search in.
     * @return The QueryBuilder instance.
     */
    public QueryBuilder buildQuery(final String q, final List<String> fields) {
        try {
            final QueryBuilder queryBuilder;
            if (Strings.isNullOrEmpty(q)) {
                queryBuilder = QueryBuilders.matchAllQuery();
            } else {
                final String fullWidthSpace = "\u3000";

        called.set(false);
        final AtomicBoolean calledFirst = new AtomicBoolean(false);
        queryProcessor.addFilter(new QueryProcessor.Filter() {
            @Override
            public QueryBuilder execute(QueryContext context, Query query, float boost, FilterChain chain) {
                calledFirst.set(true);
                assertFalse(called.get());

        // Test with boost = 0.5
        QueryBuilder queryBuilder1 = queryCommand.convertWildcardQuery(queryContext, wildcardQuery, 0.5f);
        assertNotNull(queryBuilder1);

        // Test with boost = 2.0
        QueryBuilder queryBuilder2 = queryCommand.convertWildcardQuery(queryContext, wildcardQuery, 2.0f);
        assertNotNull(queryBuilder2);

        // Test with boost = 0

        QueryContext context = new QueryContext("test", false);
        QueryBuilder result = booleanQueryCommand.convertBooleanQuery(context, booleanQuery, 1.0f);

        assertNull(result);
    }

    // Test convertBooleanQuery with null queryBuilder from processor
    @Test
    public void test_convertBooleanQuery_withNullQueryBuilder() {

        // Using template method
        QueryBuilder result1 = queryCommand.convertWithFieldCheck(fessConfig, context1, "title", "test", 1.0f,
                (field, boost) -> QueryBuilders.matchQuery(field, "test").boost(boost),
                (field, text, boost) -> QueryBuilders.matchQuery(field, text).boost(boost));

        // Manual implementation (for comparison)
        QueryBuilder result2;

        QueryContext context = new QueryContext("*:*", false);
        MatchAllDocsQuery query = new MatchAllDocsQuery();
        float boost = 1.0f;

        QueryBuilder result1 = matchAllQueryCommand.execute(context, query, boost);
        QueryBuilder result2 = matchAllQueryCommand.execute(context, query, boost);

        assertNotNull(result1);
        assertNotNull(result2);

import org.codelibs.fess.entity.QueryContext;
import org.codelibs.fess.exception.InvalidQueryException;
import org.junit.jupiter.api.Test;
import org.opensearch.index.query.FuzzyQueryBuilder;
import org.opensearch.index.query.QueryBuilder;

public class FuzzyQueryCommandTest extends QueryTestBase {

    private FuzzyQueryCommand fuzzyQueryCommand;

    @Override
    protected void setUpChild() throws Exception {

import org.codelibs.fess.entity.QueryContext;
import org.codelibs.fess.exception.InvalidQueryException;
import org.junit.jupiter.api.Test;
import org.opensearch.index.query.MatchPhraseQueryBuilder;
import org.opensearch.index.query.QueryBuilder;

public class PhraseQueryCommandTest extends QueryTestBase {
    private PhraseQueryCommand queryCommand;

    @Override
    protected void setUpChild() throws Exception {

                return oldDocList;
            }

            @Override
            public long deleteByQuery(final String index, final QueryBuilder queryBuilder) {
                if (queryBuilder instanceof final TermsQueryBuilder termsQueryBuilder) {
                    termsQueryBuilder.values().stream().forEach(o -> deletedDocIdList.add(o.toString()));
                }

        }

        public QueryBuilder buildQuery(String q, List<String> fields) {
            return createQueryBuilder().buildQuery(q, fields);
        }

        public QueryBuilder buildFilterQuery(String fieldName, List<String> words) {
            return createQueryBuilder().buildFilterQuery(fieldName, words);
        }