builder.put(entry.getKey(), DependentsSet.dependencyToAll(entry.getValue()));
        }
        Set<String> collected = new HashSet<>();
        for (Map.Entry<String, Set<String>> entry : accessibleDependents.entrySet()) {
            if (collected.add(entry.getKey())) {
                builder.put(entry.getKey(), DependentsSet.dependentClasses(privateDependents.getOrDefault(entry.getKey(), Collections.emptySet()), entry.getValue()));

    @Override
    public MavenMetadata setPath(Path path) {
        return new LocalSnapshotMetadata(metadata, path, timestamp);
    }

    public Object getKey() {
        return getGroupId() + ':' + getArtifactId() + ':' + getVersion();
    }

    public static Object getKey(Artifact artifact) {
        return artifact.getGroupId() + ':' + artifact.getArtifactId() + ':' + artifact.getBaseVersion();
    }

    @Override

            mergeDetailsSet.add(getMergeDetails(section, baseEntry.getKey(), baseEntry.getValue(), mergeValue));
            mergeOnlyAttributes.remove(baseEntry.getKey());
        }
        for (Map.Entry<String, Object> mergeEntry : mergeOnlyAttributes.entrySet()) {
            mergeDetailsSet.add(getMergeDetails(section, mergeEntry.getKey(), null, mergeEntry.getValue()));
        }

            if (SystemProperties.getInstance().isStandardProperty(entry.getKey())) {
                continue;
            }
            if (SystemProperties.getInstance().isNonStandardImportantProperty(entry.getKey())) {
                continue;
            }
            if (entry.getKey().startsWith("sun.") || entry.getKey().startsWith("awt.") || entry.getKey().contains(".awt.")) {
                continue;
            }

      Map<AnEnum, String> map = Maps.newHashMap();
      for (Entry<AnEnum, String> entry : entries) {
        // checkArgument(!map.containsKey(entry.getKey()));
        map.put(entry.getKey(), entry.getValue());
      }
      return Maps.immutableEnumMap(map);
    }
  }

  public static class ImmutableMapCopyOfEnumMapGenerator extends TestEnumMapGenerator {
    @Override

    for (ListIterator<Entry<K, V>> i = expected.listIterator(); i.hasNext(); ) {
      if (Helpers.equal(i.next().getKey(), newEntry.getKey())) {
        i.set(newEntry);
        return;
      }
    }

    throw new IllegalArgumentException(
        Platform.format("key %s not found in entries %s", newEntry.getKey(), expected));
  }

  /**

                    previous = nextEntry(previousEntries);
                } else if (currentNormalizedPath.isEmpty()) {
                    String currentAbsolutePath = current.getKey();
                    String previousAbsolutePath = previous.getKey();
                    if (!currentAbsolutePath.equals(previousAbsolutePath)) {
                        if (!currentSnapshots.containsKey(previousAbsolutePath)) {

                            result.getSearchFieldLogList().add(new Pair<>(e.getKey(), v));
                        }
                    } else if (e.getValue() instanceof List) {
                        final List<String> values = (List<String>) e.getValue();
                        for (final String v : values) {
                            result.getSearchFieldLogList().add(new Pair<>(e.getKey(), v));
                        }

  }

  protected final K k0() {
    return e0().getKey();
  }

  protected final V v0() {
    return e0().getValue();
  }

  protected final K k1() {
    return e1().getKey();
  }

  protected final V v1() {
    return e1().getValue();
  }

  protected final K k2() {
    return e2().getKey();
  }

  protected final V v2() {
    return e2().getValue();

        items.entrySet().stream().filter(e -> String.valueOf(e.getKey()).startsWith(prefix)).sorted(comparingByStringifiedKey()).forEach(e -> {
            System.out.printf("   %s=%s\n", e.getKey(), e.getValue());
        });
    }

    private static Comparator<Map.Entry<?, ?>> comparingByStringifiedKey() {
        return Comparator.comparing(entry -> String.valueOf(entry.getKey()));
    }