for (int i = 0; i < entries.size(); i++) {
      assertEqualInOrder(
          entries.subList(0, i), navigableMap.headMap(entries.get(i).getKey()).entrySet());
    }
  }

  public void testTailMap() {
    List<Entry<K, V>> entries =
        Helpers.copyToList(
            getSubjectGenerator()

            itemList.add(createItem(entry.getKey(), entry.getValue()));
        }
        return itemList;
    }

    public static List<Map<String, String>> getPropItems() {
        final List<Map<String, String>> itemList = new ArrayList<>();
        for (final Map.Entry<Object, Object> entry : System.getProperties().entrySet()) {

      @Override
      public boolean hasNext() {
        return entryItr.hasNext();
      }

      @Override
      public V next() {
        return entryItr.next().getValue();
      }
    };
  }

  @Override
  public Spliterator<V> spliterator() {
    return CollectSpliterators.map(map.entrySet().spliterator(), Entry::getValue);
  }

        // Find accessors that were not removed but should be
        Map<AccessorKey, ReplacedAccessor> keptAccessors = new HashMap<>(oldAccessorsOfUpgradedProperties);
        keptAccessors.entrySet().removeIf(e -> {
            if (seenUpgradedAccessorsChanges.contains(e.getKey())) {
                return true;
            }
            ReplacedAccessor accessor = e.getValue();

    public Collection<Object> values() {
        return parent.values();
    }

    @Override
    public Set<java.util.Map.Entry<String, Object>> entrySet() {
        if (parent.containsKey(LANG_KEY)) {
            final List<java.util.Map.Entry<String, Object>> list = new ArrayList<>(parent.entrySet());
            Collections.sort(list, (o1, o2) -> {
                final String k1 = o1.getKey();
                if (LANG_KEY.equals(k1)) {

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

    protected void log(final Map<String, String> valueMap) {

        for (Map<String, Object> doc : docs) {
            String[] keywords = query.split(" ");
            assertTrue(doc.entrySet().stream()
                    .anyMatch(entry -> entry.getValue().toString().toLowerCase().contains(keywords[0].toLowerCase())), doc.toString());
            assertFalse(doc.entrySet().stream()

          if (oldCount <= occurrences) {
            itr.remove();
          }
        }
      }
      return oldCount;
    }

    @Override
    public Set<Multiset.Entry<K>> entrySet() {
      return new Multisets.EntrySet<K>() {

        @Override
        Multiset<K> multiset() {
          return Keys.this;
        }

        @Override
        public Iterator<Multiset.Entry<K>> iterator() {

     */
    abstract Set<Entry<K, V>> createEntrySet();

    @LazyInit @CheckForNull private transient Set<Entry<K, V>> entrySet;

    @Override
    public Set<Entry<K, V>> entrySet() {
      Set<Entry<K, V>> result = entrySet;
      return (result == null) ? entrySet = createEntrySet() : result;
    }

    @LazyInit @CheckForNull private transient Set<K> keySet;

    @Override

  /**
   * Returns an immutable set of the mappings in this map. The iteration order is specified by the
   * method used to create this map. Typically, this is insertion order.
   */
  @Override
  public ImmutableSet<Entry<K, V>> entrySet() {
    ImmutableSet<Entry<K, V>> result = entrySet;
    return (result == null) ? entrySet = createEntrySet() : result;
  }