return sources;
    }

    public static void appendFile(File file, String name, String type, StringBuilder output) {
        String text = FileUtils.read(file, "UTF-8");
        if (text.trim().isEmpty()) {
            return;
        }
        appendText(text, name, type, output);
    }

    public static void appendText(String text, final String name, final String type, StringBuilder output) {

                10, (hit, accumulator) -> accumulator.add(hit.getId()));

        assertNotNull(results);
        assertTrue(results.isEmpty());
    }

    @Test
    public void testScrollSearch_singlePage() {
        createTestIndex();
        indexDocuments(5);
        runner.refresh();

        List<String> results =

    noElementSplitFunction: (Int) -> List<R> = { throw IllegalArgumentException("More buckets than things to split") },
    canRunTogether: (T, T) -> Boolean = { _, _ -> true },
): List<R> {
    if (list.isEmpty()) {
        return noElementSplitFunction(expectedBucketNumber)
    }
    if (expectedBucketNumber == 1) {
        return listOf(smallElementAggregateFunction(list))
    }

  }

  static String formatCompact4Digits(double value) {
    return String.format(Locale.ROOT, "%.4g", value);
  }

  static boolean stringIsNullOrEmpty(@Nullable String string) {
    return string == null || string.isEmpty();
  }

  /**
   * Returns the string if it is not null, or an empty string otherwise.
   *
   * @param string the string to test and possibly return
   * @return {@code string} if it is not null; {@code ""} otherwise

    ImmutableList.Builder<List<E>> axesBuilder = new ImmutableList.Builder<>(lists.size());
    for (List<? extends E> list : lists) {
      List<E> copy = ImmutableList.copyOf(list);
      if (copy.isEmpty()) {
        return ImmutableList.of();
      }
      axesBuilder.add(copy);
    }
    return new CartesianList<>(axesBuilder.build());
  }

  CartesianList(ImmutableList<List<E>> axes) {
    this.axes = axes;

        assertNotNull(result);
        assertTrue(result.isEmpty());
    }

    @Test
    public void test_parseJson_invalid() {
        final Map<String, Object> result = coordinatorHelper.parseJson("invalid json");
        assertNotNull(result);
        assertTrue(result.isEmpty());
    }

    @Test
    public void test_parseJson_null() {

        final ListResultBean<FileConfig> list = fileConfigBhv.selectList(cb -> {
            cb.query().setName_Equal(name);
            cb.query().addOrderBy_SortOrder_Asc();
        });
        if (list.isEmpty()) {
            return OptionalEntity.empty();
        }
        return OptionalEntity.of(list.get(0));
    }

    /**
     * Stores a file configuration in the database.

        getDocumentationRoot().getAsFileTree().matching(spec -> spec.include("**/*.adoc")).forEach(file -> {
            gatherBadSnippetsInFile(file, errors);
        });

        if (!errors.isEmpty()) {
            StringBuilder sb = new StringBuilder("Found reversed multi-language snippet order in AsciiDoc files:\n");
            for (Map.Entry<File, List<Error>> e : errors.entrySet()) {

    }

    @Test
    public void test_defaultConstructor() {
        final LlmChatRequest request = new LlmChatRequest();
        assertNotNull(request.getMessages());
        assertTrue(request.getMessages().isEmpty());
        assertNull(request.getModel());
        assertNull(request.getMaxTokens());
        assertNull(request.getTemperature());
        assertFalse(request.isStream());
    }

    @Test

    }

    @Override
    public boolean containsAll(Collection<?> collection) {
      return standardContainsAll(collection);
    }

    @Override
    public boolean isEmpty() {
      return standardIsEmpty();
    }

    @Override
    public Iterator<E> iterator() {
      return standardIterator();
    }

    @Override