*/
    public long getTotal() {
        return total;
    }

    /**
     * Returns the list of suggested items.
     * @return The list of items.
     */
    public List<SuggestItem> getItems() {
        return items;
    }

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

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

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

                crawlingConfigHelper.getPipeline(configId).ifPresent(s -> builder.setPipeline(s));
            }
        });
        return asJson(new ApiBulkResponse().items(Arrays.stream(response.getItems()).map(item -> {
            final Map<String, Object> itemMap = new HashMap<>();
            itemMap.put("result", item.status().name());
            if (item.isFailed()) {

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

/**
 * Tests for the {@link AllocInfo} interface.
 * Since {@code AllocInfo} only declares getters, the tests focus on
 * verifying that implementations honour the contract.
 */
@ExtendWith(MockitoExtension.class)
public class AllocInfoTest {

    @Mock
    AllocInfo mockAllocInfo;

    /**
     * Happy path – verifies that getters return the values supplied by the
     * implementation.
     */
    @Test

            }
          }
        }
      }
    }
  }

  private void assertRelated(int groupNumber, int itemNumber, int relatedItemNumber) {
    Item<T> itemInfo = getItem(groupNumber, itemNumber);
    Item<T> relatedInfo = getItem(groupNumber, relatedItemNumber);

    T item = itemInfo.value;
    T related = relatedInfo.value;
    assertWithTemplate(
        "$ITEM must be $RELATIONSHIP to $OTHER",