public class StringCatcher {
  private List<String> events = Lists.newArrayList();

  @Subscribe
  public void hereHaveAString(@Nullable String string) {
    events.add(string);
  }

  public void methodWithoutAnnotation(@Nullable String string) {
    Assert.fail("Event bus must not call methods without @Subscribe!");
  }

  public List<String> getEvents() {
    return events;
  }

    List<DeadEvent> events = catcher.getEvents();
    assertEquals("One dead event should be delivered.", 1, events.size());
    assertEquals("The dead event should wrap the original event.", EVENT, events.get(0).getEvent());
  }

  public void testDeadEventPosting() {
    GhostCatcher catcher = new GhostCatcher();
    bus.register(catcher);

    bus.post(new DeadEvent(this, EVENT));

    List<DeadEvent> events = catcher.getEvents();

    List<DeadEvent> events = catcher.getEvents();
    assertEquals("One dead event should be delivered.", 1, events.size());
    assertEquals("The dead event should wrap the original event.", EVENT, events.get(0).getEvent());
  }

  public void testDeadEventPosting() {
    GhostCatcher catcher = new GhostCatcher();
    bus.register(catcher);

    bus.post(new DeadEvent(this, EVENT));

    List<DeadEvent> events = catcher.getEvents();

    return NANOSECONDS.toMillis(stopwatch.instant - startTime);
  }

  private void assertEvents(String... events) {
    assertEquals(Arrays.toString(events), stopwatch.readEventsAndClear());
  }

  /**
   * The stopwatch gathers events and presents them as strings. R0.6 means a delay of 0.6 seconds
   * caused by the (R)ateLimiter U1.0 means the (U)ser caused the stopwatch to sleep for a second.

 * events fired during collection.
 *
 * @since 3.9.0
 */
class ReverseTreeRepositoryListener extends AbstractRepositoryListener {
    @Override
    public void artifactResolved(RepositoryEvent event) {
        requireNonNull(event, "event cannot be null");

        if (!isLocalRepositoryArtifactOrMissing(event.getSession(), event.getArtifact())) {
            return;
        }

import org.apache.maven.api.annotations.Nonnull;

/**
 * A listener for session events.
 * TODO: open this to other events like similar to {@code org.apache.maven.eventspy.EventSpy}
 *
 * @since 4.0.0
 */
@Experimental
@FunctionalInterface
@Consumer
public interface Listener {
    void onEvent(@Nonnull Event event);

import org.apache.maven.api.annotations.Nonnull;

/**
 * Event sent by maven during various phases of the build process.
 * Such events can be listened to using {@link Listener}s objects
 * registered in the {@link Session}.
 *
 * @since 4.0.0
 */
@Experimental
public interface Event {

    /**
     * Gets the type of the event.
     *
     * @return the type of the event, never {@code null}
     */
    @Nonnull

    }

    @Override
    public void projectSkipped(ExecutionEvent event) {
        dispatcher.onEvent(event);
        delegate.projectSkipped(event);
    }

    @Override
    public void projectStarted(ExecutionEvent event) {
        dispatcher.onEvent(event);
        delegate.projectStarted(event);
    }

    @Override
    public void projectSucceeded(ExecutionEvent event) {
        dispatcher.onEvent(event);

        ForkedProjectStarted,
        ForkedProjectSucceeded,
        ForkedProjectFailed,
    }

    /**
     * Gets the type of the event.
     *
     * @return The type of the event, never {@code null}.
     */
    Type getType();

    /**
     * Gets the session from which this event originates.
     *
     * @return The current session, never {@code null}.
     */
    MavenSession getSession();

    /**

   * all subscribers in the order they are posted.
   *
   * <p>When all subscribers are dispatched to using a <i>direct</i> executor (which dispatches on
   * the same thread that posts the event), this yields a breadth-first dispatch order on each
   * thread. That is, all subscribers to a single event A will be called before any subscribers to