}

        ArtifactTransferEvent event = wrap(transferEvent);
        event.setDataBuffer(buffer);
        event.setDataOffset(0);
        event.setDataLength(length);
        event.setTransferredBytes(transferred);

        listener.transferProgress(event);
    }

    @Override
    public void transferStarted(TransferEvent transferEvent) {

  ) : ConnectionEvent() {
    override fun closes(event: ConnectionEvent): Boolean = event is ConnectStart && call == event.call && route == event.route
  }

  data class ConnectEnd(
    override val timestampNs: Long,
    override val connection: Connection,
    val route: Route,
    val call: Call,
  ) : ConnectionEvent() {

  }

  @Test
  fun idCleared() {
    consumeEvents(
      """
      |data: first event
      |id: 1
      |
      |data: second event
      |id
      |
      |data: third event
      |
      |
      """.trimMargin(),
    )
    assertThat(callbacks.remove()).isEqualTo(Event("1", null, "first event"))

public class SubscriberExceptionContext {
  private final EventBus eventBus;
  private final Object event;
  private final Object subscriber;
  private final Method subscriberMethod;

  /**
   * @param eventBus The {@link EventBus} that handled the event and the subscriber. Useful for
   *     broadcasting a new event based on the error.
   * @param event The event object that caused the subscriber to throw.
   * @param subscriber The source subscriber context.

        // Test minimum value
        event.setVersionNo(Long.MIN_VALUE);
        assertEquals(Long.valueOf(Long.MIN_VALUE), event.getVersionNo());

        // Test zero
        event.setVersionNo(0L);
        assertEquals(Long.valueOf(0L), event.getVersionNo());

        // Test maximum value
        event.setVersionNo(Long.MAX_VALUE);
        assertEquals(Long.valueOf(Long.MAX_VALUE), event.getVersionNo());
    }

    override fun closes(event: CallEvent): Boolean = event is CallStart && call == event.call
  }

  data class CallFailed(
    override val timestampNs: Long,
    override val call: Call,
    val ioe: IOException,
  ) : CallEvent() {
    override fun closes(event: CallEvent): Boolean = event is CallStart && call == event.call
  }

  data class Canceled(
    override val timestampNs: Long,

  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(
    cls: Class<out IOException?>?,
    vararg messages: String,
  ) {
    val event = nextEvent() as Failure

          }
        };

    @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()) {

    try {
      while (true) {
        val event = takeEvent()
        if (eventClass.isInstance(event)) {
          return eventClass.cast(event)
        }
      }
    } catch (e: NoSuchElementException) {
      throw AssertionError("full event sequence: $fullEventSequence", e)
    }
  }

  /**
   * Remove and return the next event from the recorded sequence.
   *

      ?: throw AssertionError("Timed out waiting for event.")

  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() {