*/
    public PhraseQueryCommand() {
        super();
    }

    private static final Logger logger = LogManager.getLogger(PhraseQueryCommand.class);

    @Override
    protected String getQueryClassName() {
        return PhraseQuery.class.getSimpleName();
    }

    @Override
    public QueryBuilder execute(final QueryContext context, final Query query, final float boost) {

    /**
     * Default constructor.
     */
    public FuzzyQueryCommand() {
        super();
    }

    @Override
    protected String getQueryClassName() {
        return FuzzyQuery.class.getSimpleName();
    }

    /**
     * Executes the fuzzy query command to convert a Lucene FuzzyQuery into an OpenSearch QueryBuilder.
     *

        super.tearDown(testInfo);
    }

    @Test
    public void test_getQueryClassName() {
        // Test that getQueryClassName returns the correct class name
        String className = matchAllQueryCommand.getQueryClassName();
        assertEquals("MatchAllDocsQuery", className);
        assertEquals(MatchAllDocsQuery.class.getSimpleName(), className);
    }

    @Test

        @Override
        public QueryBuilder execute(QueryContext context, Query query, float boost) {
            return QueryBuilders.matchAllQuery();
        }

        @Override
        protected String getQueryClassName() {
            return "TestQuery";
        }

        // Expose protected methods for testing
        @Override
        public boolean isSearchField(String field) {

        fuzzyQueryCommand = new FuzzyQueryCommand();
        fuzzyQueryCommand.register();
    }

    // Test getQueryClassName method
    @Test
    public void test_getQueryClassName() {
        assertEquals("FuzzyQuery", fuzzyQueryCommand.getQueryClassName());
    }

    // Test execute method with valid FuzzyQuery
    @Test
    public void test_execute_withFuzzyQuery() {

            @Override
            public QueryBuilder execute(QueryContext context, Query query, float boost) {
                return null;
            }

            @Override
            protected String getQueryClassName() {
                return null;
            }
        };
    }

    @Test
    public void test_buildMatchPhraseQuery() {
        assertQueryBuilder("test", "", MatchPhraseQueryBuilder.class);

        assertEquals("test日本語", queryCommand.toLowercaseWildcard("TEST日本語"));
    }

    @Test
    public void test_getQueryClassName() {
        assertEquals("WildcardQuery", queryCommand.getQueryClassName());
    }

    @Test
    public void test_setLowercaseWildcard() {
        // Test default value
        assertTrue(queryCommand.lowercaseWildcard);

        // Test setting to false

        queryCommand = new TermRangeQueryCommand();
        queryCommand.register();
    }

    @Test
    public void test_getQueryClassName() {
        assertEquals("TermRangeQuery", queryCommand.getQueryClassName());
    }

    @Test
    public void test_execute_withInvalidQuery() {
        try {
            QueryContext context = new QueryContext("test", false);

        }
        queryFieldConfig.notAnalyzedFieldSet = notAnalyzedFieldSet;
    }

    @Test
    public void test_getQueryClassName() {
        assertEquals("PrefixQuery", queryCommand.getQueryClassName());
    }

    @Test
    public void test_execute_withInvalidQuery() {
        QueryContext context = new QueryContext("test", false);
        TermQuery termQuery = new TermQuery(new Term("field", "value"));

        queryCommand = new PhraseQueryCommand();
        queryCommand.register();
    }

    @Test
    public void test_getQueryClassName() {
        assertEquals("PhraseQuery", queryCommand.getQueryClassName());
    }

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