* @return A SuggesterBuilder instance.
     */
    public static SuggesterBuilder builder() {
        return new SuggesterBuilder();
    }

    // getter
    /**
     * Returns the SuggestSettings instance.
     * @return The SuggestSettings instance.
     */
    public SuggestSettings settings() {
        return suggestSettings;
    }

    /**

            for (Entry<Range<Integer>, Integer> entry : rangeMap.asMapOfRanges().entrySet()) {
              if (entry.getKey().isConnected(subRange)
                  && !entry.getKey().intersection(subRange).isEmpty()) {
                expectedBuilder.put(entry.getKey().intersection(subRange), entry.getValue());
              }
            }

    assertThat(entry.getKey()).isEqualTo("foo");
    assertThat(entry.getValue()).containsExactly(5, 3).inOrder();
    entry = collectionIterator.next();
    assertThat(entry.getKey()).isEqualTo("bar");
    assertThat(entry.getValue()).containsExactly(4, 1).inOrder();
    entry = collectionIterator.next();
    assertThat(entry.getKey()).isEqualTo("cow");
    assertThat(entry.getValue()).contains(2);

                    final Boolean b = (Boolean) xObj.value();
                    putResultDataBody(dataMap, entry.getKey(), b.toString());
                    break;
                case NUMBER:
                    final Number d = (Number) xObj.value();
                    putResultDataBody(dataMap, entry.getKey(), d.toString());
                    break;
                case STRING:

    Iterator<Entry<K, V>> iterator = multimap().entries().iterator();
    Entry<K, V> entry = iterator.next();
    K key = entry.getKey();
    V value = entry.getValue();
    multimap().removeAll(key);
    assertEquals(key, entry.getKey());
    assertEquals(value, entry.getValue());
  }

        valueMap.put("user", user.map(FessUserBean::getUserId).orElse("-"));
        final Comparator<Map.Entry<String, String>> c = Comparator.comparing(Map.Entry::getKey);
        params.entrySet().stream().sorted(c).forEach(e -> {
            valueMap.put(e.getKey(), e.getValue().replace('\t', '_'));
        });
        log(valueMap);
    }

    /**
     * Log the value map.
     * @param valueMap The value map.

    assertThrows(
        IllegalArgumentException.class,
        () -> Stream.of(mapEntry("one", 1), mapEntry("one", 11)).collect(collector));
  }

  public void testToImmutableSortedMapMerging() {
    Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector =
        toImmutableSortedMap(Entry::getKey, Entry::getValue, Integer::sum);

        json.append("{\n");

        boolean first = true;
        for (final Map.Entry<String, Object> entry : source.entrySet()) {
            final String field = entry.getKey();
            if (excludeFields.contains(field)) {
                continue;
            }

            final Object value = entry.getValue();
            if (value == null) {
                continue;

        FieldUtil.set(field, this, Integer.valueOf(testData));
        assertThat(FieldUtil.getInt(field, this), is(testData));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetIntFieldObject() throws Exception {
        final Field field = getClass().getField("INT_DATA");
        assertThat(FieldUtil.getInt(field), is(INT_DATA));
    }

    /**
     * @throws Exception
     */
    @Test

            Metadata metadata = it.next();
            if (metadata instanceof VersionsMetadata versionsMetadata) {
                it.remove();
                processedVersions.put(versionsMetadata.getKey(), versionsMetadata);
            }
        }
    }

    @Override
    public Collection<? extends Metadata> prepare(Collection<? extends Artifact> artifacts) {
        return Collections.emptyList();
    }