// 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;

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

    // Test addFunctionScore
    @Test
    public void test_addFunctionScore() {
        queryContext = new QueryContext("test", false);

                    called.set(true);
                    return QueryBuilders.boolQuery();
                };
            }
        };
        queryProcessor.init();

        QueryContext context = new QueryContext(null, false);
        MatchAllDocsQuery query = new MatchAllDocsQuery();

        QueryBuilder queryBuilder = queryProcessor.execute(context, query, 1.0f);
        assertTrue(called.get());

    }

    // Test query() method
    @Test
    public void test_query() {
        QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
        UpdateLabelJob returnedJob = updateLabelJob.query(queryBuilder);

        assertSame(updateLabelJob, returnedJob); // Method chaining
        assertEquals(queryBuilder, updateLabelJob.queryBuilder);
    }

    // Test query() method with null
    @Test

                .should(QueryBuilders.fuzzyQuery("title", query).boost(0.01f).maxExpansions(10))//
                .should(QueryBuilders.fuzzyQuery("content", query).boost(0.005f).maxExpansions(10))//
        ;
    }

    private QueryBuilder functionScoreQuery(QueryBuilder queryBuilder) {
        return QueryBuilders.functionScoreQuery(queryBuilder, ScoreFunctionBuilders.fieldValueFactorFunction("boost"));
    }

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.query;

import org.codelibs.fess.unit.UnitFessTestCase;
import org.junit.jupiter.api.Test;
import org.opensearch.index.query.QueryBuilders;

public class DefaultQueryBuilderTest extends UnitFessTestCase {
    @Test
    public void test_invalid_null() {
        try {
            new DefaultQueryBuilder(null);
            fail();

import org.lastaflute.core.mail.Postbox;
import org.opensearch.action.bulk.BulkRequestBuilder;
import org.opensearch.action.search.SearchResponse;
import org.opensearch.index.query.QueryBuilders;
import org.opensearch.search.SearchHit;
import org.opensearch.search.sort.SortOrder;

/**
 * Job for sending log notifications.
 */
public class LogNotificationJob {

    /**

        final String result = indexExportJob.format("json").query(QueryBuilders.matchAllQuery()).execute();

        assertEquals("Exported 0 documents.", result);
    }

    @Test
    public void test_execute_queryAndFormatChaining() {
        setupMockComponents(Collections.emptyList());

        final String result = indexExportJob.query(QueryBuilders.matchAllQuery()).format("json").execute();

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

        final IndexExportFormatter resolvedFormatter =
                this.formatter != null ? this.formatter : createFormatter(fessConfig.getIndexExportFormat());

        final QueryBuilder query = queryBuilder != null ? queryBuilder : QueryBuilders.matchAllQuery();

        if (logger.isInfoEnabled()) {
            logger.info("[EXPORT] Starting index export: path={}, scrollSize={}, excludeFields={}, query={}", exportPath, scrollSize,