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<>();

        PopularWordsResponse response = new PopularWordsResponse("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<>();

        when(evaluator.evaluate("item1")).thenReturn("item1");

        helper.setProperty(bean, "item", String.class, config);

        assertEquals(1, bean.getItems().size());
        assertEquals("item1", bean.getItems().get(0));
    }

    @Test
    void testPerformanceWithRepeatedCalls() throws Exception {
        TestBean bean1 = new TestBean();
        TestBean bean2 = new TestBean();

SuggestResponse response = suggester.suggest()
    .setQuery("sea")                    // user input
    .setSize(10)                        // max suggestions
    .execute()
    .getResponse();

// Process suggestions
response.getItems().forEach(item -> {
    System.out.println("Suggestion: " + item.getText()[0]);
    System.out.println("Score: " + item.getScore());
});
```

#### 4. Asynchronous Suggestions

```java

        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()));
                }
            }
        }

        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");

        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")

     * @return true if the registration is expired
     */
    public boolean isExpired(long timeoutMs) {
        return System.currentTimeMillis() - lastHeartbeat > timeoutMs;
    }

    // Getters and setters

    /**
     * Gets the last heartbeat timestamp.
     *
     * @return the last heartbeat timestamp in milliseconds
     */
    public long getLastHeartbeat() {
        return lastHeartbeat;
    }

        assertEquals(0L, controller.getDelayMillisBeforeProcessing());
        assertEquals(1000L, controller.getDelayMillisForWaitingNewUrl());
    }

    /**
     * Test setters
     */
    public void test_setters() {
        final DefaultIntervalController controller = new DefaultIntervalController();

        controller.setDelayMillisAfterProcessing(111L);

                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);
                }