otherArchives = objectFactory.setProperty(String.class);
    }

    @Override
    public Property<String> getName() {
        return name;
    }

    @Override
    public Property<String> getSubscribe() {
        return subscribe;
    }

    @Override
    public Property<String> getUnsubscribe() {
        return unsubscribe;
    }

    @Override
    public Property<String> getPost() {

    /**
     * The name of this mailing list.
     */
    Property<String> getName();

    /**
     * The email address or link that can be used to subscribe to this mailing list.
     */
    Property<String> getSubscribe();

    /**
     * The email address or link that can be used to subscribe to this mailing list.
     */
    Property<String> getUnsubscribe();

    /**

    }

    private static MailingList convertMailingList(MavenPomMailingList source) {
        MailingList target = new MailingList();
        target.setName(source.getName().getOrNull());
        target.setSubscribe(source.getSubscribe().getOrNull());
        target.setUnsubscribe(source.getUnsubscribe().getOrNull());
        target.setPost(source.getPost().getOrNull());
        target.setArchive(source.getArchive().getOrNull());

  }

  public void testNotOverriddenInSubclass() {
    assertThat(getSubscriber().notOverriddenInSubclassEvents).contains(EVENT);
  }

  public void testOverriddenNotAnnotatedInSubclass() {
    assertThat(getSubscriber().overriddenNotAnnotatedInSubclassEvents).contains(EVENT);
  }

  public void testDifferentlyOverriddenNotAnnotatedInSubclass() {
    assertThat(getSubscriber().differentlyOverriddenNotAnnotatedInSubclassGoodEvents)

  public void testNeitherOverriddenNorAnnotated() {
    assertThat(getSubscriber().neitherOverriddenNorAnnotatedEvents).isEmpty();
  }

  public void testOverriddenInSubclassNowhereAnnotated() {
    assertThat(getSubscriber().overriddenInSubclassNowhereAnnotatedEvents).isEmpty();
  }

  public void testOverriddenAndAnnotatedInSubclass() {
    assertThat(getSubscriber().overriddenAndAnnotatedInSubclassEvents).contains(EVENT);
  }

 * @author Louis Wasserman
 */
abstract class AbstractEventBusTest<H> extends TestCase {
  static final Object EVENT = new Object();

  abstract H createSubscriber();

  private @Nullable H subscriber;

  H getSubscriber() {
    return subscriber;
  }

  @Override
  protected void setUp() throws Exception {
    subscriber = createSubscriber();
    EventBus bus = new EventBus();
    bus.register(subscriber);

  /** @return The event object that caused the subscriber to throw. */
  public Object getEvent() {
    return event;
  }

  /** @return The object context that the subscriber was called on. */
  public Object getSubscriber() {
    return subscriber;
  }

  /** @return The subscribed method that threw the exception. */
  public Method getSubscriberMethod() {
    return subscriberMethod;
  }

  /** @return The event object that caused the subscriber to throw. */
  public Object getEvent() {
    return event;
  }

  /** @return The object context that the subscriber was called on. */
  public Object getSubscriber() {
    return subscriber;
  }

  /** @return The subscribed method that threw the exception. */
  public Method getSubscriberMethod() {
    return subscriberMethod;
  }

          + method.getName()
          + '('
          + method.getParameterTypes()[0].getName()
          + ')'
          + " on subscriber "
          + context.getSubscriber()
          + " when dispatching event: "
          + context.getEvent();
    }
  }

          + method.getName()
          + '('
          + method.getParameterTypes()[0].getName()
          + ')'
          + " on subscriber "
          + context.getSubscriber()
          + " when dispatching event: "
          + context.getEvent();
    }
  }