@Override
    public boolean equals(@Nullable Object other) {
      return (other instanceof ClassWhichIsAlwaysEqualButHasDifferentHashcodes);
    }
  }

  private static class ObjectWhichIsEqualButChangesClass implements Serializable {
    private static final long serialVersionUID = 1L;

    @Override
    public boolean equals(@Nullable Object other) {

  /**
   * @since 12.0
   */
  @GwtIncompatible // NavigableSet
  @Override
  public @Nullable E lower(E e) {
    return Iterators.<@Nullable E>getNext(headSet(e, false).descendingIterator(), null);
  }

  /**
   * @since 12.0
   */
  @Override
  public @Nullable E floor(E e) {
    return Iterators.<@Nullable E>getNext(headSet(e, true).descendingIterator(), null);
  }

  /**
   * @since 12.0
   */

 * invoke methods, they invoke methods on the {@code ForwardingListMultimap}.
 *
 * @author Kurt Alfred Kluever
 * @since 3.0
 */
@GwtCompatible
public abstract class ForwardingListMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends ForwardingMultimap<K, V> implements ListMultimap<K, V> {

  /** Constructor for use by subclasses. */
  protected ForwardingListMultimap() {}

  @Override

import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * A generator for {@code ListMultimap} implementations based on test data.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@NullMarked
public interface TestListMultimapGenerator<K extends @Nullable Object, V extends @Nullable Object>

// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@NullMarked
public abstract class AbstractMapTester<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractContainerTester<Map<K, V>, Entry<K, V>> {
  protected Map<K, V> getMap() {
    return container;
  }

  @Override
  protected Collection<Entry<K, V>> actualContents() {

    // The same element is not allowed in both forgetMeNot and skipMe, but duplicates are allowed in
    // either of them, up to the same multiplicity as the queue.
    private @Nullable Queue<E> forgetMeNot;
    private @Nullable List<E> skipMe;
    private @Nullable E lastFromForgetMeNot;
    private boolean canRemove;

    @Override
    public boolean hasNext() {
      checkModCount();
      nextNotInSkipMe(cursor + 1);

     */
    @Nonnull
    static VersionRangeResolverRequest build(
            @Nonnull Session session,
            @Nonnull ArtifactCoordinates artifactCoordinates,
            @Nullable List<RemoteRepository> repositories,
            @Nullable Nature nature) {
        return builder()
                .session(requireNonNull(session, "session cannot be null"))

    multimap.put("bar", 9);
    assertThat(multimap.keySet()).containsExactly("cow", "bar").inOrder();
  }

  public void testToStringNullExact() {
    SetMultimap<@Nullable String, @Nullable Integer> multimap = LinkedHashMultimap.create();

    multimap.put("foo", 3);
    multimap.put("foo", -1);
    multimap.put(null, null);
    multimap.put("bar", 1);
    multimap.put("foo", 2);

 */
@GwtCompatible
public abstract class AbstractSequentialIterator<T> extends UnmodifiableIterator<T> {
  private @Nullable T nextOrNull;

  /**
   * Creates a new iterator with the given first element, or, if {@code firstOrNull} is null,
   * creates a new empty iterator.
   */
  protected AbstractSequentialIterator(@Nullable T firstOrNull) {
    this.nextOrNull = firstOrNull;
  }

  /**

   * PeekingIterator#remove()} removes the same elements as the reference's iterator {@code
   * remove()}.
   */
  private static class PeekingIteratorTester<T extends @Nullable Object> extends IteratorTester<T> {
    private final Iterable<T> master;
    private @Nullable List<T> targetList;

    PeekingIteratorTester(Collection<T> master) {
      super(master.size() + 3, MODIFIABLE, master, IteratorTester.KnownOrder.KNOWN_ORDER);