public int size() {
                    return 0;
                }
            };
        }
    };

    static <E1, E2 extends E1> List<E1> copy(Collection<E2> collection) {
        return collection == null ? List.of() : List.copyOf(collection);
    }

    static <K, V> Map<K, V> copy(Map<K, V> map) {
        if (map == null) {
            return emptyMap();

     * @since 3.5.0
     * @deprecated Use {@link #DefaultProjectDependencyGraph(Collection, Collection)} instead.
     */
    @Deprecated
    public DefaultProjectDependencyGraph(List<MavenProject> allProjects, Collection<MavenProject> projects)
            throws CycleDetectedException, DuplicateProjectException {
        this((Collection<MavenProject>) allProjects, projects);
    }

    /**

        if (entry.getKey().equals(key)) {
          expectedValues.add(entry.getValue());
        }
      }

      Collection<V> collection = multimap().asMap().get(key);
      if (expectedValues.isEmpty()) {
        assertNull(collection);
      } else {
        assertEqualIgnoringOrder(expectedValues, collection);
      }
    }
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(ALLOWS_NULL_KEYS)

                }
                snapshotMetadata.bind(artifact);
            }
        }

        return Collections.emptyList();
    }

    @Override
    public Artifact transformArtifact(Artifact artifact) {
        return artifact;
    }

    @Override
    public Collection<? extends Metadata> finish(Collection<? extends Artifact> artifacts) {
        return snapshots.values();
    }

        return result;
    }

    @Override
    public Collection<org.eclipse.aether.scope.ResolutionScope> buildResolutionScopes(
            InternalScopeManager internalScopeManager) {
        Collection<org.eclipse.aether.scope.DependencyScope> allDependencyScopes =
                internalScopeManager.getDependencyScopeUniverse();
        Collection<org.eclipse.aether.scope.DependencyScope> nonTransitiveDependencyScopes =

            projectKeys.add(key);
        }
        return projectKeys;
    }

    private Collection<String> negate(Collection<String> scopes) {
        Collection<String> result = new HashSet<>();
        Collections.addAll(result, "system", "compile", "provided", "runtime", "test");

        for (String scope : scopes) {
            if ("compile".equals(scope)) {
                result.remove("compile");

  protected Collection<Method> suppressForSingletonSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForHashSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForLinkedHashSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForEnumSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForSynchronizedNavigableSet() {

    assertPermutationsCount(1, Collections2.permutations(Collections.<Integer>emptyList()));
    assertPermutationsCount(1, Collections2.permutations(newArrayList(1)));
    assertPermutationsCount(2, Collections2.permutations(newArrayList(1, 2)));
    assertPermutationsCount(6, Collections2.permutations(newArrayList(1, 2, 3)));
    assertPermutationsCount(5040, Collections2.permutations(newArrayList(1, 2, 3, 4, 5, 6, 7)));

  public void testCopyOf_shortcut_empty() {
    Collection<String> c = ImmutableList.of();
    assertThat(ImmutableList.copyOf(c)).isSameInstanceAs(c);
  }

  public void testCopyOf_shortcut_singleton() {
    Collection<String> c = ImmutableList.of("a");
    assertThat(ImmutableList.copyOf(c)).isSameInstanceAs(c);
  }

  public void testCopyOf_shortcut_immutableList() {
    Collection<String> c = ImmutableList.of("a", "b", "c");

    for (Collection<V> collection : asMap().values()) {
      if (collection.contains(value)) {
        return true;
      }
    }

    return false;
  }

  @Override
  public boolean containsEntry(@Nullable Object key, @Nullable Object value) {
    Collection<V> collection = asMap().get(key);
    return collection != null && collection.contains(value);
  }

  @CanIgnoreReturnValue