return response;
    }

    /**
     * Deletes a bad word.
     * @param badWord The bad word to delete.
     */
    public void deleteBadWord(final String badWord) {
        ensureOperations();
        wordMgmtOps.deleteBadWord(badWord);
    }

    /**
     * Adds an elevate word.
     * @param elevateWord The elevate word to add.

        refresh();
    }

    /**
     * Deletes a bad word from the suggest index.
     *
     * @param badWord The bad word to delete.
     */
    public void deleteBadWord(final String badWord) {
        suggester.indexer().deleteBadWord(badWord);
        refresh();
    }

    /**
     * Refreshes the suggest index.
     */
    public synchronized void refresh() {
        suggester.refresh();

        }
        return new SuggestDeleteResponse(null, 0);
    }

    /**
     * Deletes a bad word.
     *
     * @param badWord The bad word to delete
     */
    public void deleteBadWord(final String badWord) {
        settings.badword().delete(normalizer.normalize(badWord, ""));
    }

    /**
     * Adds an elevate word.
     *
     * @param index The index name

            assertTrue(true);
        } catch (Exception e) {
            assertTrue(true);
        }
    }

    @Test
    public void test_deleteBadWord() {
        try {
            suggestHelper.deleteBadWord("badword");
            assertTrue(true);
        } catch (Exception e) {
            assertTrue(true);
        }
    }

    @Test
    public void test_refresh() {
        try {

        assertEquals(1, response3.getNum());

        assertEquals(2, suggester.settings().badword().get(false).length);
        suggester.indexer().deleteBadWord("[");
        suggester.indexer().deleteBadWord("ｴﾝｼﾞﾝ");
        assertEquals(0, suggester.settings().badword().get(false).length);
    }

    @Test
    public void test_popularWords() throws Exception {

        assertFalse(response.hasError());
    }

    @Test
    public void test_deleteNonExistentBadWord() throws Exception {
        // Should not throw
        suggester.indexer().deleteBadWord("non-existent");
    }

    @Test
    public void test_restoreElevateWordOnEmpty() throws Exception {
        SuggestIndexResponse response = suggester.indexer().restoreElevateWord();

        suggester.indexer().addBadWord("badword", false);

        String[] badWords = suggester.settings().badword().get(false);
        assertTrue(badWords.length > 0);

        suggester.indexer().deleteBadWord("badword");

        badWords = suggester.settings().badword().get(false);
        assertEquals(0, badWords.length);
    }

    @Test
    public void test_addElevateWord() throws Exception {

        try {
            badWordService.getBadWord(id).ifPresent(entity -> {
                try {
                    badWordService.delete(entity);
                    suggestHelper.deleteBadWord(entity.getSuggestWord());
                    saveInfo(messages -> messages.addSuccessCrudDeleteCrudTable(GLOBAL));
                } catch (final Exception e) {

        final String id = form.id;
        badWordService.getBadWord(id).ifPresent(entity -> {
            try {
                badWordService.delete(entity);
                suggestHelper.deleteBadWord(entity.getSuggestWord());
                saveInfo(messages -> messages.addSuccessCrudDeleteCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);