String[] fields = { "field1", "field2", "field1", "field3", "field2" };
        queryFieldConfig.setNotAnalyzedFields(fields);

        // Set should contain unique values only
        assertEquals(3, queryFieldConfig.notAnalyzedFieldSet.size());
        assertTrue(queryFieldConfig.notAnalyzedFieldSet.contains("field1"));
        assertTrue(queryFieldConfig.notAnalyzedFieldSet.contains("field2"));

        FessConfig fessConfig = new FessConfig.SimpleImpl() {
            @Override
            public String getQueryFacetFields() {
                return "field1, field2, field1, , field3, field2";
            }

            @Override
            public String getQueryFacetFieldsSize() {
                return "";
            }

            @Override

        assertTrue(result.contains("field1"));
        assertTrue(result.contains("exclude1"));
    }

    public void test_getCacheKey_sorting() {
        String seed = "test_seed";
        String[] tags = { "zzz", "aaa", "mmm" };
        String[] roles = { "role3", "role1", "role2" };
        String[] fields = { "field3", "field1", "field2" };

        request.setParameterValues("facet.field", new String[] { "field1" });

        FacetInfo facetInfo = searchRequestParams.createFacetInfo(request);
        assertNotNull(facetInfo);
        assertEquals(1, facetInfo.field.length);
        assertEquals("field1", facetInfo.field[0]);
        assertEquals(0, facetInfo.query.length);
        assertNull(facetInfo.size);

        facetQueryView.addQuery("label1", "field1:value1");
        facetQueryView.addQuery("label2", "field2:value2");

        facetQueryView.init();

        // Should not modify query map when no filetype queries present
        assertEquals(2, facetQueryView.getQueryMap().size());
        assertEquals("field1:value1", facetQueryView.getQueryMap().get("label1"));

    public void test_convertBooleanQuery_withShouldClause() {
        BooleanQuery.Builder boolQueryBuilder = new BooleanQuery.Builder();
        TermQuery termQuery1 = new TermQuery(new Term("field1", "value1"));
        TermQuery termQuery2 = new TermQuery(new Term("field2", "value2"));
        boolQueryBuilder.add(termQuery1, BooleanClause.Occur.SHOULD);
        boolQueryBuilder.add(termQuery2, BooleanClause.Occur.SHOULD);

        }
    }

    // Test annotation hashCode and equals behavior
    public void test_annotationHashCodeAndEquals() throws Exception {
        final Field field1 = UriTypeTest.class.getDeclaredField("testFieldWeb");
        final UriType annotation1 = field1.getAnnotation(UriType.class);

        final Field field2 = UriTypeTest.class.getDeclaredField("testFieldFile");

    }

    // Test addQuery with existing query
    public void test_addQuery_withExistingQuery() {
        queryContext = new QueryContext("test", false);
        QueryBuilder initialQuery = QueryBuilders.termQuery("field1", "value1");
        queryContext.setQueryBuilder(initialQuery);

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

        // Test executing BoostQuery with a BooleanQuery inside
        BooleanQuery.Builder boolBuilder = new BooleanQuery.Builder();
        boolBuilder.add(new TermQuery(new Term("field1", "value1")), BooleanClause.Occur.MUST);
        boolBuilder.add(new TermQuery(new Term("field2", "value2")), BooleanClause.Occur.SHOULD);
        BooleanQuery boolQuery = boolBuilder.build();

// JSON utilities with proper escaping
String escaped = JsonUtil.escape("Hello \"World\" with special chars");
String unescaped = JsonUtil.unescape(escaped);

// Text tokenization
Tokenizer tokenizer = new Tokenizer("field1,field2,field3", ",");
while (tokenizer.hasMoreTokens()) {
    String token = tokenizer.nextToken();
    // Process each token
}

// Decimal formatting