SuggestResponse response = new SuggestResponse("test-index", 100, words, 10, items);

        assertNotNull(response.getItems());
        assertEquals(2, response.getItems().size());
    }

    @Test
    public void test_emptyResponse() throws Exception {
        List<String> words = new ArrayList<>();
        List<SuggestItem> items = new ArrayList<>();

        final SuggestWriterResult result = new SuggestWriterResult();
        if (response.hasFailures()) {
            for (final BulkItemResponse bulkItemResponses : response.getItems()) {
                if (bulkItemResponses.isFailed()) {
                    result.addFailure(new SuggestIndexException("Bulk failure. " + bulkItemResponses.getFailureMessage()));
                }
            }
        }

        SuggestResponse response = suggester.suggest().setQuery("test").setSuggestDetail(true).execute().getResponse();

        assertNotNull(response);
        if (response.getNum() > 0) {
            assertNotNull(response.getItems());
        }
    }

    @Test
    public void test_chainedBuilder() throws Exception {
        indexItems();

        SuggestResponse response = suggester.suggest()
                .setQuery("test")

                stream(baseExcludes).of(stream -> stream.forEach(exclude -> popularWordsRequestBuilder.addExcludeWord(exclude)));
                try {
                    popularWordsRequestBuilder.execute().getResponse().getItems().stream().forEach(item -> wordList.add(item.getText()));
                } catch (final SuggesterException e) {
                    logger.warn("Failed to generate popular words.", e);
                }

        indexQueryItems();

        PopularWordsResponse response = suggester.popularWords().setSize(10).execute().getResponse();

        assertNotNull(response);
        assertNotNull(response.getItems());
    }

    @Test
    public void test_buildQuery() throws Exception {
        PopularWordsRequest request = new PopularWordsRequest();
        request.setIndex("test-index");

            buf.append(",\"page_size\":").append(suggestResponse.getNum());

            if (!suggestResponse.getItems().isEmpty()) {
                buf.append(",\"data\":[");

                boolean first = true;
                for (final SuggestItem item : suggestResponse.getItems()) {
                    if (!first) {
                        buf.append(',');
                    }

        suggester.refresh();

        final SuggestResponse response = suggester.suggest().setQuery("検索").setSuggestDetail(true).execute().getResponse();
        final List<SuggestItem> items = response.getItems();
        assertEquals(1, response.getNum());
        assertEquals("検索 エンジン", items.get(0).getText());
    }

    @Test
    public void test_indexFromSearchWordExclude() throws Exception {

            builderCall.callback(bulkBuilder);
        }

        final BulkResponse response = bulkBuilder.execute().actionGet(bulkTimeout);
        final BulkItemResponse[] itemResponses = response.getItems();
        if (itemResponses.length != entityList.size()) {
            throw new IllegalStateException("Invalid response size: " + itemResponses.length + " != " + entityList.size());
        }

            builderCall.callback(bulkBuilder);
        }

        final BulkResponse response = bulkBuilder.execute().actionGet(bulkTimeout);
        final BulkItemResponse[] itemResponses = response.getItems();
        if (itemResponses.length != entityList.size()) {
            throw new IllegalStateException("Invalid response size: " + itemResponses.length + " != " + entityList.size());
        }

    protected String buildFailureMessage(final BulkResponse bulkResponse, final boolean ignoreAlreadyExists) {
        final StringBuilder sb = new StringBuilder(100);
        final BulkItemResponse[] responses = bulkResponse.getItems();
        for (int i = 0; i < responses.length; i++) {
            final BulkItemResponse response = responses[i];
            if (response.isFailed()) {
                if (ignoreAlreadyExists) {