/**
     * Test convertWithFieldCheck() adds query text to context.
     */
    @Test
    public void test_convertWithFieldCheck_addsToContext() {
        FessConfig fessConfig = ComponentUtil.getFessConfig();
        QueryContext context = new QueryContext("test", true);

        String queryText = "search term";
        queryCommand.convertWithFieldCheck(fessConfig, context, "title", queryText, 1.0f,

     *
     * @param context the query context
     * @param termQuery the term query to convert
     * @param boost the boost value to apply
     * @return the converted QueryBuilder
     */
    protected QueryBuilder convertTermQuery(final QueryContext context, final TermQuery termQuery, final float boost) {
        final String field = getSearchField(context.getDefaultField(), termQuery.getTerm().field());

        QueryBuilder result = fuzzyQueryCommand.convertFuzzyQuery(context, fuzzyQuery, 1.0f);
        assertNotNull(result);

    }

    // Test with various field names
    @Test
    public void test_convertFuzzyQuery_withVariousFields() {
        QueryContext context = new QueryContext("test", false);
        String[] fields = { "title", "content", "url", "site", "host", "mimetype" };

            String result = upgradeGoal.testDoUpgradeLogic(context, "4.0.0");

            assertEquals("4.0.0", result);
        }

        @Test
        @DisplayName("should prioritize explicit model over --all option")
        void shouldPrioritizeExplicitModelOverAllOption() {
            UpgradeContext context =

            when(mockStrategies.get(1).isApplicable(context)).thenReturn(true);
            when(mockStrategies.get(1).apply(Mockito.eq(context), Mockito.any()))
                    .thenReturn(UpgradeResult.empty());

            when(mockStrategies.get(2).isApplicable(context)).thenReturn(false);

            UpgradeResult result = orchestrator.executeStrategies(context, pomMap);

        boolQueryBuilder.add(termQuery, BooleanClause.Occur.MUST);
        BooleanQuery booleanQuery = boolQueryBuilder.build();

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

        assertNotNull(result);
        assertTrue(result instanceof BoolQueryBuilder);

        context.println();
        context.info(getDescription() + " Summary:");
        context.indent();
        context.info(result.modifiedCount() + " POM(s) modified");
        context.info(result.unmodifiedCount() + " POM(s) needed no changes");
        if (result.errorCount() > 0) {
            context.info(result.errorCount() + " POM(s) had errors");
        }
        context.unindent();
    }

        TermQuery termQuery = new TermQuery(term);
        BoostQuery boostQuery = new BoostQuery(termQuery, 2.5f);

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

        assertNotNull(result);
        // The result could be either a TermQueryBuilder or DefaultQueryBuilder depending on field configuration

        if (!result.errorPoms().isEmpty()) {
            context.failure("Strategy completed with errors");
            context.indent();
            context.info("Processed: " + result.processedPoms().size() + " POMs");
            context.info("Modified: " + result.modifiedPoms().size() + " POMs");
            context.failure("Errors: " + result.errorPoms().size() + " POMs");

        // Test with search field (content)
        PhraseQuery.Builder builder = new PhraseQuery.Builder();
        builder.add(new Term("content", "test"));
        PhraseQuery phraseQuery = builder.build();

        QueryContext context = new QueryContext("test", false);
        QueryBuilder result = queryCommand.convertPhraseQuery(context, phraseQuery, 1.0f);

        assertNotNull(result);