QueryBuilder builder = queryProcessor.execute(context, prefixQuery, 10.0f);

        assertNotNull(builder);
        assertTrue(builder instanceof MatchPhrasePrefixQueryBuilder);

        // Query was processed with high boost
        MatchPhrasePrefixQueryBuilder mpqb = (MatchPhrasePrefixQueryBuilder) builder;
        assertEquals(10.0f, mpqb.boost());
    }

        ElevateWord elevateWord1 =
                new ElevateWord("a", 1.0f, Collections.singletonList("a"), Collections.singletonList("content"), null, null);
        ElevateWord elevateWord2 =
                new ElevateWord("b", 0.0f, Collections.singletonList("b"), Collections.singletonList("content"), null, null);
        ElevateWord elevateWord3 = new ElevateWord("c", 100.0f, Collections.singletonList("c"), Collections.singletonList("content"),

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

        assertNotNull(result);
        assertTrue(result instanceof MatchAllQueryBuilder);
        MatchAllQueryBuilder matchAllQueryBuilder = (MatchAllQueryBuilder) result;
        assertEquals(3.0f, matchAllQueryBuilder.boost());
    }

        assertNotNull(queryBuilder);
    }

    public void test_execute_withNonWildcardQuery() {
        QueryContext queryContext = new QueryContext("test", false);
        TermQuery termQuery = new TermQuery(new Term("title", "test"));

        try {
            queryCommand.execute(queryContext, termQuery, 1.0f);
            fail("Should throw InvalidQueryException");

        BooleanQuery booleanQuery = boolQueryBuilder.build();

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

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

        BoolQueryBuilder boolResult = (BoolQueryBuilder) result;
        assertTrue(boolResult.hasClauses());
    }

                new float[] {2.0f, 3.0f, 2.0f, 3.0f, 4.0f, 2.0f, 3.0f},
                new float[] {2.0f, 3.0f, 4.0f}))
        .isEqualTo(2);
    assertThat(
            Floats.indexOf(
                new float[] {2.0f, 2.0f, 3.0f, 4.0f, 2.0f, 3.0f, 4.0f},
                new float[] {2.0f, 3.0f, 4.0f}))
        .isEqualTo(1);
    assertThat(Floats.indexOf(new float[] {4.0f, 3.0f, 2.0f}, new float[] {2.0f, 3.0f, 4.0f}))
        .isEqualTo(-1);

                new float[] {2.0f, 3.0f, 2.0f, 3.0f, 4.0f, 2.0f, 3.0f},
                new float[] {2.0f, 3.0f, 4.0f}))
        .isEqualTo(2);
    assertThat(
            Floats.indexOf(
                new float[] {2.0f, 2.0f, 3.0f, 4.0f, 2.0f, 3.0f, 4.0f},
                new float[] {2.0f, 3.0f, 4.0f}))
        .isEqualTo(1);
    assertThat(Floats.indexOf(new float[] {4.0f, 3.0f, 2.0f}, new float[] {2.0f, 3.0f, 4.0f}))
        .isEqualTo(-1);

        Term term = new Term("title", "fuzzy");
        FuzzyQuery fuzzyQuery = new FuzzyQuery(term);

        // Test with different boost values
        float[] boostValues = { 0.5f, 1.0f, 2.5f, 10.0f };
        for (float boost : boostValues) {
            QueryBuilder result = queryProcessor.execute(context, fuzzyQuery, boost);
            assertNotNull(result);

        // Test document frequency
        item.setDocFreq(150L);
        assertEquals(150L, item.getDocFreq());

        // Test user boost
        item.setUserBoost(2.0f);
        assertEquals(2.0f, item.getUserBoost(), 0.001f);

        // Test readings
        String[][] newReadings = { { "read1", "read2" }, { "read3" } };
        item.setReadings(newReadings);

        Query termQuery = new TermQuery(new Term("field", "value"));
        QueryContext context = new QueryContext("test", false);

        try {
            queryCommand.execute(context, termQuery, 1.0f);
            fail("Should throw InvalidQueryException for non-phrase query");
        } catch (InvalidQueryException e) {
            assertTrue(e.getMessage().contains("Unknown q:"));
        }
    }