assertEquals(isRoundTrippable, Utf8.isWellFormed(bytes, 0, numBytes));
      String s = new String(bytes, UTF_8);
      byte[] bytesReencoded = s.getBytes(UTF_8);
      boolean bytesEqual = Arrays.equals(bytes, bytesReencoded);

      if (bytesEqual != isRoundTrippable) {
        fail();
      }
      if (isRoundTrippable) {
        countRoundTripped++;
      }
    }

        return ImmutableList.this.get(index);
      }
    };
  }

  @Override
  public ImmutableList<E> asList() {
    return this;
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    return Lists.equalsImpl(this, obj);
  }

  @Override
  public int hashCode() {
    return Lists.hashCodeImpl(this);
  }

  public ImmutableList<E> reverse() {

                    this.requireMic = true;
                }
                this.firstResponse = false;
            } else if (targ.getMechanism() != null && !targ.getMechanism().equals(this.selectedMech)) {
                throw new SmbException("Server switched mechanism");
            }
            inputToken = targ.getMechanismToken();
        } else {

        if (dataClass == null) {
            return super.getData(accessResultData);
        }

        final Map<String, Object> dataMap = XmlUtil.getDataMap(accessResultData);
        if (Map.class.equals(dataClass)) {
            return dataMap;
        }

        try {
            final Object obj = dataClass.getDeclaredConstructor().newInstance();
            BeanUtil.copyMapToBean(dataMap, obj);

      this.value = value;
    }

    @Override
    public int compareTo(ClassWithTerribleHashCode that) {
      return Integer.compare(this.value, that.value);
    }

    @Override
    public boolean equals(@Nullable Object x) {
      return x instanceof ClassWithTerribleHashCode
          && ((ClassWithTerribleHashCode) x).value == value;
    }

    @Override
    public int hashCode() {
      return 23;

import java.util.Comparator;
import java.util.List;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

@AndroidIncompatible // lots of failures, possibly some related to bad equals() implementations?
@NullUnmarked
public class TypeTokenSubtypeTest extends TestCase {

  public void testOwnerTypeSubtypes() throws Exception {
    new OwnerTypeSubtypingTests().testAllDeclarations();
  }

    if (!Objects.equals(actual, expected)) {
      // fail(), but with the JUnit-supplied message.
      assertEquals("Using seed " + seed, expected, actual);
    }
  }

  private static void assertEqualsUsingStartedWith(
      Collection<?> startedWith, @Nullable Object expected, @Nullable Object actual) {
    if (!Objects.equals(actual, expected)) {

        return false;
      } else if (read1 != BUFFER_SIZE) {
        return true;
      }
    }
  }

  // The Arrays.equals(<arraytype>, int, int, <arraytype>, int, int) methods were not added until
  // Java 9. This function is just returns the same result that
  // Arrays.equals(array1, 0, count, array2, 0, count) would. It assumes that both arrays have a
  // length of at least count.

            <![CDATA[
    /**
     * @see java.lang.Object#equals(java.lang.Object)
     */
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        } else if (o instanceof Extension e) {
            return java.util.Objects.equals(e.getArtifactId(), getArtifactId())
                && java.util.Objects.equals(e.getGroupId(), getGroupId())

     * Tests to see if two <code>SmbFile</code> objects are equal. Two
     * SmbFile objects are equal when they reference the same SMB
     * resource. More specifically, two <code>SmbFile</code> objects are
     * equals if their server IP addresses are equal and the canonicalized
     * representation of their URLs, minus authentication parameters, are
     * case insensitively and lexographically equal.
     * <br>