testData2.add(createRelatedQuery("term2", new String[] { "query2" }, ""));
        mockBhv.setTestData(testData2);

        relatedQueryHelper.load();

        // Old term should not be found
        results = relatedQueryHelper.getRelatedQueries("term1");
        assertEquals(0, results.length);

        // New term should be found

        testData.add(createRelatedContent("term1", "content1", ""));
        testData.add(createRelatedContent("term2", "content2", "host1"));
        mockBhv.setTestData(testData);

        List<RelatedContent> result = relatedContentHelper.getAvailableRelatedContentList();
        assertEquals(2, result.size());
        assertEquals("term1", result.get(0).getTerm());
        assertEquals("term2", result.get(1).getTerm());
    }

    @Test

            QueryBuilder result = fuzzyQueryCommand.convertFuzzyQuery(context, fuzzyQuery, 1.0f);
            assertNotNull(result);
            assertTrue(result.toString().contains(text));

        }
    }

    // Test with empty term text
    @Test
    public void test_convertFuzzyQuery_withEmptyTerm() {
        QueryContext context = new QueryContext("test", false);
        Term term = new Term("title", "");

        // Test with BooleanQuery
        BooleanQuery.Builder builder = new BooleanQuery.Builder();
        Term term1 = new Term("content", "test");
        Term term2 = new Term("title", "query");
        builder.add(new TermQuery(term1), BooleanClause.Occur.SHOULD);
        builder.add(new TermQuery(term2), BooleanClause.Occur.SHOULD);
        BooleanQuery booleanQuery = builder.build();

    /** CRUD operation mode (CREATE, EDIT, etc.) */
    @ValidateTypeFailure
    public Integer crudMode;

    /** Input terms (comma-separated) that will be mapped to the output term */
    @Required
    @Size(max = 1000)
    public String inputs;

    /** Output term that input terms will be mapped to */
    @Size(min = 1, max = 1000)
    public String output;

    /**

                return queries;
            }
        }
        return StringUtil.EMPTY_STRINGS;
    }

    private String toLowerCase(final String term) {
        return term != null ? term.toLowerCase(Locale.ROOT) : term;
    }

        final Term[] terms = phraseQuery.getTerms();
        if (terms.length == 0) {
            throw new InvalidQueryException(messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),
                    "Unknown phrase query: " + phraseQuery);
        }
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        final String field = terms[0].field();

### List of English terms and their preferred German translations

    }

    @Test
    public void test_convertPhraseQuery_multipleTerms_defaultField() {
        // Test with multiple terms in default field
        PhraseQuery.Builder builder = new PhraseQuery.Builder();
        builder.add(new Term(Constants.DEFAULT_FIELD, "hello"));
        builder.add(new Term(Constants.DEFAULT_FIELD, "world"));
        PhraseQuery phraseQuery = builder.build();

- Use the same translation for the same term throughout the document.
- If you translate a concept one way, keep it consistent across all occurrences.

### Links and references

- Never modify link syntax like `{.internal-link target=_blank}`.
- Keep markdown link structure intact: `[text](url){.internal-link}`.

### Preferred translations / glossary