}, (builder, hit) -> {
                try {
                    final Map<String, Object> doc = hit.getSourceAsMap();
                    final String url = DocumentUtil.getValue(doc, fessConfig.getIndexFieldUrl(), String.class);
                    if (StringUtil.isNotBlank(url)) {
                        final Set<String> labelSet = labelTypeHelper.getMatchedLabelValueSet(url);

    K key = secondEntry.getKey();
    SortedMap<K, V> subMap = map.tailMap(key);
    V value = getValueNotInPopulatedMap();
    subMap.put(key, value);
    assertEquals(secondEntry.getValue(), value);
    assertEquals(map.get(key), value);
    assertThrows(IllegalArgumentException.class, () -> subMap.put(firstEntry.getKey(), value));
  }

  public void testTailMapRemoveThrough() {
    SortedMap<K, V> map;

    K key = secondEntry.getKey();
    SortedMap<K, V> subMap = map.tailMap(key);
    V value = getValueNotInPopulatedMap();
    subMap.put(key, value);
    assertEquals(secondEntry.getValue(), value);
    assertEquals(map.get(key), value);
    assertThrows(IllegalArgumentException.class, () -> subMap.put(firstEntry.getKey(), value));
  }

  public void testTailMapRemoveThrough() {
    SortedMap<K, V> map;

                            .toSortedMap()
                        for (key in versionsByPatch.keys.reversed()) {
                            val versionsOfPatch = versionsByPatch.getValue(key)
                            if (versionsOfPatch.any { !it.contains("-") }) {
                                add(versionsOfPatch.first { !it.contains("-") })
                                break

@NullUnmarked
public class FilteredMultimapTest extends TestCase {

  private static final Predicate<Entry<String, Integer>> ENTRY_PREDICATE =
      entry ->
          !Objects.equals(entry.getKey(), "badkey") && !Objects.equals(entry.getValue(), 55556);

  protected Multimap<String, Integer> create() {
    Multimap<String, Integer> unfiltered = HashMultimap.create();
    unfiltered.put("foo", 55556);
    unfiltered.put("badkey", 1);

            assertTrue(Modifier.isFinal(m), e.getKey() + " must be final");
            assertEquals(String.class, f.getType(), e.getKey() + " must be String");
            assertEquals(e.getValue(), f.get(null), e.getKey() + " value mismatch");
        }
    }

    @Test
    @DisplayName("OID values have valid dotted numeric format")
    void oidFormat() {

                    storeChildUrlsToQueue(urlQueue, getChildUrlSet(searchEngineClient, id));
                    return true;
                }

                final Date expires = DocumentUtil.getValue(document, fessConfig.getIndexFieldExpires(), Date.class);
                if (expires != null && expires.getTime() < systemHelper.getCurrentTimeAsLong()) {

                            final String distance = request.getParameter(distanceKey);
                            if (StringUtil.isNotBlank(distance)) {
                                StreamUtil.stream(e.getValue()).of(s -> s.forEach(pt -> {
                                    List<QueryBuilder> list = geoMap.get(geoField);
                                    if (list == null) {

   */
  public char[] @Nullable [] toArray() {
    char[][] result = new char[max + 1][];
    for (Entry<Character, String> entry : map.entrySet()) {
      result[entry.getKey()] = entry.getValue().toCharArray();
    }
    return result;
  }

  /**
   * Convert this builder into a char escaper which is just a decorator around the underlying array
   * of replacement char[]s.
   *

        StringBuilder buffer = new StringBuilder(64);

        for (Map.Entry<TransferResource, Long> entry : downloads.entrySet()) {
            long total = entry.getKey().getContentLength();
            long complete = entry.getValue();

            buffer.append(getStatus(complete, total)).append("  ");
        }

        int pad = lastLength - buffer.length();
        lastLength = buffer.length();
        pad(buffer, pad);