.add("field27", Optional.absent())
            // Arrays
            .add("field31", new Object[] {"!!!"})
            .add("field32", new boolean[0])
            .add("field33", new byte[0])
            .add("field34", new char[0])
            .add("field35", new short[0])
            .add("field36", new int[0])
            .add("field37", new long[0])
            .add("field38", new float[0])

            stream.forEach(field -> {
                count.incrementAndGet();
                assertTrue(field.equals("field1") || field.equals("field2") || field.equals("field3"));
            });
        });

        assertEquals(3, count.get());
    }

    @Test
    public void test_highlightedFields_empty() {
        String[] fields = {};
        queryFieldConfig.setHighlightedFields(fields);

        String[] initialFields = { "field1", "field2" };
        queryFieldConfig.setSearchFields(initialFields);
        assertTrue(queryFieldConfig.searchFieldSet.contains("field1"));
        assertTrue(queryFieldConfig.searchFieldSet.contains("field2"));
        assertEquals(2, queryFieldConfig.searchFieldSet.size());

        // Update fields
        String[] updatedFields = { "field3", "field4", "field5" };

        facetInfo.size = 20;
        facetInfo.sort = "term.asc";

        String result = facetInfo.toString();
        assertEquals("FacetInfo [field=[field1], query=null, size=20, minDocCount=null, sort=term.asc, missing=null]", result);
    }

    // Test field assignment
    @Test
    public void test_fieldAssignment() {
        String[] fields = new String[] { "field1", "field2", "field3" };

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

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

        existingList.add("existing");
        fieldLogMap.put("field", existingList);
        getMockRequest().setAttribute(Constants.FIELD_LOGS, fieldLogMap);

        queryContext = new QueryContext("test", true);
        queryContext.addFieldLog("field", "new");

        List<String> list = fieldLogMap.get("field");
        assertEquals(2, list.size());
        assertEquals("existing", list.get(0));

        QueryBuilder fieldsFilter = request.buildFilterQuery("fields", Arrays.asList("field1"));

        assertTrue("Tags filter should contain 'tags'", tagsFilter.toString().contains("tags"));
        assertTrue("Roles filter should contain 'roles'", rolesFilter.toString().contains("roles"));
        assertTrue("Fields filter should contain 'fields'", fieldsFilter.toString().contains("fields"));
    }

                if (isExcludeSearchword(words[i], fields != null && fields.length > 0 ? fields[0] : "", langs, analyzer)) {
                    continue;
                }

                final String word = normalizer.normalize(words[i], fields != null && fields.length > 0 ? fields[0] : "", langs);
                final List<String> l = readingConverter.convert(word, fields != null && fields.length > 0 ? fields[0] : "", langs);

		if fieldStruct := modelType.Field(i); ast.IsExported(fieldStruct.Name) {
			if field := schema.ParseField(fieldStruct); field.EmbeddedSchema != nil {
				schema.Fields = append(schema.Fields, field.EmbeddedSchema.Fields...)
			} else {
				schema.Fields = append(schema.Fields, field)
			}
		}
	}

	for _, field := range schema.Fields {
		if field.DBName == "" && field.DataType != "" {

    dict[str, dict[str, Any]],
]:
    schema_generator = GenerateJsonSchema(ref_template=REF_TEMPLATE)
    validation_fields = [field for field in fields if field.mode == "validation"]
    serialization_fields = [field for field in fields if field.mode == "serialization"]
    flat_validation_models = get_flat_models_from_fields(
        validation_fields, known_models=set()
    )