@MapFeature.Require(SUPPORTS_REMOVE)
  /*
   * ListMultimap.asMap essentially returns a Map<K, List<V>>; we just can't declare it that way.
   * Thus, calls like asMap().values().remove(someList) are safe because they are comparing a list
   * to a collection of other lists.
   */
  @SuppressWarnings("CollectionUndefinedEquality")
  public void testValuesRemove() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k1(), v0()), mapEntry(k0(), v3()));

  @MapFeature.Require(SUPPORTS_REMOVE)
  /*
   * ListMultimap.asMap essentially returns a Map<K, List<V>>; we just can't declare it that way.
   * Thus, calls like asMap().values().remove(someList) are safe because they are comparing a list
   * to a collection of other lists.
   */
  @SuppressWarnings("CollectionUndefinedEquality")
  public void testValuesRemove() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k1(), v0()), mapEntry(k0(), v3()));

   * then comparing those results using {@code this}. For example, to compare objects by their
   * string forms, in a case-insensitive manner, use:
   *
   * {@snippet :
   * Ordering.from(String.CASE_INSENSITIVE_ORDER).onResultOf(Functions.toStringFunction())
   * }
   *
   * <p><b>Java 8+ users:</b> Use {@code Comparator.comparing(function, thisComparator)} instead

import com.google.caliper.Param;
import java.security.MessageDigest;
import java.util.Arrays;
import java.util.Random;
import org.jspecify.annotations.NullUnmarked;

/**
 * Benchmarks for comparing the various {@link HashCode#equals} methods.
 *
 * <p>Parameters for the benchmark are:
 *
 * <ul>
 *   <li>size: the length of the byte array to hash
 *   <li>whereToDiffer: where in the array the bytes should differ

  @MapFeature.Require(SUPPORTS_REMOVE)
  /*
   * SetMultimap.asMap essentially returns a Map<K, Set<V>>; we just can't declare it that way.
   * Thus, calls like asMap().values().remove(someSet) are safe because they are comparing a set to
   * a collection of other sets.
   */
  @SuppressWarnings("CollectionUndefinedEquality")
  public void testValuesRemove() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k1(), v0()), mapEntry(k0(), v3()));

            <p>
            We check the binary compatibility by comparing the current code’s binary interfaces
            against THE LATEST VERSION WHICH IS RELEASED FROM RELEASE BRANCH (from `released-version.json` on this branch)

import java.util.Collections;
import java.util.Iterator;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * A utility for testing an Iterator implementation by comparing its behavior to that of a "known
 * good" reference implementation. In order to accomplish this, it's important to test a great
 * variety of sequences of the {@link Iterator#next}, {@link Iterator#hasNext} and {@link

        // Under some edge cases (such as the proxy of JDK types serialized and then deserialized)
        // the proxy type may not be the same.
        // We first check isProxyClass() so that the common case of comparing with non-proxy objects
        // is efficient.
        || (Proxy.isProxyClass(arg.getClass())
            && Arrays.equals(arg.getClass().getInterfaces(), proxyClass.getInterfaces()));
  }

// These tests should not be confused with `[*]_grad_test` which compare the
// result of `gradient_checker` and `[*]_grad`. The tests here test the
// functionality of `gradient_checker` by comparing the result with expected
// manual user-provided gradients.
class GradientCheckerTest
    : public ::testing::TestWithParam<std::tuple<const char*, bool, bool>> {
 protected:
  void SetUp() override {

import java.util.Collections;
import java.util.Iterator;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * A utility for testing an Iterator implementation by comparing its behavior to that of a "known
 * good" reference implementation. In order to accomplish this, it's important to test a great
 * variety of sequences of the {@link Iterator#next}, {@link Iterator#hasNext} and {@link