// Create different implementations
        SearchLogEvent event1 = new TestSearchLogEvent("id1", 1L, "type1");
        SearchLogEvent event2 = new NullSearchLogEvent();
        SearchLogEvent event3 = new EmptySearchLogEvent();

        // Test polymorphic behavior
        SearchLogEvent[] events = { event1, event2, event3 };

        for (SearchLogEvent event : events) {
            // All methods should be callable without exceptions

                .build();

        LogEvent event3 = Log4jLogEvent.newBuilder()
                .setLoggerName("third.logger")
                .setLevel(Level.ERROR)
                .setMessage(new SimpleMessage("test message 3"))
                .build();

        LogEvent result1 = policy.rewrite(event1);
        LogEvent result2 = policy.rewrite(event2);
        LogEvent result3 = policy.rewrite(event3);

  }

  /**
   * Enqueues an event to be run on currently known listeners.
   *
   * <p>The {@code toString} method of the Event itself will be used to describe the event in the
   * case of an error.
   *
   * @param event the callback to execute on {@link #dispatch}
   */
  public void enqueue(Event<L> event) {
    enqueueHelper(event, event);
  }

  /**

  }

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

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

    List<DeadEvent> events = catcher.getEvents();
    assertEquals("The explicit DeadEvent should be delivered.", 1, events.size());
    assertEquals("The dead event must not be re-wrapped.", EVENT, events.get(0).getEvent());

  }

  fun assertExhausted() {
    assertThat(events).isEmpty()
  }

  fun assertOpen(): WebSocket {
    val event = nextEvent() as Open
    return event.webSocket
  }

  fun assertFailure(t: Throwable?) {
    val event = nextEvent() as Failure
    assertThat(event.response).isNull()
    assertThat(event.t).isSameAs(t)
  }

  fun assertFailure(

import java.net.Proxy

/**
 * Listener for metrics events. Extend this class to monitor the quantity, size, and duration of
 * your application's HTTP calls.
 *
 * All start/connect/acquire events will eventually receive a matching end/release event, either
 * successful (non-null parameters), or failed (non-null throwable). The first common parameters of
 * each event pair are used to link the event in case of concurrent or repeated events e.g.

  fun assertExhausted() {
    assertThat(events).isEmpty()
  }

  fun assertEvent(
    id: String?,
    type: String?,
    data: String,
  ) {
    assertThat(nextEvent()).isEqualTo(Event(id, type, data))
  }

  fun assertOpen(): EventSource {
    val event = nextEvent() as Open
    return event.eventSource
  }

  fun assertClose() {
    nextEvent() as Closed
  }

  fun assertFailure(

    assertEquals(
        "ReentrantEventHater expected 2 events",
        Lists.<Object>newArrayList(FIRST, SECOND),
        hater.eventsReceived);
  }

  public class ReentrantEventsHater {
    boolean ready = true;
    final List<Object> eventsReceived = new ArrayList<>();

    @Subscribe
    public void listenForStrings(String event) {
      eventsReceived.add(event);
      ready = false;
      try {

          }
        };

    @Override
    void dispatch(Object event, Iterator<Subscriber> subscribers) {
      checkNotNull(event);
      checkNotNull(subscribers);
      // requireNonNull accommodates Android's @RecentlyNullable annotation on ThreadLocal.get
      Queue<Event> queueForThread = requireNonNull(queue.get());
      queueForThread.offer(new Event(event, subscribers));

      if (!dispatching.get()) {

    }

    /**
     * Rewrites log events by converting ERROR level to WARN level for matching loggers.
     *
     * @param event the log event to potentially rewrite
     * @return the original event or a new event with WARN level if conversion applied
     */
    @Override
    public LogEvent rewrite(final LogEvent event) {
        final String loggerName = event.getLoggerName();
        if (loggerName == null) {