*
 * <p>Unless also annotated with @{@link AllowConcurrentEvents}, event subscriber methods will be
 * invoked serially by each event bus that they are registered with.
 *
 * @author Cliff Biffle
 * @since 10.0
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@ElementTypesAreNonnullByDefault

 *
 * <p>Unless also annotated with @{@link AllowConcurrentEvents}, event subscriber methods will be
 * invoked serially by each event bus that they are registered with.
 *
 * @author Cliff Biffle
 * @since 10.0
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@ElementTypesAreNonnullByDefault

  <url>http://www.apache.org/</url>

  <mailingLists>
    <mailingList>
      <name>parent</name>
      <post>******@****.***</post>
      <subscribe>subscribe@mailing.list.com</subscribe>
      <unsubscribe>******@****.***</unsubscribe>
    </mailingList>
  </mailingLists>

  <build>
    <plugins>
      <plugin>
        <groupId>inheritance.configuration</groupId>

        new RuntimeException("but culottes have a tendency to ride up!");
    final Object subscriber =
        new Object() {
          @Subscribe
          public void throwExceptionOn(String message) {
            throw exception;
          }
        };
    eventBus.register(subscriber);
    eventBus.post(EVENT);

    assertEquals("Cause should be available.", exception, handler.exception);

	ch3 := make(chan Maskable, 1)
	doneCh := make(chan struct{})
	defer close(doneCh)
	if err := ps.Subscribe(MaskAll, ch1, doneCh, nil); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if err := ps.Subscribe(MaskAll, ch2, doneCh, nil); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if err := ps.Subscribe(MaskAll, ch3, doneCh, nil); err == nil {
		t.Fatalf("unexpected nil err")
	}
}

    @Subscribe
    public void notOverriddenInSubclass(Object o) {
      notOverriddenInSubclassEvents.add(o);
    }

    @Subscribe
    public void overriddenNotAnnotatedInSubclass(Object o) {
      overriddenNotAnnotatedInSubclassEvents.add(o);
    }

    @Subscribe
    public void overriddenAndAnnotatedInSubclass(Object o) {

import com.google.common.eventbus.Subscribe;
import com.google.common.eventbus.outside.DeepInterfaceTest.SubscriberClass;
import java.util.List;

public class DeepInterfaceTest extends AbstractEventBusTest<SubscriberClass> {
  interface Interface1 {
    @Subscribe
    void annotatedIn1(Object o);

    @Subscribe
    void annotatedIn1And2(Object o);

    @Subscribe
    void annotatedIn1And2AndClass(Object o);

  }

  public void testCreate() {
    Subscriber s1 = Subscriber.create(bus, this, getTestSubscriberMethod("recordingMethod"));
    assertThat(s1).isInstanceOf(Subscriber.SynchronizedSubscriber.class);

    // a thread-safe method should not create a synchronized subscriber
    Subscriber s2 = Subscriber.create(bus, this, getTestSubscriberMethod("threadSafeMethod"));
    assertThat(s2).isNotInstanceOf(Subscriber.SynchronizedSubscriber.class);
  }

    for (Entry<Class<?>, Collection<Subscriber>> entry : listenerMethods.asMap().entrySet()) {
      Class<?> eventType = entry.getKey();
      Collection<Subscriber> eventMethodsInListener = entry.getValue();

      CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType);

      if (eventSubscribers == null) {

    Iterator<Subscriber> two = registry.getSubscribers("");
    assertEquals(s1, two.next().target);
    assertEquals(o1, two.next().target);
    assertFalse(two.hasNext());
  }

  public static class StringSubscriber {

    @Subscribe
    public void handle(String s) {}
  }

  public static class IntegerSubscriber {

    @Subscribe
    public void handle(Integer i) {}
  }