gt:             executor.execute(new CheckedRunnable() {
context: /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  /*
   * This file is available under and governed by the GNU General Public
   * License version 2 only, as published by the Free Software Foundation.
   * However, the following notice accompanied the original version of this
   * file:
   *
   * Written by Doug Lea with assistance from members of JCP JSR-166
   * Expert Group and released to the public domain, as explained at
   * http://creativecommons.org/publicdomain/zero/1.0/
   * Other contributors include Andrew Wright, Jeffrey Hayes,
   * Pat Fisher, Mike Judd.
   */
  
  import static java.util.concurrent.TimeUnit.MILLISECONDS;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.NoSuchElementException;
  import java.util.Queue;
  import java.util.concurrent.BlockingQueue;
  import java.util.concurrent.CountDownLatch;
  import java.util.concurrent.Executors;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.LinkedBlockingQueue;
  
  import junit.framework.Test;
  
  public class LinkedBlockingQueueTest extends JSR166TestCase {
  
      public static class Unbounded extends BlockingQueueTest {
          protected BlockingQueue emptyCollection() {
              return new LinkedBlockingQueue();
          }
      }
  
      public static class Bounded extends BlockingQueueTest {
          protected BlockingQueue emptyCollection() {
              return new LinkedBlockingQueue(SIZE);
          }
      }
  
      public static void main(String[] args) {
          main(suite(), args);
      }
  
      public static Test suite() {
          class Implementation implements CollectionImplementation {
              public Class<?> klazz() { return LinkedBlockingQueue.class; }
              public Collection emptyCollection() { return new LinkedBlockingQueue(); }
              public Object makeElement(int i) { return i; }
              public boolean isConcurrent() { return true; }
              public boolean permitsNulls() { return false; }
          }
          return newTestSuite(LinkedBlockingQueueTest.class,
                              new Unbounded().testSuite(),
                              new Bounded().testSuite(),
                              CollectionTest.testSuite(new Implementation()));
      }
  
      /**
       * Returns a new queue of given size containing consecutive
       * Integers 0 ... n - 1.
       */
      private static LinkedBlockingQueue<Integer> populatedQueue(int n) {
          LinkedBlockingQueue<Integer> q = new LinkedBlockingQueue<>(n);
          assertTrue(q.isEmpty());
          for (int i = 0; i < n; i++)
              assertTrue(q.offer(new Integer(i)));
          assertFalse(q.isEmpty());
          assertEquals(0, q.remainingCapacity());
          assertEquals(n, q.size());
          assertEquals((Integer) 0, q.peek());
          return q;
      }
  
      /**
       * A new queue has the indicated capacity, or Integer.MAX_VALUE if
       * none given
       */
      public void testConstructor1() {
          assertEquals(SIZE, new LinkedBlockingQueue(SIZE).remainingCapacity());
          assertEquals(Integer.MAX_VALUE, new LinkedBlockingQueue().remainingCapacity());
      }
  
      /**
       * Constructor throws IllegalArgumentException if capacity argument nonpositive
       */
      public void testConstructor2() {
          try {
              new LinkedBlockingQueue(0);
              shouldThrow();
          } catch (IllegalArgumentException success) {}
      }
  
      /**
       * Initializing from null Collection throws NullPointerException
       */
      public void testConstructor3() {
          try {
              new LinkedBlockingQueue(null);
              shouldThrow();
          } catch (NullPointerException success) {}
      }
  
      /**
       * Initializing from Collection of null elements throws NullPointerException
       */
      public void testConstructor4() {
          Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
          try {
              new LinkedBlockingQueue(elements);
              shouldThrow();
          } catch (NullPointerException success) {}
      }
  
      /**
       * Initializing from Collection with some null elements throws
       * NullPointerException
       */
      public void testConstructor5() {
          Integer[] ints = new Integer[SIZE];
          for (int i = 0; i < SIZE - 1; ++i)
              ints[i] = new Integer(i);
          Collection<Integer> elements = Arrays.asList(ints);
          try {
              new LinkedBlockingQueue(elements);
              shouldThrow();
          } catch (NullPointerException success) {}
      }
  
      /**
       * Queue contains all elements of collection used to initialize
       */
      public void testConstructor6() {
          Integer[] ints = new Integer[SIZE];
          for (int i = 0; i < SIZE; ++i)
              ints[i] = new Integer(i);
          LinkedBlockingQueue q = new LinkedBlockingQueue(Arrays.asList(ints));
          for (int i = 0; i < SIZE; ++i)
              assertEquals(ints[i], q.poll());
      }
  
      /**
       * Queue transitions from empty to full when elements added
       */
      public void testEmptyFull() {
          LinkedBlockingQueue q = new LinkedBlockingQueue(2);
          assertTrue(q.isEmpty());
          assertEquals("should have room for 2", 2, q.remainingCapacity());
          q.add(one);
          assertFalse(q.isEmpty());
          q.add(two);
          assertFalse(q.isEmpty());
          assertEquals(0, q.remainingCapacity());
          assertFalse(q.offer(three));
      }
  
      /**
       * remainingCapacity decreases on add, increases on remove
       */
      public void testRemainingCapacity() {
          BlockingQueue q = populatedQueue(SIZE);
          for (int i = 0; i < SIZE; ++i) {
              assertEquals(i, q.remainingCapacity());
              assertEquals(SIZE, q.size() + q.remainingCapacity());
              assertEquals(i, q.remove());
          }
          for (int i = 0; i < SIZE; ++i) {
              assertEquals(SIZE - i, q.remainingCapacity());
              assertEquals(SIZE, q.size() + q.remainingCapacity());
              assertTrue(q.add(i));
          }
      }
  
      /**
       * Offer succeeds if not full; fails if full
       */
      public void testOffer() {
          LinkedBlockingQueue q = new LinkedBlockingQueue(1);
          assertTrue(q.offer(zero));
          assertFalse(q.offer(one));
      }
  
      /**
       * add succeeds if not full; throws IllegalStateException if full
       */
      public void testAdd() {
          LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
          for (int i = 0; i < SIZE; ++i)
              assertTrue(q.add(new Integer(i)));
          assertEquals(0, q.remainingCapacity());
          try {
              q.add(new Integer(SIZE));
              shouldThrow();
          } catch (IllegalStateException success) {}
      }
  
      /**
       * addAll(this) throws IllegalArgumentException
       */
      public void testAddAllSelf() {
          LinkedBlockingQueue q = populatedQueue(SIZE);
          try {
              q.addAll(q);
              shouldThrow();
          } catch (IllegalArgumentException success) {}
      }
  
      /**
       * addAll of a collection with any null elements throws NPE after
       * possibly adding some elements
       */
      public void testAddAll3() {
          LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
          Integer[] ints = new Integer[SIZE];
          for (int i = 0; i < SIZE - 1; ++i)
              ints[i] = new Integer(i);
          Collection<Integer> elements = Arrays.asList(ints);
          try {
              q.addAll(elements);
              shouldThrow();
          } catch (NullPointerException success) {}
      }
  
      /**
       * addAll throws IllegalStateException if not enough room
       */
      public void testAddAll4() {
          LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE - 1);
          Integer[] ints = new Integer[SIZE];
          for (int i = 0; i < SIZE; ++i)
              ints[i] = new Integer(i);
          Collection<Integer> elements = Arrays.asList(ints);
          try {
              q.addAll(elements);
              shouldThrow();
          } catch (IllegalStateException success) {}
      }
  
      /**
       * Queue contains all elements, in traversal order, of successful addAll
       */
      public void testAddAll5() {
          Integer[] empty = new Integer[0];
          Integer[] ints = new Integer[SIZE];
          for (int i = 0; i < SIZE; ++i)
              ints[i] = new Integer(i);
          LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
          assertFalse(q.addAll(Arrays.asList(empty)));
          assertTrue(q.addAll(Arrays.asList(ints)));
          for (int i = 0; i < SIZE; ++i)
              assertEquals(ints[i], q.poll());
      }
  
      /**
       * all elements successfully put are contained
       */
      public void testPut() throws InterruptedException {
          LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
          for (int i = 0; i < SIZE; ++i) {
              Integer x = new Integer(i);
              q.put(x);
              assertTrue(q.contains(x));
          }
          assertEquals(0, q.remainingCapacity());
      }
  
      /**
       * put blocks interruptibly if full
       */
      public void testBlockingPut() throws InterruptedException {
          final LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
          Thread t = newStartedThread(new CheckedRunnable() {
              public void realRun() throws InterruptedException {
                  for (int i = 0; i < SIZE; ++i)
                      q.put(i);
                  assertEquals(SIZE, q.size());
                  assertEquals(0, q.remainingCapacity());
  
                  Thread.currentThread().interrupt();
                  try {
                      q.put(99);
                      shouldThrow();
                  } catch (InterruptedException success) {}
                  assertFalse(Thread.interrupted());
  
                  pleaseInterrupt.countDown();
                  try {
                      q.put(99);
                      shouldThrow();
                  } catch (InterruptedException success) {}
                  assertFalse(Thread.interrupted());
              }});
  
          await(pleaseInterrupt);
          if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
          t.interrupt();
          awaitTermination(t);
          assertEquals(SIZE, q.size());
          assertEquals(0, q.remainingCapacity());
      }
  
      /**
       * put blocks interruptibly waiting for take when full
       */
      public void testPutWithTake() throws InterruptedException {
          final int capacity = 2;
          final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
          final CountDownLatch pleaseTake = new CountDownLatch(1);
          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
          Thread t = newStartedThread(new CheckedRunnable() {
              public void realRun() throws InterruptedException {
                  for (int i = 0; i < capacity; i++)
                      q.put(i);
                  pleaseTake.countDown();
                  q.put(86);
  
                  Thread.currentThread().interrupt();
                  try {
                      q.put(99);
                      shouldThrow();
                  } catch (InterruptedException success) {}
                  assertFalse(Thread.interrupted());
  
                  pleaseInterrupt.countDown();
                  try {
                      q.put(99);
                      shouldThrow();
                  } catch (InterruptedException success) {}
                  assertFalse(Thread.interrupted());
              }});
  
          await(pleaseTake);
          assertEquals(0, q.remainingCapacity());
          assertEquals(0, q.take());
  
          await(pleaseInterrupt);
          if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
          t.interrupt();
          awaitTermination(t);
          assertEquals(0, q.remainingCapacity());
      }
  
      /**
       * timed offer times out if full and elements not taken
       */
      public void testTimedOffer() {
          final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
          Thread t = newStartedThread(new CheckedRunnable() {
              public void realRun() throws InterruptedException {
                  q.put(new Object());
                  q.put(new Object());
                  long startTime = System.nanoTime();
  
                  assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
  
                  Thread.currentThread().interrupt();
                  try {
                      q.offer(new Object(), randomTimeout(), randomTimeUnit());
                      shouldThrow();
                  } catch (InterruptedException success) {}
                  assertFalse(Thread.interrupted());
  
                  pleaseInterrupt.countDown();
                  try {
                      q.offer(new Object(), LONGER_DELAY_MS, MILLISECONDS);
                      shouldThrow();
                  } catch (InterruptedException success) {}
                  assertFalse(Thread.interrupted());
              }});
  
          await(pleaseInterrupt);
          if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
          t.interrupt();
          awaitTermination(t);
      }
  
      /**
       * take retrieves elements in FIFO order
       */
      public void testTake() throws InterruptedException {
          LinkedBlockingQueue q = populatedQueue(SIZE);
          for (int i = 0; i < SIZE; ++i) {
              assertEquals(i, q.take());
          }
      }
  
      /**
       * Take removes existing elements until empty, then blocks interruptibly
       */
      public void testBlockingTake() throws InterruptedException {
          final BlockingQueue q = populatedQueue(SIZE);
          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
          Thread t = newStartedThread(new CheckedRunnable() {
              public void realRun() throws InterruptedException {
                  for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
  
                  Thread.currentThread().interrupt();
                  try {
                      q.take();
                      shouldThrow();
                  } catch (InterruptedException success) {}
                  assertFalse(Thread.interrupted());
  
                  pleaseInterrupt.countDown();
                  try {
                      q.take();
                      shouldThrow();
                  } catch (InterruptedException success) {}
                  assertFalse(Thread.interrupted());
              }});
  
          await(pleaseInterrupt);
          if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
          t.interrupt();
          awaitTermination(t);
      }
  
      /**
       * poll succeeds unless empty
       */
      public void testPoll() {
          LinkedBlockingQueue q = populatedQueue(SIZE);
          for (int i = 0; i < SIZE; ++i) {
              assertEquals(i, q.poll());
          }
          assertNull(q.poll());
      }
  
      /**
       * timed poll with zero timeout succeeds when non-empty, else times out
       */
      public void testTimedPoll0() throws InterruptedException {
          LinkedBlockingQueue q = populatedQueue(SIZE);
          for (int i = 0; i < SIZE; ++i) {
              assertEquals(i, q.poll(0, MILLISECONDS));
          }
          assertNull(q.poll(0, MILLISECONDS));
      }
  
      /**
       * timed poll with nonzero timeout succeeds when non-empty, else times out
       */
      public void testTimedPoll() throws InterruptedException {
          LinkedBlockingQueue<Integer> q = populatedQueue(SIZE);
          for (int i = 0; i < SIZE; ++i) {
              long startTime = System.nanoTime();
              assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
              assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
          }
          long startTime = System.nanoTime();
          assertNull(q.poll(timeoutMillis(), MILLISECONDS));
          assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
          checkEmpty(q);
      }
  
      /**
       * Interrupted timed poll throws InterruptedException instead of
       * returning timeout status
       */
      public void testInterruptedTimedPoll() throws InterruptedException {
          final BlockingQueue<Integer> q = populatedQueue(SIZE);
          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
          Thread t = newStartedThread(new CheckedRunnable() {
              public void realRun() throws InterruptedException {
                  for (int i = 0; i < SIZE; i++)
                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
  
                  Thread.currentThread().interrupt();
                  try {
                      q.poll(randomTimeout(), randomTimeUnit());
                      shouldThrow();
                  } catch (InterruptedException success) {}
                  assertFalse(Thread.interrupted());
  
                  pleaseInterrupt.countDown();
                  try {
                      q.poll(LONGER_DELAY_MS, MILLISECONDS);
                      shouldThrow();
                  } catch (InterruptedException success) {}
                  assertFalse(Thread.interrupted());
              }});
  
          await(pleaseInterrupt);
          if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
          t.interrupt();
          awaitTermination(t);
          checkEmpty(q);
      }
  
      /**
       * peek returns next element, or null if empty
       */
      public void testPeek() {
          LinkedBlockingQueue q = populatedQueue(SIZE);
          for (int i = 0; i < SIZE; ++i) {
              assertEquals(i, q.peek());
              assertEquals(i, q.poll());
              assertTrue(q.peek() == null ||
                         !q.peek().equals(i));
          }
          assertNull(q.peek());
      }
  
      /**
       * element returns next element, or throws NSEE if empty
       */
      public void testElement() {
          LinkedBlockingQueue q = populatedQueue(SIZE);
          for (int i = 0; i < SIZE; ++i) {
              assertEquals(i, q.element());
              assertEquals(i, q.poll());
          }
          try {
              q.element();
              shouldThrow();
          } catch (NoSuchElementException success) {}
      }
  
      /**
       * remove removes next element, or throws NSEE if empty
       */
      public void testRemove() {
          LinkedBlockingQueue q = populatedQueue(SIZE);
          for (int i = 0; i < SIZE; ++i) {
              assertEquals(i, q.remove());
          }
          try {
              q.remove();
              shouldThrow();
          } catch (NoSuchElementException success) {}
      }
  
      /**
       * An add following remove(x) succeeds
       */
      public void testRemoveElementAndAdd() throws InterruptedException {
          LinkedBlockingQueue q = new LinkedBlockingQueue();
          assertTrue(q.add(new Integer(1)));
          assertTrue(q.add(new Integer(2)));
          assertTrue(q.remove(new Integer(1)));
          assertTrue(q.remove(new Integer(2)));
          assertTrue(q.add(new Integer(3)));
          assertNotNull(q.take());
      }
  
      /**
       * contains(x) reports true when elements added but not yet removed
       */
      public void testContains() {
          LinkedBlockingQueue q = populatedQueue(SIZE);
          for (int i = 0; i < SIZE; ++i) {
              assertTrue(q.contains(new Integer(i)));
              q.poll();
              assertFalse(q.contains(new Integer(i)));
          }
      }
  
      /**
       * clear removes all elements
       */
      public void testClear() {
          LinkedBlockingQueue q = populatedQueue(SIZE);
          q.clear();
          assertTrue(q.isEmpty());
          assertEquals(0, q.size());
          assertEquals(SIZE, q.remainingCapacity());
          q.add(one);
          assertFalse(q.isEmpty());
          assertTrue(q.contains(one));
          q.clear();
          assertTrue(q.isEmpty());
      }
  
      /**
       * containsAll(c) is true when c contains a subset of elements
       */
      public void testContainsAll() {
          LinkedBlockingQueue q = populatedQueue(SIZE);
          LinkedBlockingQueue p = new LinkedBlockingQueue(SIZE);
          for (int i = 0; i < SIZE; ++i) {
              assertTrue(q.containsAll(p));
              assertFalse(p.containsAll(q));
              p.add(new Integer(i));
          }
          assertTrue(p.containsAll(q));
      }
  
      /**
       * retainAll(c) retains only those elements of c and reports true if changed
       */
      public void testRetainAll() {
          LinkedBlockingQueue q = populatedQueue(SIZE);
          LinkedBlockingQueue p = populatedQueue(SIZE);
          for (int i = 0; i < SIZE; ++i) {
              boolean changed = q.retainAll(p);
              if (i == 0)
                  assertFalse(changed);
              else
                  assertTrue(changed);
  
              assertTrue(q.containsAll(p));
              assertEquals(SIZE - i, q.size());
              p.remove();
          }
      }
  
      /**
       * removeAll(c) removes only those elements of c and reports true if changed
       */
      public void testRemoveAll() {
          for (int i = 1; i < SIZE; ++i) {
              LinkedBlockingQueue q = populatedQueue(SIZE);
              LinkedBlockingQueue p = populatedQueue(i);
              assertTrue(q.removeAll(p));
              assertEquals(SIZE - i, q.size());
              for (int j = 0; j < i; ++j) {
                  Integer x = (Integer)(p.remove());
                  assertFalse(q.contains(x));
              }
          }
      }
  
      /**
       * toArray contains all elements in FIFO order
       */
      public void testToArray() {
          LinkedBlockingQueue q = populatedQueue(SIZE);
          Object[] a = q.toArray();
          assertSame(Object[].class, a.getClass());
          for (Object o : a)
              assertSame(o, q.poll());
          assertTrue(q.isEmpty());
      }
  
      /**
       * toArray(a) contains all elements in FIFO order
       */
      public void testToArray2() throws InterruptedException {
          LinkedBlockingQueue<Integer> q = populatedQueue(SIZE);
          Integer[] ints = new Integer[SIZE];
          Integer[] array = q.toArray(ints);
          assertSame(ints, array);
          for (Integer o : ints)
              assertSame(o, q.poll());
          assertTrue(q.isEmpty());
      }
  
      /**
       * toArray(incompatible array type) throws ArrayStoreException
       */
      public void testToArray1_BadArg() {
          LinkedBlockingQueue q = populatedQueue(SIZE);
          try {
              q.toArray(new String[10]);
              shouldThrow();
          } catch (ArrayStoreException success) {}
      }
  
      /**
       * iterator iterates through all elements
       */
      public void testIterator() throws InterruptedException {
          LinkedBlockingQueue q = populatedQueue(SIZE);
          Iterator it = q.iterator();
          int i;
          for (i = 0; it.hasNext(); i++)
              assertTrue(q.contains(it.next()));
          assertEquals(i, SIZE);
          assertIteratorExhausted(it);
  
          it = q.iterator();
          for (i = 0; it.hasNext(); i++)
              assertEquals(it.next(), q.take());
          assertEquals(i, SIZE);
          assertIteratorExhausted(it);
      }
  
      /**
       * iterator of empty collection has no elements
       */
      public void testEmptyIterator() {
          assertIteratorExhausted(new LinkedBlockingQueue().iterator());
      }
  
      /**
       * iterator.remove removes current element
       */
      public void testIteratorRemove() {
          final LinkedBlockingQueue q = new LinkedBlockingQueue(3);
          q.add(two);
          q.add(one);
          q.add(three);
  
          Iterator it = q.iterator();
          it.next();
          it.remove();
  
          it = q.iterator();
          assertSame(it.next(), one);
          assertSame(it.next(), three);
          assertFalse(it.hasNext());
      }
  
      /**
       * iterator ordering is FIFO
       */
      public void testIteratorOrdering() {
          final LinkedBlockingQueue q = new LinkedBlockingQueue(3);
          q.add(one);
          q.add(two);
          q.add(three);
          assertEquals(0, q.remainingCapacity());
          int k = 0;
          for (Iterator it = q.iterator(); it.hasNext();) {
              assertEquals(++k, it.next());
          }
          assertEquals(3, k);
      }
  
      /**
       * Modifications do not cause iterators to fail
       */
      public void testWeaklyConsistentIteration() {
          final LinkedBlockingQueue q = new LinkedBlockingQueue(3);
          q.add(one);
          q.add(two);
          q.add(three);
          for (Iterator it = q.iterator(); it.hasNext();) {
              q.remove();
              it.next();
          }
          assertEquals(0, q.size());
      }
  
      /**
       * toString contains toStrings of elements
       */
      public void testToString() {
          LinkedBlockingQueue q = populatedQueue(SIZE);
          String s = q.toString();
          for (int i = 0; i < SIZE; ++i) {
              assertTrue(s.contains(String.valueOf(i)));
          }
      }
  
      /**
       * offer transfers elements across Executor tasks
       */
      public void testOfferInExecutor() {
          final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
          q.add(one);
          q.add(two);
          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
          final ExecutorService executor = Executors.newFixedThreadPool(2);
          try (PoolCleaner cleaner = cleaner(executor)) {
              executor.execute(new CheckedRunnable() {
                  public void realRun() throws InterruptedException {
                      assertFalse(q.offer(three));
                      threadsStarted.await();
                      assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
                      assertEquals(0, q.remainingCapacity());
                  }});
  
  