@Override
  Collection<V> wrapCollection(@ParametricNullness K key, Collection<V> collection) {
    return new WrappedSet(key, (Set<V>) collection);
  }

  // Following Javadoc copied from SetMultimap.

  /**
   * {@inheritDoc}
   *
   * <p>Because a {@code SetMultimap} has unique values for a given key, this method returns a
   * {@link Set}, instead of the {@link Collection} specified in the {@link Multimap} interface.
   */
  @Override

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

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

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

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

        }

        @Override
        public Collection<Phase> phases() {
            return List.of(phase(
                    Phase.CLEAN,
                    plugin(
                            MAVEN_PLUGINS + "maven-clean-plugin:" + MAVEN_CLEAN_PLUGIN_VERSION + ":clean",
                            Phase.CLEAN)));
        }

        @Override
        public Collection<Alias> aliases() {

@GwtCompatible
public enum CollectionSize implements Feature<Collection>, Comparable<CollectionSize> {
  /** Test an empty collection. */
  ZERO(0),
  /** Test a one-element collection. */
  ONE(1),
  /** Test a three-element collection. */
  SEVERAL(3),
  /*
   * TODO: add VERY_LARGE, noting that we currently assume that the fourth
   * sample element is not in any collection
   */

  ANY(ZERO, ONE, SEVERAL);

      }
    };

    abstract Object operate(Stream<?> stream);
  }

  @Param private Operation operation;

  Collection<Object> collection;

  @BeforeExperiment
  void setUp() {
    collection = source.supplier.get();
    for (int i = 0; i < size; i++) {
      collection.add(new Object());
    }
  }

  @Benchmark
  int runOperation(int reps) {
    int result = 0;

public class Lifecycles {

    static Lifecycle.Phase phase(String name) {
        return new DefaultPhase(name, Collections.emptyList(), Collections.emptyList(), Collections.emptyList());
    }

    static Lifecycle.Phase phase(String name, Lifecycle.Phase... phases) {
        return new DefaultPhase(name, Collections.emptyList(), Collections.emptyList(), asList(phases));
    }

    @Nonnull
    Optional<Artifact> getRootArtifact();

    @Nonnull
    Optional<DependencyCoordinates> getRoot();

    @Nonnull
    Collection<DependencyCoordinates> getDependencies();

    @Nonnull
    Collection<DependencyCoordinates> getManagedDependencies();

    boolean getVerbose();

    @Nonnull
    PathScope getPathScope();

    /**

     */
    @Nonnull
    ChecksumAlgorithm select(@Nonnull String algorithmName);

    /**
     * Returns a collection of {@link ChecksumAlgorithm} in same order as algorithm names are ordered, or throws if
     * any of the algorithm name is not supported. The returned collection has equal count of elements as passed in
     * collection of names, and if names contains duplicated elements, the returned list of algorithms will have
     * duplicates as well.

    assertTrue("contains(present) should return true", collection.contains(e0()));
  }

  public void testContains_no() {
    assertFalse("contains(notPresent) should return false", collection.contains(e3()));
  }

  @CollectionFeature.Require(ALLOWS_NULL_QUERIES)
  public void testContains_nullNotContainedButQueriesSupported() {
    assertFalse("contains(null) should return false", collection.contains(null));
  }

        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 =