void declaredIn1AnnotatedInClass(Object o);

    void nowhereAnnotated(Object o);
  }

  interface Interface2 extends Interface1 {
    @Override
    @Subscribe
    void declaredIn1AnnotatedIn2(Object o);

    @Override
    @Subscribe
    void annotatedIn1And2(Object o);

    @Override
    @Subscribe
    void annotatedIn1And2AndClass(Object o);

    void declaredIn2AnnotatedInClass(Object o);

    /**
     * Returns the appropriate HTML response for login handling.
     * If a user is already authenticated, redirects to the appropriate admin interface.
     * Otherwise, displays the login page.
     *
     * @return HTML response for login page or redirect to admin interface
     */
    protected HtmlResponse getHtmlResponse() {
        return getUserBean().map(this::redirectByUser).orElse(asHtml(virtualHost(path_Login_IndexJsp)));
    }

  /**
   * A set containing none of the optional features of the {@link Iterator} or {@link ListIterator}
   * interfaces.
   */
  public static final Set<IteratorFeature> UNMODIFIABLE = emptySet();

  /**
   * A set containing all of the optional features of the {@link Iterator} and {@link ListIterator}
   * interfaces.
   */
  public static final Set<IteratorFeature> MODIFIABLE =

    for (Class<? super T> itf : allInterfaceClasses) {
      Iterator<Class<?>> iterator = interfaceClasses.iterator();
      boolean addToSet = true;
      while (iterator.hasNext()) {
        Class<?> current = iterator.next();
        if (current == itf || itf.isAssignableFrom(current)) {
          // Skip any super interface of the ones that are already included.

 * the symmetry of {@code equals}. Custom definitions of equality are usually based on an interface,
 * such as {@code Set} or {@code List}, so that the implementation of {@code equals} can cast the
 * object being tested for equality to the custom interface. {@code ForwardingObject} implements no
 * such custom interfaces directly; they are implemented only in subclasses. Therefore, forwarding

    return Reflection.newProxy(List.class, new SubHandler2(delegate));
  }

  private static Object newProxyWithEqualsForInterfaces(Class<?>... interfaces) {
    return Proxy.newProxyInstance(
        AbstractInvocationHandlerTest.class.getClassLoader(),
        interfaces,
        new DelegatingInvocationHandlerWithEquals("a string"));
  }

  private static class DelegatingInvocationHandler extends AbstractInvocationHandler

    for (Class<? super T> itf : allInterfaceClasses) {
      Iterator<Class<?>> iterator = interfaceClasses.iterator();
      boolean addToSet = true;
      while (iterator.hasNext()) {
        Class<?> current = iterator.next();
        if (current == itf || itf.isAssignableFrom(current)) {
          // Skip any super interface of the ones that are already included.

  /**
   * A set containing none of the optional features of the {@link Iterator} or {@link ListIterator}
   * interfaces.
   */
  public static final Set<IteratorFeature> UNMODIFIABLE = emptySet();

  /**
   * A set containing all of the optional features of the {@link Iterator} and {@link ListIterator}
   * interfaces.
   */
  public static final Set<IteratorFeature> MODIFIABLE =

 * the symmetry of {@code equals}. Custom definitions of equality are usually based on an interface,
 * such as {@code Set} or {@code List}, so that the implementation of {@code equals} can cast the
 * object being tested for equality to the custom interface. {@code ForwardingObject} implements no
 * such custom interfaces directly; they are implemented only in subclasses. Therefore, forwarding

    checkNotNull(wrapperFunction);
    checkArgument(interfaceType.isInterface(), "%s isn't an interface", interfaceType);
    Method[] methods = getMostConcreteMethods(interfaceType);
    AccessibleObject.setAccessible(methods, true);
    for (Method method : methods) {
      // Interfaces can have default methods that aren't abstract.
      // No need to verify them.