abstract class Retailer<ProductT> extends Shop<ProductT>
        implements Comparator<ProductT>, ConsumerFacing<ProductT> {}
  }

  private static class Outlet<T> extends Mall<T> {}

  private interface UseIterable<T extends Iterable<?>> {}

  private interface UseSerializableIterable<T extends Serializable & Iterable<?>> {}

  private interface UseList<T extends List<?>> {}

  private enum MyEnum {}

  }

  static final class ImmediateFailedFuture<V extends @Nullable Object> extends TrustedFuture<V> {
    ImmediateFailedFuture(Throwable thrown) {
      setException(thrown);
    }
  }

  static final class ImmediateCancelledFuture<V extends @Nullable Object> extends TrustedFuture<V> {
    static final @Nullable ImmediateCancelledFuture<Object> INSTANCE =

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@NullMarked
public abstract class AbstractMultimapTester<
        K extends @Nullable Object, V extends @Nullable Object, M extends Multimap<K, V>>
    extends AbstractContainerTester<M, Entry<K, V>> {

  private M multimap;

  protected M multimap() {
    return multimap;
  }

  /**

/**
 * A package-local class holding common representation and mechanics for classes supporting dynamic
 * striping on 64bit values. The class extends Number so that concrete subclasses must publicly do
 * so.
 */
@SuppressWarnings("SunApi") // b/345822163
@GwtIncompatible
abstract class Striped64 extends Number {
  /*
   * This class maintains a lazily-initialized table of atomically

  interface StrongValueEntry<K, V, E extends InternalEntry<K, V, E>>
      extends InternalEntry<K, V, E> {}

  /** Marker interface for {@link InternalEntry} implementations for weak values. */
  interface WeakValueEntry<K, V, E extends InternalEntry<K, V, E>> extends InternalEntry<K, V, E> {
    /** Gets the weak value reference held by entry. */

  }

  private static <K, V> Map<K, V> newHashMap(
      Collection<? extends Entry<? extends K, ? extends V>> entries) {
    HashMap<K, V> map = new HashMap<>();
    for (Entry<? extends K, ? extends V> entry : entries) {
      map.put(entry.getKey(), entry.getValue());
    }
    return map;
  }

  /** A skeleton implementation for {@link SortedMultiset#elementSet}. */
  @SuppressWarnings("JdkObsolete") // TODO(b/6160855): Switch GWT emulations to NavigableSet.
  static class ElementSet<E extends @Nullable Object> extends Multisets.ElementSet<E>
      implements SortedSet<E> {
    @Weak private final SortedMultiset<E> multiset;

    ElementSet(SortedMultiset<E> multiset) {
      this.multiset = multiset;
    }

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@NullMarked
public abstract class AbstractBiMapTester<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractMapTester<K, V> {

  @Override
  protected BiMap<K, V> getMap() {
    return (BiMap<K, V>) super.getMap();
  }

  static <K extends @Nullable Object, V extends @Nullable Object> Entry<V, K> reverseEntry(
      Entry<K, V> entry) {

/**
 * Implementation of {@link Multimaps#filterKeys(ListMultimap, Predicate)}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
final class FilteredKeyListMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends FilteredKeyMultimap<K, V> implements ListMultimap<K, V> {
  FilteredKeyListMultimap(ListMultimap<K, V> unfiltered, Predicate<? super K> keyPredicate) {
    super(unfiltered, keyPredicate);
  }

              + " called");
    }

    public <A extends @Nullable Object> void a(A a) {
      fail("Method with parameter <A extends @Nullable Object> should not be called");
    }

    public <A extends B, B extends @Nullable Object> void b(A a) {
      fail(