limited:
    assuredConcurrencyShares: 1
    borrowingLimitPercent: 4
    lendablePercent: 3
    limitResponse:
      queuing:
        handSize: 2
        queueLengthLimit: 3
        queues: 1
      type: typeValue
  type: typeValue
status:
  conditions:
  - lastTransitionTime: "2003-01-01T01:01:01Z"
    message: messageValue
    reason: reasonValue
    status: statusValue

        received.await()
        daemonConnection.stop()

        then:
        1 * handler.run() >> { received.countDown(); throw new RuntimeException() }
        0 * handler._
    }

    def "receive queues incoming messages"() {
        when:
        connection.queueIncoming("incoming1")
        connection.queueIncoming("incoming2")
        connection.queueIncoming("incoming3")
        def result = []

    final L listener;
    final Executor executor;

    @GuardedBy("this")
    final Queue<ListenerCallQueue.Event<L>> waitQueue = Queues.newArrayDeque();

    @GuardedBy("this")
    final Queue<Object> labelQueue = Queues.newArrayDeque();

    @GuardedBy("this")
    boolean isThreadScheduled;

    PerListenerQueue(L listener, Executor executor) {

import java.util.Queue;
import org.checkerframework.checker.nullness.qual.Nullable;

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

	backend.ProcessEvents(newEvents(1)...)
	tc := make(chan time.Time)
	wg := sync.WaitGroup{}
	wg.Add(1)
	go func() {
		defer wg.Done()
		batch = backend.collectEvents(tc, nil)
	}()
	// Wait for the queued events to be collected.
	err := wait.Poll(time.Second, wait.ForeverTestTimeout, func() (bool, error) {
		return len(backend.buffer) == 0, nil
	})
	require.NoError(t, err)

	tc <- time.Now() // Trigger "timeout"

    WeakValueReferenceImpl(ReferenceQueue<V> queue, V referent, E entry) {
      super(referent, queue);
      this.entry = entry;
    }

    @Override
    public E getEntry() {
      return entry;
    }

    @Override
    public WeakValueReference<K, V, E> copyFor(ReferenceQueue<V> queue, E entry) {
      return new WeakValueReferenceImpl<>(queue, get(), entry);
    }
  }

  /**

import (
	"io"
	"regexp/syntax"
	"sync"
)

// A queue is a 'sparse array' holding pending threads of execution.
// See https://research.swtch.com/2008/03/using-uninitialized-memory-for-fun-and.html
type queue struct {
	sparse []uint32
	dense  []entry
}

// An entry is an entry on a queue.
// It holds both the instruction pc and the actual thread.
// Some queue entries are just place holders so that the machine

	checkReceiver("init", t, obj, false)

	// Run once, immediately, and queue a retry
	// rel=0ms
	obj.setRetryFn(func() { runner.RetryAfter(5 * time.Second) })
	runner.Run()
	waitForRunWithRetry("first run", t, timer, obj, 5*time.Second)

	// Nothing happens...
	timer.advance(time.Second) // rel=1000ms
	waitForNothing("minInterval, nothing queued", t, timer, obj)

	// After retryInterval, function is called

 * on single thread, keeping the listener logic simple. This listener also blocks on last transfer event to allow
 * output to perform possible cleanup. It spawns a daemon thread to consume queued events that may fall in even
 * concurrently.
 *
 * @since 4.0.0
 */
public final class SimplexTransferListener extends AbstractTransferListener {

        }

        public boolean isComplete() {
            return complete;
        }
    }

    /**
     * Queues the task for execution, but does not schedule it. Use {@link org.gradle.internal.buildtree.BuildTreeWorkGraph#scheduleWork(Consumer)} to schedule queued tasks.
     */
    void queueForExecution();

    /**