/** Returns the delay in nanoseconds until the next execution, or -1L to not reschedule. */
  abstract fun runOnce(): Long

  internal fun initQueue(queue: TaskQueue) {
    if (this.queue === queue) return

    check(this.queue === null) { "task is in multiple queues" }
    this.queue = queue
  }

  override fun toString(): String = name

    // This dispatcher matches the original dispatch behavior of EventBus.

    /** Per-thread queue of events to dispatch. */
    @SuppressWarnings("ThreadLocalUsage") // Each Dispatcher needs its own state.
    private final ThreadLocal<Queue<Event>> queue =
        new ThreadLocal<Queue<Event>>() {
          @Override
          protected Queue<Event> initialValue() {
            return new ArrayDeque<>();
          }
        };

 * incoming messages. But it does not guarantee that the other peer will successfully receive all of
 * its incoming messages.
 *
 * ## Message Queue
 *
 * Messages enqueued with [send] are buffered in an outgoing message queue. This queue has a 16 MiB
 * limit. If a call to [send] would cause the queue to exceed this limit, the web socket will
 * initiate a graceful shutdown (close code 1001) and `send()` will return `false`. No exception is

/**
 * A bounded {@linkplain BlockingQueue blocking queue} backed by an array. This queue orders
 * elements FIFO (first-in-first-out). The head of the queue is that element that has been
 * on the queue the longest time. The tail of the queue is that element that has been on
 * the queue the shortest time. New elements are inserted at the tail of the queue, and the queue
 * retrieval operations obtain elements at the head of the queue.

/**
 * A bounded {@linkplain BlockingQueue blocking queue} backed by an array. This queue orders
 * elements FIFO (first-in-first-out). The head of the queue is that element that has been
 * on the queue the longest time. The tail of the queue is that element that has been on
 * the queue the shortest time. New elements are inserted at the tail of the queue, and the queue
 * retrieval operations obtain elements at the head of the queue.

 * defined as the <i>least</i> element in the queue according to the queue's comparator. But unlike
 * a regular priority queue, the methods {@link #peekLast}, {@link #pollLast} and {@link
 * #removeLast} are also provided, to act on the <i>greatest</i> element in the queue instead.
 *
 * <p>A min-max priority queue can be configured with a maximum size. If so, each time the size of

import java.util.Collection;
import java.util.Queue;

/**
 * A non-blocking queue which automatically evicts elements from the head of the queue when
 * attempting to add new elements onto the queue and it is full. This queue orders elements FIFO
 * (first-in-first-out). This data structure is logically equivalent to a circular buffer (i.e.,
 * cyclic buffer or ring buffer).
 *

import java.util.Collection;
import java.util.Queue;

/**
 * A non-blocking queue which automatically evicts elements from the head of the queue when
 * attempting to add new elements onto the queue and it is full. This queue orders elements FIFO
 * (first-in-first-out). This data structure is logically equivalent to a circular buffer (i.e.,
 * cyclic buffer or ring buffer).
 *

    if (writerTask != null) {
      taskQueue.schedule(writerTask)
    }
  }

  /**
   * Attempts to remove a single frame from a queue and send it. This prefers to write urgent pongs
   * before less urgent messages and close frames. For example, it's possible that a caller will
   * enqueue messages followed by pongs, but this sends pongs followed by messages. Pongs are always
   * written in the order they were enqueued.
   *

import java.util.Queue;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Creates queues, containing sample elements, to be tested.
 *
 * @author Jared Levy
 */
@GwtCompatible
@NullMarked
public interface TestQueueGenerator<E extends @Nullable Object> extends TestCollectionGenerator<E> {
  @Override
  Queue<E> create(Object... elements);