* @since 27.1
   */
  @CanIgnoreReturnValue
  boolean addEdge(EndpointPair<N> endpoints, E edge);

  /**
   * Removes {@code node} if it is present; all edges incident to {@code node} will also be removed.
   *
   * @return {@code true} if the network was modified as a result of this call
   */
  @CanIgnoreReturnValue
  boolean removeNode(N node);

  /**

    testThreshold(10, 100, false, false);
    testThreshold(100, 100, false, false);
    testThreshold(1000, 100, false, false);
  }

  private void testThreshold(
      int fileThreshold, int dataSize, boolean singleByte, boolean resetOnFinalize)
      throws IOException {
    byte[] data = newPreFilledByteArray(dataSize);
    FileBackedOutputStream out = new FileBackedOutputStream(fileThreshold, resetOnFinalize);

  private static final boolean useSecurityManager = Boolean.getBoolean("jsr166.useSecurityManager");

  protected static final boolean expensiveTests = Boolean.getBoolean("jsr166.expensiveTests");

  /**
   * If true, report on stdout all "slow" tests, that is, ones that take more than profileThreshold
   * milliseconds to execute.
   */

            }
        }
        return null;
    }

    private boolean isProjectContext(String context) {
        return context != null && context.startsWith("project");
    }

    private static boolean isAny(String str) {
        return "*".equals(str);
    }

    private static boolean matches(String pattern, String str) {
        if (isAny(pattern)) {
            return true;

import java.io.OutputStream;
import java.util.Arrays;

/** @author Colin Decker */
public class TestOutputStream extends FilterOutputStream {

  private final ImmutableSet<TestOption> options;
  private boolean closed;

  public TestOutputStream(OutputStream out, TestOption... options) throws IOException {
    this(out, Arrays.asList(options));
  }

    public IncludesArtifactFilter(List<String> patterns) {
        this.patterns = new LinkedHashSet<>(patterns);
    }

    public boolean include(Artifact artifact) {
        String id = artifact.getGroupId() + ":" + artifact.getArtifactId();

        boolean matched = false;
        for (Iterator<String> i = patterns.iterator(); i.hasNext() & !matched; ) {

     */
    @Override
    public boolean renewCredentials ( String locationHint, Throwable error ) {
        return false;
    }


    /**
     * {@inheritDoc}
     * 
     *
     * @see jcifs.CIFSContext#close()
     */
    @Override
    public boolean close () throws CIFSException {
        if ( !this.closed ) {

        super(createMetadata(artifact, versioning));
        this.artifact = artifact;
    }

    public boolean storedInGroupDirectory() {
        return false;
    }

    public boolean storedInArtifactVersionDirectory() {
        return false;
    }

    public String getGroupId() {
        return artifact.getGroupId();
    }

     *         c1 is less specific than c2, INCOMPARABLE if they are incomparable.
     */
    private static int moreSpecific(Class<?>[] c1, Class<?>[] c2) {
        boolean c1MoreSpecific = false;
        boolean c2MoreSpecific = false;

        for (int i = 0; i < c1.length; ++i) {
            if (c1[i] != c2[i]) {

 *
 */
@Deprecated
public final class MetadataBridge extends AbstractMetadata implements MergeableMetadata {

    private ArtifactMetadata metadata;

    private boolean merged;

    public MetadataBridge(ArtifactMetadata metadata) {
        this.metadata = metadata;
    }

    public void merge(File current, File result) throws RepositoryException {
        try {