assertEquals("word3", stopwordsFile.stopwordsItemList.get(2).getInput());
    }

    @Test
    public void test_reload_withEscapedCharacters() {
        String content = "word\\\\1\n" + // word\1
                "word\\\\\\\\2\n" + // word\\2
                "word3\n";

        InputStream is = new ByteArrayInputStream(content.getBytes(StandardCharsets.UTF_8));

                parser.parseSearchWords(words, null, fields, null, null, 1, defaultReadingConverter, defaultNormalizer, analyzer, null);

        assertNotNull(item);
        assertEquals("test", item.getText());
    }

    @Test
    public void test_parseSearchWords_withPartialReadings() throws Exception {
        String[] words = new String[] { "word1", "word2", "word3" };
        // Only provide readings for first word

        StopwordsItem item = new StopwordsItem(123, "word");
        assertEquals("StopwordsItem [id=123, inputs=word, newInputs=null]", item.toString());

        item.setNewInput("updated");
        assertEquals("StopwordsItem [id=123, inputs=word, newInputs=updated]", item.toString());

        item.setNewInput("");
        assertEquals("StopwordsItem [id=123, inputs=word, newInputs=]", item.toString());
    }

    @Test

                final String[] words = SuggestUtil.parseQuery(queryString, field);
                if (words.length == 0) {
                    continue;
                }

                final String[][] readings = new String[words.length][];
                for (int j = 0; j < words.length; j++) {
                    words[j] = normalizer.normalize(words[j], field, "");

 *
 * <p>This class acts as a facade, delegating to internal operation classes for the actual work:
 * <ul>
 * <li>{@code IndexingOperations} - Core indexing functionality with bad word filtering</li>
 * <li>{@code DeletionOperations} - Deletion by ID, query, or kind</li>
 * <li>{@code WordManagementOperations} - Bad word and elevate word management</li>

errors.invalid_query_sort_value = De opgegeven sorteerwaarde {0} is ongeldig.
errors.invalid_query_unsupported_sort_field = Het opgegeven sorteerveld {0} wordt niet ondersteund.
errors.invalid_query_unsupported_sort_order = De opgegeven sorteervolgorde {0} wordt niet ondersteund.
errors.invalid_query_cannot_process=Kan de opgegeven query niet verwerken.
errors.crud_invalid_mode = Ongeldige modus. (Is {1}, niet {0})

                firstItems);
    }

    /**
     * Checks if the first word matches.
     * @param singleWordQuery True if it is a single word query.
     * @param hiraganaQuery True if it is a hiragana query.
     * @param text The text to check.
     * @return True if the first word matches, false otherwise.
     */

    /**
     * Sets whether to match the first word.
     * @param matchWordFirst True to match the first word, false otherwise.
     */
    public void setMatchWordFirst(final boolean matchWordFirst) {
        this.matchWordFirst = matchWordFirst;
    }

    /**
     * Sets whether to skip duplicate words.
     * @param skipDuplicateWords True to skip duplicate words, false otherwise.
     */

class Prompt(BaseModel):
    text: str


@app.post("/chat/stream", response_class=EventSourceResponse)
async def stream_chat(prompt: Prompt) -> AsyncIterable[ServerSentEvent]:
    words = prompt.text.split()
    for word in words:
        yield ServerSentEvent(data=word, event="token")

    // ============================================================

    @Test
    public void test_buildFilterQuery_singleWord() {
        List<String> words = Collections.singletonList("tag1");
        QueryBuilder result = request.buildFilterQuery("tags", words);
        assertNotNull(result);
        assertTrue(result instanceof BoolQueryBuilder);

        String queryString = result.toString();