assertTrue(queue.add("one"));
    assertTrue(queue.add("two"));
    assertTrue(queue.add("three"));
    assertEquals("one", queue.element());
    assertEquals("one", queue.peek());
    assertEquals(3, queue.size());
    assertEquals(0, queue.remainingCapacity());

    assertTrue(queue.add("four"));
    assertEquals("two", queue.element());
    assertEquals("two", queue.peek());
    assertEquals(3, queue.size());

   *
   * @param queue the queue to be wrapped in a synchronized view
   * @return a synchronized view of the specified queue
   * @since 14.0
   */
  @J2ktIncompatible // Synchronized
  public static <E extends @Nullable Object> Queue<E> synchronizedQueue(Queue<E> queue) {
    return Synchronized.queue(queue, null);
  }

  /**

        UrlQueueImpl<Long> queue = new UrlQueueImpl<>();
        assertNotNull(queue);
        assertNull(queue.getId());
        assertNull(queue.getSessionId());
        assertNull(queue.getMethod());
        assertNull(queue.getUrl());
        assertNull(queue.getMetaData());
        assertNull(queue.getEncoding());
        assertNull(queue.getParentUrl());
        assertNull(queue.getDepth());

	// Ext for test item
	testItemExt = ".test"
)

// Initialize the queue store.
func setUpQueueStore(directory string, limit uint64) (Store[TestItem], error) {
	queueStore := NewQueueStore[TestItem](queueDir, limit, testItemExt)
	if oErr := queueStore.Open(); oErr != nil {
		return nil, oErr
	}
	return queueStore, nil
}

// Tear down queue store.
func tearDownQueueStore() error {
	return os.RemoveAll(queueDir)
}

    assertEquals(6, queue.size());
    assertEquals(8, queue.capacity());
    checkUnbounded(queue);
    checkNatural(queue);
  }

  public void testCreation_maximumSize_withContents() {
    MinMaxPriorityQueue<Integer> queue =
        rawtypeToWildcard(MinMaxPriorityQueue.maximumSize(42)).create(NUMBERS);
    assertEquals(6, queue.size());
    assertEquals(11, queue.capacity());
    assertEquals(42, queue.maximumSize);

   *
   * @param queue the queue to be wrapped in a synchronized view
   * @return a synchronized view of the specified queue
   * @since 14.0
   */
  @J2ktIncompatible // Synchronized
  public static <E extends @Nullable Object> Queue<E> synchronizedQueue(Queue<E> queue) {
    return Synchronized.queue(queue, null);
  }

  /**

 * }
 * </pre>
 */
public class ESSourceReader implements DocumentReader {
    private static final Logger logger = LogManager.getLogger(ESSourceReader.class);

    /** Queue of documents. */
    protected final Queue<Map<String, Object>> queue = new ConcurrentLinkedQueue<>();
    /** Flag indicating if reading is finished. */
    protected final AtomicBoolean isFinished = new AtomicBoolean(false);

    /** OpenSearch client. */

        for (UrlQueueImpl<Long> queue : queueList) {
            assertEquals(sessionId, queue.getSessionId());
            assertEquals(Integer.valueOf(0), queue.getDepth());
            assertNotNull(queue.getCreateTime());

            if ("https://example.com/page1".equals(queue.getUrl())) {
                foundPage1 = true;
                assertEquals("GET", queue.getMethod());

            // Default constructor
        }

        /**
         * The queue for URLs waiting to be crawled.
         */
        protected Queue<OpenSearchUrlQueue> waitingQueue = new ConcurrentLinkedQueue<>();

        /**
         * The queue for URLs currently being crawled.
         */
        protected Queue<OpenSearchUrlQueue> crawlingQueue = new ConcurrentLinkedQueue<>();
    }

    /**

	Events []Name `xml:"Event" json:"Event"`
}

// Queue - represents elements inside <QueueConfiguration>
type Queue struct {
	common
	ARN ARN `xml:"Queue"`
}

// UnmarshalXML - decodes XML data.
func (q *Queue) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	// Make subtype to avoid recursive UnmarshalXML().
	type queue Queue
	parsedQueue := queue{}