hash = hash * 31 + filters.hashCode();
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (obj instanceof OrArtifactFilter other) {
            return filters.equals(other.filters);
        } else {
            return false;
        }
    }

  }

  @Override
  public List<E> subList(int fromIndex, int toIndex) {
    return delegate().subList(fromIndex, toIndex);
  }

  @Override
  public boolean equals(@Nullable Object object) {
    return object == this || delegate().equals(object);
  }

  @Override
  public int hashCode() {
    return delegate().hashCode();
  }

  /**

   * required, to have the following properties:
   *
   * <ul>
   *   <li>Its execution does not cause any observable side effects.
   *   <li>The computation is <i>consistent with equals</i>; that is, {@link Objects#equal
   *       Objects.equal}{@code (a, b)} implies that {@code predicate.apply(a) ==
   *       predicate.apply(b))}.
   * </ul>
   *

        AuthScheme authScheme = null;
        if (Constants.BASIC.equals(scheme)) {
            authScheme = new BasicScheme();
        } else if (Constants.DIGEST.equals(scheme)) {
            authScheme = new DigestScheme();
        } else if (Constants.NTLM.equals(scheme)) {
            final Properties props = new Properties();

        Name name2 = new Name(mockConfig, "TEST", 0x20, "scope");

        assertTrue(name1.equals(name2));
    }

    @Test
    void equals_withDifferentName_shouldReturnFalse() {
        Name name1 = new Name(mockConfig, "TEST1", 0x20, "scope");
        Name name2 = new Name(mockConfig, "TEST2", 0x20, "scope");

        assertFalse(name1.equals(name2));
    }

    @Test

    // instead of Object[].
    return delegateList().toArray(new Object[size()]);
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    return delegateList().equals(obj);
  }

  @Override
  public int hashCode() {
    return delegateList().hashCode();
  }

  @Override
  public UnmodifiableIterator<E> iterator() {

            throws ArtifactResolutionException, ArtifactNotFoundException {
        if (Artifact.LATEST_VERSION.equals(artifact.getVersion())) {
            try {
                String version = resolveVersion(artifact, request);
                if (Artifact.LATEST_VERSION.equals(version)) {
                    throw new ArtifactNotFoundException("Unable to determine the latest version", artifact);
                }

    File asciiFile = getTestFile("ascii.txt");
    File i18nFile = getTestFile("i18n.txt");
    assertTrue(Arrays.equals(ASCII.getBytes(US_ASCII), Files.toByteArray(asciiFile)));
    assertTrue(Arrays.equals(I18N.getBytes(UTF_8), Files.toByteArray(i18nFile)));
    assertTrue(Arrays.equals(I18N.getBytes(UTF_8), Files.asByteSource(i18nFile).read()));
  }

    }

    @Override
    public boolean equals(final Object obj) {
        Name n;

        if (!(obj instanceof Name)) {
            return false;
        }
        n = (Name) obj;
        if (this.scope == null && n.scope == null) {
            return this.name.equals(n.name) && this.hexCode == n.hexCode;
        }
        return this.name.equals(n.name) && this.hexCode == n.hexCode && this.scope.equals(n.scope);

    }

    @Override
    public int hashCode() {
      return identity().hashCode();
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj instanceof DummyHandler) {
        DummyHandler that = (DummyHandler) obj;
        return identity().equals(that.identity());
      } else {
        return false;
      }
    }

    private DummyProxy identity() {