import com.google.common.eventbus.Subscribe;
import com.google.common.eventbus.outside.AnnotatedAndAbstractInSuperclassTest.SubClass;
import java.util.ArrayList;
import java.util.List;

public class AnnotatedAndAbstractInSuperclassTest extends AbstractEventBusTest<SubClass> {
  abstract static class SuperClass {
    @Subscribe
    public abstract void overriddenAndAnnotatedInSubclass(Object o);

    @Subscribe

import com.google.common.eventbus.Subscribe;
import com.google.common.eventbus.outside.AnnotatedAndAbstractInSuperclassTest.SubClass;
import java.util.ArrayList;
import java.util.List;

public class AnnotatedAndAbstractInSuperclassTest extends AbstractEventBusTest<SubClass> {
  abstract static class SuperClass {
    @Subscribe
    public abstract void overriddenAndAnnotatedInSubclass(Object o);

    @Subscribe

import com.google.common.eventbus.Subscribe;
import com.google.common.eventbus.outside.NeitherAbstractNorAnnotatedInSuperclassTest.SubClass;
import java.util.ArrayList;
import java.util.List;

public class NeitherAbstractNorAnnotatedInSuperclassTest extends AbstractEventBusTest<SubClass> {
  static class SuperClass {
    final List<Object> neitherOverriddenNorAnnotatedEvents = new ArrayList<>();

        // The raw class isn't even a subclass.
      }
    }
    if (!spec.suppressGetSupertype()) {
      try {
        assertThat(getSupertype(paramType, TypeToken.of(returnType).getRawType()))
            .isNotEqualTo(returnType);
      } catch (IllegalArgumentException notSubtype2) {
        // The raw class isn't even a subclass.
      }
    }
    return null;
  }

import com.google.common.eventbus.Subscribe;
import com.google.common.eventbus.outside.AnnotatedNotAbstractInSuperclassTest.SubClass;
import java.util.ArrayList;
import java.util.List;

public class AnnotatedNotAbstractInSuperclassTest extends AbstractEventBusTest<SubClass> {
  static class SuperClass {
    final List<Object> notOverriddenInSubclassEvents = new ArrayList<>();

import com.google.common.eventbus.Subscribe;
import com.google.common.eventbus.outside.AbstractNotAnnotatedInSuperclassTest.SubClass;
import java.util.ArrayList;
import java.util.List;

public class AbstractNotAnnotatedInSuperclassTest extends AbstractEventBusTest<SubClass> {
  abstract static class SuperClass {
    public abstract void overriddenInSubclassNowhereAnnotated(Object o);

import com.google.common.eventbus.Subscribe;
import com.google.common.eventbus.outside.NeitherAbstractNorAnnotatedInSuperclassTest.SubClass;
import java.util.ArrayList;
import java.util.List;

public class NeitherAbstractNorAnnotatedInSuperclassTest extends AbstractEventBusTest<SubClass> {
  static class SuperClass {
    final List<Object> neitherOverriddenNorAnnotatedEvents = new ArrayList<>();

  public void testSubtypeOfInnerClass_nonStaticAnonymousClass() {
    TypeToken<?> supertype = new TypeToken<Mall<Outdoor>.Shop<Electronics>>() {};
    Class<?> subclass = new Mall<Outdoor>().new Shop<Electronics>() {}.getClass();
    assertTrue(TypeToken.of(subclass).isSubtypeOf(supertype));
  }

  @SuppressWarnings("RestrictedApiChecker") // crashes under JDK8, which EP no longer supports

   * {@link SortedMultiset#entrySet}, and {@link SortedMultiset#remove(Object, int)}. In many
   * situations, you may wish to override {@link SortedMultiset#elementSet} to forward to this
   * implementation or a subclass thereof.
   *
   * @since 15.0
   */
  protected class StandardElementSet extends SortedMultisets.NavigableElementSet<E> {
    /** Constructor for use by subclasses. */
    public StandardElementSet() {

  /**
   * A duplex request body is special in how it is **transmitted** on the network and
   * in the **API contract** between OkHttp and the application.
   *
   * This method returns false unless it is overridden by a subclass.
   *
   * ### Duplex Transmission
   *
   * With regular HTTP calls the request always completes sending before the response may begin