public static Collection<Object[]> parameters() {
    return Arrays.asList(new Object[][] {{false}, {true}});
  }

  private final boolean allowsSelfLoops;
  private ImmutableGraph.Builder<Integer> graphBuilder;

  public StandardImmutableUndirectedGraphTest(boolean allowsSelfLoops) {
    this.allowsSelfLoops = allowsSelfLoops;
  }

  @Override
  public Graph<Integer> createGraph() {

    }

    @Override
    public boolean contains(Object object) {
      return standardContains(object);
    }

    @Override
    public boolean containsAll(Collection<?> collection) {
      return standardContainsAll(collection);
    }

    @Override
    public boolean remove(Object object) {
      return standardRemove(object);
    }

    @Override
    public boolean removeAll(Collection<?> collection) {

    @Deprecated
    ArtifactRepository createDeploymentArtifactRepository(String id, String url, String layoutId, boolean uniqueVersion)
            throws UnknownRepositoryLayoutException;

    ArtifactRepository createDeploymentArtifactRepository(
            String id, String url, ArtifactRepositoryLayout layout, boolean uniqueVersion);

    ArtifactRepository createArtifactRepository(
            String id,
            String url,

            }
            delegate = newDelegate;
        }
    }

    protected boolean replace(Object oldDelegate, Object newDelegate) {
        return false;
    }

    @FunctionalInterface
    protected interface ChildrenTracking {
        boolean replace(Object oldDelegate, Object newDelegate);
    }

    }

    @Override
    public Optional<Boolean> suppressSnapshotUpdates() {
        return returnFirstPresentOrEmpty(MavenOptions::suppressSnapshotUpdates);
    }

    @Override
    public Optional<Boolean> strictChecksums() {
        return returnFirstPresentOrEmpty(MavenOptions::strictChecksums);
    }

    @Override
    public Optional<Boolean> relaxedChecksums() {

   */
  public static void verify(boolean expression) {
    if (!expression) {
      throw new VerifyException();
    }
  }

  /**
   * Ensures that {@code expression} is {@code true}, throwing a {@code VerifyException} with a
   * custom message otherwise.
   *
   * @param expression a boolean expression

    {
        return sv.getClassifier() + ":" + sv.getExtension();
    }

    public boolean merge( Metadata sourceMetadata )
    {
        boolean changed = false;

        for ( Plugin plugin : sourceMetadata.getPlugins() )
        {
            boolean found = false;

            for ( Plugin preExisting : getPlugins() )
            {

    private File localRepositoryPath;

    private boolean offline = false;

    private boolean interactiveMode = true;

    private boolean cacheTransferError = false;

    private boolean cacheNotFound = false;

    private boolean ignoreMissingArtifactDescriptor = true;

    private boolean ignoreInvalidArtifactDescriptor = true;

    private boolean ignoreTransitiveRepositories;

    private List<Proxy> proxies;

            String groupId,
            String artifactId,
            VersionRange versionRange,
            String type,
            String classifier,
            String scope,
            boolean optional) {
        return createArtifact(groupId, artifactId, versionRange, type, classifier, scope, null, optional);
    }

    @Override
    public Artifact createDependencyArtifact(
            String groupId,

  public NavigableSet<E> subSet(
      @ParametricNullness E fromElement,
      boolean fromInclusive,
      @ParametricNullness E toElement,
      boolean toInclusive) {
    return delegate().subSet(fromElement, fromInclusive, toElement, toInclusive);
  }

  /**
   * A sensible definition of {@link #subSet(Object, boolean, Object, boolean)} in terms of the