def endpoint1 = queue.newEndpoint()
        def endpoint2 = queue.newEndpoint()

        and:
        queue.dispatch(message1)
        queue.dispatch(message2)
        queue.dispatch(message3)

        when:
        queue.empty(endpoint1)
        def messages1 = []
        endpoint1.take(messages1)
        def messages2 = []
        endpoint2.take(messages2)

        then:

	queue.AddWork(context.TODO(), NewWorkArgs("3", "3"), now, then)
	queue.AddWork(context.TODO(), NewWorkArgs("4", "4"), now, then)
	queue.AddWork(context.TODO(), NewWorkArgs("5", "5"), now, then)
	queue.AddWork(context.TODO(), NewWorkArgs("1", "1"), now, then)
	queue.AddWork(context.TODO(), NewWorkArgs("2", "2"), now, then)
	queue.AddWork(context.TODO(), NewWorkArgs("3", "3"), now, then)
	queue.AddWork(context.TODO(), NewWorkArgs("4", "4"), now, then)

        when:
        async {
            // Successful queue
            workerThread {
                buildOperationExecutor.runAll(worker, { queue ->
                    amountOfWork.times {
                        queue.add(success)
                    }
                })
                successfulQueueCompleted = true
            }
            // Failure queue
            workerThread {
                try {

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

  /**
   * Returns a synchronized (thread-safe) deque backed by the specified deque. In order to guarantee

    delayNanos: Long,
  ) {
    lock.assertHeld()

    val queue = task.queue!!
    check(queue.activeTask === task)

    val cancelActiveTask = queue.cancelActiveTask
    queue.cancelActiveTask = false
    queue.activeTask = null
    busyQueues.remove(queue)

    if (delayNanos != -1L && !cancelActiveTask && !queue.shutdown) {
      queue.scheduleAndDecide(task, delayNanos, recurrence = true)
    }

            println("Execution 3 running!")
            thread.blockUntil.execution3Released
        })

        expect:
        async {
            queue.submit(execution1)
            queue.submit(execution2)
            queue.submit(execution3)

            thread.blockUntil.execution1Started
            thread.blockUntil.execution2Started
            thread.blockUntil.execution3Started

					qs.qCfg.Name, now.Format(nsTimeFmt), qs.currentR, r.descr1, r.descr2, r.workEstimate.MaxSeats(), r.queue.index,
					r.queue.nextDispatchR, actualServiceDuration.Seconds(), r.queue.requestsWaiting.Length(), r.queue.requestsWaiting.QueueSum(), r.queue.requestsExecuting.Len(), r.queue.seatsInUse)
			} else {

 * 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

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

    /** Per-thread queue of events to dispatch. */
    private final ThreadLocal<Queue<Event>> queue =
        new ThreadLocal<Queue<Event>>() {
          @Override
          protected Queue<Event> initialValue() {
            return Queues.newArrayDeque();
          }
        };

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

    /** Per-thread queue of events to dispatch. */
    private final ThreadLocal<Queue<Event>> queue =
        new ThreadLocal<Queue<Event>>() {
          @Override
          protected Queue<Event> initialValue() {
            return Queues.newArrayDeque();
          }
        };