* Equivalence<? super T> below, no type could satisfy both that bound and T's own
     * bound. With this type, they have some overlap: in our example, Equivalence<Number>
     * and Equivalence<Object>.
     */
    private final Equivalence<? super @NonNull T> equivalence;

    @ParametricNullness private final T reference;

  private CollectorTester(
      Collector<T, A, R> collector, BiPredicate<? super R, ? super R> equivalence) {
    this.collector = checkNotNull(collector);
    this.equivalence = checkNotNull(equivalence);
  }

  /**
   * Different orderings for combining the elements of an input array, which must all produce the
   * same result.
   */
  enum CollectStrategy {

import com.google.common.annotations.J2ktIncompatible;
import java.io.Serializable;
import org.jspecify.annotations.Nullable;

/**
 * Equivalence applied on functional result.
 *
 * @author Bob Lee
 * @since 10.0
 */
@GwtCompatible
final class FunctionalEquivalence<F, T> extends Equivalence<F> implements Serializable {

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

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

@GwtCompatible
final class PairwiseEquivalence<E, T extends @Nullable E> extends Equivalence<Iterable<T>>
    implements Serializable {
  final Equivalence<E> elementEquivalence;

  PairwiseEquivalence(Equivalence<E> elementEquivalence) {
    this.elementEquivalence = Preconditions.checkNotNull(elementEquivalence);
  }

  @Override

        .addEquivalenceGroup("a")
        .test();
  }

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

  @J2ktIncompatible
  @GwtIncompatible // NullPointerTester
  public void testNulls() throws NoSuchMethodException {

  private EquivalenceTester(Equivalence<? super T> equivalence) {
    this.equivalence = checkNotNull(equivalence);
    this.delegate =
        new RelationshipTester<>(
            equivalence, "equivalent", "hash", /* itemReporter= */ Item::toString);
  }

  public static <T> EquivalenceTester<T> of(Equivalence<? super T> equivalence) {
    return new EquivalenceTester<>(equivalence);
  }

  /**

  private EquivalenceTester(Equivalence<? super T> equivalence) {
    this.equivalence = checkNotNull(equivalence);
    this.delegate =
        new RelationshipTester<>(
            equivalence, "equivalent", "hash", /* itemReporter= */ Item::toString);
  }

  public static <T> EquivalenceTester<T> of(Equivalence<? super T> equivalence) {
    return new EquivalenceTester<>(equivalence);
  }

  /**

   * directly against {@code equals()} rather than through the {@code Equivalence}.
   */
  private final Equivalence<? super T> equivalence;

  private final String relationshipName;
  private final String hashName;
  private final ItemReporter itemReporter;
  private final List<ImmutableList<T>> groups = new ArrayList<>();

  RelationshipTester(
      Equivalence<? super T> equivalence,
      String relationshipName,
      String hashName,

  @CanIgnoreReturnValue
  CacheBuilder<K, V> keyEquivalence(Equivalence<Object> equivalence) {
    checkState(keyEquivalence == null, "key equivalence was already set to %s", keyEquivalence);
    keyEquivalence = checkNotNull(equivalence);
    return this;
  }

  Equivalence<Object> getKeyEquivalence() {
    return MoreObjects.firstNonNull(keyEquivalence, getKeyStrength().defaultEquivalence());
  }

  /**

import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertTrue;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Equivalence;
import com.google.common.collect.Iterables;
import com.google.common.testing.RelationshipTester.Item;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.ArrayList;
import java.util.List;