/**
     * Deletes all URL queues.
     */
    void deleteAll();

    /**
     * Offers all URL queues.
     *
     * @param sessionId The session ID.
     * @param newUrlQueueList The list of new URL queues.
     */
    void offerAll(String sessionId, List<QUEUE> newUrlQueueList);

    /**
     * Polls a URL queue.
     *
     * @param sessionId The session ID.

 *   <li>Deleting URL queues associated with a session.</li>
 *   <li>Deleting all URL queues.</li>
 *   <li>Offering a list of URLs to the queue, ensuring duplicates are not added.</li>
 *   <li>Polling (retrieving and removing) a URL from the queue.</li>
 *   <li>Saving the session (currently a no-op).</li>
 *   <li>Checking if a URL has already been visited.</li>
 *   <li>Generating URL queues from a previous session's access results.</li>

  /** 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

        super();
    }

    /**
     * Clears all URL queues and session data.
     */
    public void clear() {
        urlQueueMap.clear();
        sessionMap.clear();
    }

    /**
     * Returns the URL queue for the specified session ID.
     * Creates a new queue if one doesn't exist.
     * @param sessionId the session ID
     * @return the URL queue for the session
     */

 *
 * Work within queues is not concurrent. This is equivalent to each queue having a dedicated thread
 * for its work; in practice a set of queues may share a set of threads to save resources.
 */
class TaskQueue internal constructor(
  internal val taskRunner: TaskRunner,
  internal val name: String,
) {
  internal var shutdown = false

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);

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);

    // 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<>();
          }
        };

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 ok {
			for i, queue := range config.QueueList {
				// Remove ARN not found queues, because we previously allowed
				// adding unexpected entries into the config.
				//
				// With newer config disallowing changing / turning off
				// notification targets without removing ARN in notification
				// configuration we won't see this problem anymore.
				if reflect.DeepEqual(queue.ARN, arnErr.ARN) && i < len(config.QueueList) {