assertEquals(word, elevateWord.getElevateWord());
        assertEquals("ニホンゴテスト", elevateWord.getReadings().get(0));

        SuggestItem suggestItem = elevateWord.toSuggestItem();
        assertEquals(word, suggestItem.getText());
        assertArrayEquals(new String[] { "ニホンゴテスト" }, suggestItem.getReadings()[0]);
    }

    @Test
    public void testWithEmptyWord() {
        // Test with empty word string

        assertEquals(35L, item.getDocFreq());
        assertEquals(2.0f, item.getUserBoost(), 0.001f);
        assertEquals(2, item.getReadings().length);
        assertArrayEquals(new String[] { "reading1", "reading2" }, item.getReadings()[0]);
        assertArrayEquals(new String[] { "reading3" }, item.getReadings()[1]);
        assertEquals(1, item.getFields().length);
        assertEquals("field1", item.getFields()[0]);

            final List<String> list = new ArrayList<>();
            if (item1.getReadings().length > i) {
                Collections.addAll(list, item1.getReadings()[i]);
            }
            if (item2.getReadings().length > i) {
                for (final String reading : item2.getReadings()[i]) {
                    if (!list.contains(reading)) {
                        list.add(reading);

        final String normalizedWord = normalizer.normalize(elevateWord.getElevateWord(), "");
        final List<String> normalizedReadings =
                elevateWord.getReadings().stream().map(reading -> normalizer.normalize(reading, "")).collect(Collectors.toList());
        final ElevateWord normalized = new ElevateWord(normalizedWord, elevateWord.getBoost(), normalizedReadings, elevateWord.getFields(),

        final Map<String, Object> secondLine = new HashMap<>();

        secondLine.put("text", item.getText());

        // reading
        final String[][] readings = item.getReadings();
        for (int i = 0; i < readings.length; i++) {
            secondLine.put("reading_" + i, readings[i]);
        }

        secondLine.put("fields", item.getFields());

        assertEquals("text", tokens.get(1).getTerm());
        // Check that readings are added
        assertEquals("TEST", ((TestAnalyzeToken) tokens.get(0)).getReading());
        assertEquals("TEXT", ((TestAnalyzeToken) tokens.get(1)).getReading());
    }

    @Test
    public void testAnalyzeAndReadingWithEmptyText() {
        // Test analyzeAndReading with empty text
        String text = "";

        setupEpg(_epgMap, et -> ((ElevateWord) et).getPermissions(), (et, vl) -> ((ElevateWord) et).setPermissions((String[]) vl),
                "permissions");
        setupEpg(_epgMap, et -> ((ElevateWord) et).getReading(), (et, vl) -> ((ElevateWord) et).setReading(DfTypeUtil.toString(vl)),
                "reading");

        });

        for (final ElevateWord elevateWord : list) {
            addElevateWord(elevateWord.getSuggestWord(), elevateWord.getReading(), elevateWord.getLabelTypeValues(),
                    elevateWord.getPermissions(), elevateWord.getBoost(), apply);
        }
        refresh();
    }

    /**

            });
            return null;
        });
        try {
            elevateWordService.store(entity);
            suggestHelper.addElevateWord(entity.getSuggestWord(), entity.getReading(), entity.getLabelTypeValues(), entity.getPermissions(),
                    entity.getBoost(), false);
        } catch (final Exception e) {
            logger.warn("Failed to process a request.", e);

                            .sorted()
                            .collect(Collectors.joining(","));
                    addToList(list, entity.getSuggestWord());
                    addToList(list, entity.getReading());
                    addToList(list, permissions);
                    addToList(list, labels);
                    addToList(list, entity.getBoost());
                    try {