}

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj instanceof MethodSignature) {
        MethodSignature other = (MethodSignature) obj;
        return name.equals(other.name)
            && parameterTypes.equals(other.parameterTypes)
            && typeSignature.equals(other.typeSignature);
      }

      return false;
    }

    @Override

                for (int j = i + 1; j < lines.size(); j++) {
                    String look = lines.get(j).trim();

                    if (look.equals("[.multi-language-sample]") || look.equals("====")) {
                        break; // stop at next sample or end of example block
                    }

                    if (sourceLang == null) {
                        String parsed = parseSourceLang(look);

   * same structural relationships as those in this network.
   *
   * <p>Thus, two networks A and B are equal if <b>all</b> of the following are true:
   *
   * <ul>
   *   <li>A and B have equal {@link #isDirected() directedness}.
   *   <li>A and B have equal {@link #nodes() node sets}.
   *   <li>A and B have equal {@link #edges() edge sets}.
   *   <li>Every edge in A and B connects the same nodes in the same direction (if any).

        return Artifact.SCOPE_COMPILE.equals(scope)
                || Artifact.SCOPE_PROVIDED.equals(scope)
                || Artifact.SCOPE_SYSTEM.equals(scope);
    }

    // TODO let the scope handler deal with this
    private static boolean isRuntimePathElement(final String scope) {
        return Artifact.SCOPE_COMPILE.equals(scope) || Artifact.SCOPE_RUNTIME.equals(scope);
    }

   * equals()} contract.
   *
   * <p><b>Note:</b> this method is now unnecessary and should be treated as deprecated; use {@link
   * java.util.Objects#equals} instead.
   */
  @SuppressWarnings("InlineMeSuggester") // would introduce fully qualified references to Objects
  public static boolean equal(@Nullable Object a, @Nullable Object b) {
    return java.util.Objects.equals(a, b);
  }

  /**

        if (current.equals(version) || (version == null && current.isEmpty())) {
            return this;
        }
        return new RelocatedArtifact(artifact, groupId, artifactId, classifier, extension, version, message);
    }

    @Override
    public Artifact setFile(File file) {
        File current = getFile();
        if (Objects.equals(current, file)) {
            return this;
        }

    assertTrue("An Object should be equal to itself.", collection.equals(collection));
  }

  // Comparisons to null *are* defined.
  @SuppressWarnings("UndefinedEquals")
  public void testEquals_null() {
    // noinspection ObjectEqualsNull
    assertFalse("An object should not be equal to null.", collection.equals(null));
  }

  // A collection should essentially never be equal to a non-collection.

        assertFalse(filter1.equals(null), "Expected " + filter1 + " to not equal " + null);
        assertTrue(filter1.equals(filter1), "Expected " + filter1 + " to equal " + filter1);
        assertEquals(filter1.hashCode(), filter1.hashCode());

        assertFalse(filter1.equals(filter2), "Expected " + filter1 + " to not equal " + filter2);
        assertFalse(filter2.equals(filter1), "Expected " + filter2 + " to not equal " + filter1);

    }
  }

  private interface Equals {
    @Override
    boolean equals(@Nullable Object obj);

    @Override
    int hashCode();

    @Override
    String toString();
  }

  private static class NoDelegateToEquals implements Equals {

    private static final Function<Equals, Equals> WRAPPER =
        new Function<Equals, Equals>() {
          @Override

        .test();
  }

  public void testPairwiseEquivalent_equals() {
    new EqualsTester()
        .addEqualityGroup(Equivalence.equals().pairwise(), Equivalence.equals().pairwise())
        .addEqualityGroup(Equivalence.identity().pairwise())
        .testEquals();
  }

  private enum LengthFunction implements Function<String, Integer> {
    INSTANCE;

    @Override