@Override
    public QueryBuilder execute(final QueryContext context, final Query query, final float boost) {
        if (logger.isDebugEnabled()) {
            logger.debug("MatchAllQuery: query={}, boost={}", query, boost);
        }
        return QueryBuilders.matchAllQuery().boost(boost);
    }

    @Test
    public void test_execute_withMatchAllDocsQuery() {
        BooleanQuery.Builder boolQueryBuilder = new BooleanQuery.Builder();
        MatchAllDocsQuery matchAllQuery = new MatchAllDocsQuery();
        boolQueryBuilder.add(matchAllQuery, BooleanClause.Occur.MUST);
        BooleanQuery booleanQuery = boolQueryBuilder.build();

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

    }

    @Test
    public void test_execute_withMatchAllDocsQuery() {
        // Test executing BoostQuery with a MatchAllDocsQuery inside
        MatchAllDocsQuery matchAllQuery = new MatchAllDocsQuery();
        BoostQuery boostQuery = new BoostQuery(matchAllQuery, 3.0f);

        QueryContext context = new QueryContext("test", false);
        QueryBuilder result = queryProcessor.execute(context, boostQuery, 1.0f);

        assertNotNull(result);
        assertTrue("Empty query should produce MatchAllQuery", result instanceof MatchAllQueryBuilder);
    }

    @Test
    public void test_buildQuery_nullQuery() {
        QueryBuilder result = request.buildQuery(null, Collections.emptyList());
        assertNotNull(result);
        assertTrue("Null query should produce MatchAllQuery", result instanceof MatchAllQueryBuilder);
    }

    @Test

    // Test addQuery with MatchAllQueryBuilder
    @Test
    public void test_addQuery_withMatchAllQuery() {
        queryContext = new QueryContext("test", false);
        queryContext.setQueryBuilder(QueryBuilders.matchAllQuery());

        queryContext.addQuery(boolQuery -> {
            boolQuery.must(QueryBuilders.termQuery("field", "value"));
        });

        QueryBuilder result = queryContext.getQueryBuilder();

        // Create index without any documents
        createTestIndex();

        List<String> results = ScrollOperationHelper.scrollSearch(client, suggester.settings(), INDEX_NAME, QueryBuilders.matchAllQuery(),
                10, (hit, accumulator) -> accumulator.add(hit.getId()));

        assertNotNull(results);
        assertTrue(results.isEmpty());
    }

    @Test

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

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

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

        } catch (IllegalArgumentException e) {
            // nothing
        }
    }

    @Test
    public void test_invalid_query() {
        try {
            new DefaultQueryBuilder(QueryBuilders.matchAllQuery());
            fail();
        } catch (IllegalArgumentException e) {
            // nothing
        }
    }

            return null;
        }).when(mockClearScrollBuilder).execute(any(ActionListener.class));

        final int deleted = fesenClient.deleteByQuery("test-index", QueryBuilders.matchAllQuery());

        assertEquals(1, deleted);
        verify(mockClearScrollBuilder, times(1)).addScrollId("scroll1");
    }

    /**
     * Test: deleteByQuery deprecated method delegates to new method

        if (ORDER_RANDOM.equals(crawlOrder)) {
            return getList(OpenSearchUrlQueue.class, sessionId,
                    QueryBuilders.functionScoreQuery(QueryBuilders.matchAllQuery(),
                            new FunctionScoreQueryBuilder.FilterFunctionBuilder[] { new FunctionScoreQueryBuilder.FilterFunctionBuilder(