--- jsr166/src/test/tck/LinkedBlockingDequeTest.java 2017/05/13 22:17:12 1.72 +++ jsr166/src/test/tck/LinkedBlockingDequeTest.java 2021/01/26 13:33:06 1.88 @@ -44,7 +44,7 @@ public class LinkedBlockingDequeTest ext class Implementation implements CollectionImplementation { public Class klazz() { return LinkedBlockingDeque.class; } public Collection emptyCollection() { return new LinkedBlockingDeque(); } - public Object makeElement(int i) { return i; } + public Object makeElement(int i) { return JSR166TestCase.itemFor(i); } public boolean isConcurrent() { return true; } public boolean permitsNulls() { return false; } } @@ -56,19 +56,19 @@ public class LinkedBlockingDequeTest ext /** * Returns a new deque of given size containing consecutive - * Integers 0 ... n - 1. + * Items 0 ... n - 1. */ - private static LinkedBlockingDeque populatedDeque(int n) { - LinkedBlockingDeque q = - new LinkedBlockingDeque(n); + private static LinkedBlockingDeque populatedDeque(int n) { + LinkedBlockingDeque q = + new LinkedBlockingDeque(n); assertTrue(q.isEmpty()); for (int i = 0; i < n; i++) - assertTrue(q.offer(new Integer(i))); + mustOffer(q, i); assertFalse(q.isEmpty()); - assertEquals(0, q.remainingCapacity()); - assertEquals(n, q.size()); - assertEquals((Integer) 0, q.peekFirst()); - assertEquals((Integer) (n - 1), q.peekLast()); + mustEqual(0, q.remainingCapacity()); + mustEqual(n, q.size()); + mustEqual(0, q.peekFirst()); + mustEqual((n - 1), q.peekLast()); return q; } @@ -76,11 +76,11 @@ public class LinkedBlockingDequeTest ext * isEmpty is true before add, false after */ public void testEmpty() { - LinkedBlockingDeque q = new LinkedBlockingDeque(); + LinkedBlockingDeque q = new LinkedBlockingDeque(); assertTrue(q.isEmpty()); - q.add(new Integer(1)); + q.add(one); assertFalse(q.isEmpty()); - q.add(new Integer(2)); + q.add(two); q.removeFirst(); q.removeFirst(); assertTrue(q.isEmpty()); @@ -90,14 +90,14 @@ public class LinkedBlockingDequeTest ext * size changes when elements added and removed */ public void testSize() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(SIZE - i, q.size()); + mustEqual(SIZE - i, q.size()); q.removeFirst(); } for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.size()); - q.add(new Integer(i)); + mustEqual(i, q.size()); + mustAdd(q, one); } } @@ -105,7 +105,7 @@ public class LinkedBlockingDequeTest ext * offerFirst(null) throws NullPointerException */ public void testOfferFirstNull() { - LinkedBlockingDeque q = new LinkedBlockingDeque(); + LinkedBlockingDeque q = new LinkedBlockingDeque(); try { q.offerFirst(null); shouldThrow(); @@ -116,7 +116,7 @@ public class LinkedBlockingDequeTest ext * offerLast(null) throws NullPointerException */ public void testOfferLastNull() { - LinkedBlockingDeque q = new LinkedBlockingDeque(); + LinkedBlockingDeque q = new LinkedBlockingDeque(); try { q.offerLast(null); shouldThrow(); @@ -127,27 +127,27 @@ public class LinkedBlockingDequeTest ext * OfferFirst succeeds */ public void testOfferFirst() { - LinkedBlockingDeque q = new LinkedBlockingDeque(); - assertTrue(q.offerFirst(new Integer(0))); - assertTrue(q.offerFirst(new Integer(1))); + LinkedBlockingDeque q = new LinkedBlockingDeque(); + assertTrue(q.offerFirst(zero)); + assertTrue(q.offerFirst(two)); } /** * OfferLast succeeds */ public void testOfferLast() { - LinkedBlockingDeque q = new LinkedBlockingDeque(); - assertTrue(q.offerLast(new Integer(0))); - assertTrue(q.offerLast(new Integer(1))); + LinkedBlockingDeque q = new LinkedBlockingDeque(); + assertTrue(q.offerLast(zero)); + assertTrue(q.offerLast(one)); } /** * pollFirst succeeds unless empty */ public void testPollFirst() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.pollFirst()); + mustEqual(i, q.pollFirst()); } assertNull(q.pollFirst()); } @@ -156,9 +156,9 @@ public class LinkedBlockingDequeTest ext * pollLast succeeds unless empty */ public void testPollLast() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = SIZE - 1; i >= 0; --i) { - assertEquals(i, q.pollLast()); + mustEqual(i, q.pollLast()); } assertNull(q.pollLast()); } @@ -167,10 +167,10 @@ public class LinkedBlockingDequeTest ext * peekFirst returns next element, or null if empty */ public void testPeekFirst() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.peekFirst()); - assertEquals(i, q.pollFirst()); + mustEqual(i, q.peekFirst()); + mustEqual(i, q.pollFirst()); assertTrue(q.peekFirst() == null || !q.peekFirst().equals(i)); } @@ -181,10 +181,10 @@ public class LinkedBlockingDequeTest ext * peek returns next element, or null if empty */ public void testPeek() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.peek()); - assertEquals(i, q.pollFirst()); + mustEqual(i, q.peek()); + mustEqual(i, q.pollFirst()); assertTrue(q.peek() == null || !q.peek().equals(i)); } @@ -195,10 +195,10 @@ public class LinkedBlockingDequeTest ext * peekLast returns next element, or null if empty */ public void testPeekLast() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = SIZE - 1; i >= 0; --i) { - assertEquals(i, q.peekLast()); - assertEquals(i, q.pollLast()); + mustEqual(i, q.peekLast()); + mustEqual(i, q.pollLast()); assertTrue(q.peekLast() == null || !q.peekLast().equals(i)); } @@ -209,10 +209,10 @@ public class LinkedBlockingDequeTest ext * getFirst() returns first element, or throws NSEE if empty */ public void testFirstElement() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.getFirst()); - assertEquals(i, q.pollFirst()); + mustEqual(i, q.getFirst()); + mustEqual(i, q.pollFirst()); } try { q.getFirst(); @@ -225,10 +225,10 @@ public class LinkedBlockingDequeTest ext * getLast() returns last element, or throws NSEE if empty */ public void testLastElement() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = SIZE - 1; i >= 0; --i) { - assertEquals(i, q.getLast()); - assertEquals(i, q.pollLast()); + mustEqual(i, q.getLast()); + mustEqual(i, q.pollLast()); } try { q.getLast(); @@ -241,9 +241,9 @@ public class LinkedBlockingDequeTest ext * removeFirst() removes first element, or throws NSEE if empty */ public void testRemoveFirst() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.removeFirst()); + mustEqual(i, q.removeFirst()); } try { q.removeFirst(); @@ -256,9 +256,9 @@ public class LinkedBlockingDequeTest ext * removeLast() removes last element, or throws NSEE if empty */ public void testRemoveLast() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = SIZE - 1; i >= 0; --i) { - assertEquals(i, q.removeLast()); + mustEqual(i, q.removeLast()); } try { q.removeLast(); @@ -271,9 +271,9 @@ public class LinkedBlockingDequeTest ext * remove removes next element, or throws NSEE if empty */ public void testRemove() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.remove()); + mustEqual(i, q.remove()); } try { q.remove(); @@ -285,13 +285,13 @@ public class LinkedBlockingDequeTest ext * removeFirstOccurrence(x) removes x and returns true if present */ public void testRemoveFirstOccurrence() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 1; i < SIZE; i += 2) { - assertTrue(q.removeFirstOccurrence(new Integer(i))); + assertTrue(q.removeFirstOccurrence(itemFor(i))); } for (int i = 0; i < SIZE; i += 2) { - assertTrue(q.removeFirstOccurrence(new Integer(i))); - assertFalse(q.removeFirstOccurrence(new Integer(i + 1))); + assertTrue(q.removeFirstOccurrence(itemFor(i))); + assertFalse(q.removeFirstOccurrence(itemFor(i + 1))); } assertTrue(q.isEmpty()); } @@ -300,13 +300,13 @@ public class LinkedBlockingDequeTest ext * removeLastOccurrence(x) removes x and returns true if present */ public void testRemoveLastOccurrence() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 1; i < SIZE; i += 2) { - assertTrue(q.removeLastOccurrence(new Integer(i))); + assertTrue(q.removeLastOccurrence(itemFor(i))); } for (int i = 0; i < SIZE; i += 2) { - assertTrue(q.removeLastOccurrence(new Integer(i))); - assertFalse(q.removeLastOccurrence(new Integer(i + 1))); + assertTrue(q.removeLastOccurrence(itemFor(i))); + assertFalse(q.removeLastOccurrence(itemFor(i + 1))); } assertTrue(q.isEmpty()); } @@ -315,7 +315,7 @@ public class LinkedBlockingDequeTest ext * peekFirst returns element inserted with addFirst */ public void testAddFirst() { - LinkedBlockingDeque q = populatedDeque(3); + LinkedBlockingDeque q = populatedDeque(3); q.pollLast(); q.addFirst(four); assertSame(four, q.peekFirst()); @@ -325,7 +325,7 @@ public class LinkedBlockingDequeTest ext * peekLast returns element inserted with addLast */ public void testAddLast() { - LinkedBlockingDeque q = populatedDeque(3); + LinkedBlockingDeque q = populatedDeque(3); q.pollLast(); q.addLast(four); assertSame(four, q.peekLast()); @@ -336,8 +336,8 @@ public class LinkedBlockingDequeTest ext * none given */ public void testConstructor1() { - assertEquals(SIZE, new LinkedBlockingDeque(SIZE).remainingCapacity()); - assertEquals(Integer.MAX_VALUE, new LinkedBlockingDeque().remainingCapacity()); + mustEqual(SIZE, new LinkedBlockingDeque(SIZE).remainingCapacity()); + mustEqual(Integer.MAX_VALUE, new LinkedBlockingDeque().remainingCapacity()); } /** @@ -345,7 +345,7 @@ public class LinkedBlockingDequeTest ext */ public void testConstructor2() { try { - new LinkedBlockingDeque(0); + new LinkedBlockingDeque(0); shouldThrow(); } catch (IllegalArgumentException success) {} } @@ -355,7 +355,7 @@ public class LinkedBlockingDequeTest ext */ public void testConstructor3() { try { - new LinkedBlockingDeque(null); + new LinkedBlockingDeque(null); shouldThrow(); } catch (NullPointerException success) {} } @@ -364,9 +364,9 @@ public class LinkedBlockingDequeTest ext * Initializing from Collection of null elements throws NullPointerException */ public void testConstructor4() { - Collection elements = Arrays.asList(new Integer[SIZE]); + Collection elements = Arrays.asList(new Item[SIZE]); try { - new LinkedBlockingDeque(elements); + new LinkedBlockingDeque(elements); shouldThrow(); } catch (NullPointerException success) {} } @@ -376,12 +376,11 @@ public class LinkedBlockingDequeTest ext * NullPointerException */ public void testConstructor5() { - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE - 1; ++i) - ints[i] = i; - Collection elements = Arrays.asList(ints); + Item[] items = new Item[2]; + items[0] = zero; + Collection elements = Arrays.asList(items); try { - new LinkedBlockingDeque(elements); + new LinkedBlockingDeque(elements); shouldThrow(); } catch (NullPointerException success) {} } @@ -390,26 +389,24 @@ public class LinkedBlockingDequeTest ext * Deque 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] = i; - LinkedBlockingDeque q = new LinkedBlockingDeque(Arrays.asList(ints)); + Item[] items = defaultItems; + LinkedBlockingDeque q = new LinkedBlockingDeque(Arrays.asList(items)); for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], q.poll()); + mustEqual(items[i], q.poll()); } /** * Deque transitions from empty to full when elements added */ public void testEmptyFull() { - LinkedBlockingDeque q = new LinkedBlockingDeque(2); + LinkedBlockingDeque q = new LinkedBlockingDeque(2); assertTrue(q.isEmpty()); - assertEquals("should have room for 2", 2, q.remainingCapacity()); + mustEqual(2, q.remainingCapacity()); q.add(one); assertFalse(q.isEmpty()); q.add(two); assertFalse(q.isEmpty()); - assertEquals(0, q.remainingCapacity()); + mustEqual(0, q.remainingCapacity()); assertFalse(q.offer(three)); } @@ -417,16 +414,16 @@ public class LinkedBlockingDequeTest ext * remainingCapacity decreases on add, increases on remove */ public void testRemainingCapacity() { - BlockingQueue q = populatedDeque(SIZE); + BlockingQueue q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.remainingCapacity()); - assertEquals(SIZE, q.size() + q.remainingCapacity()); - assertEquals(i, q.remove()); + mustEqual(i, q.remainingCapacity()); + mustEqual(SIZE, q.size() + q.remainingCapacity()); + mustEqual(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)); + mustEqual(SIZE - i, q.remainingCapacity()); + mustEqual(SIZE, q.size() + q.remainingCapacity()); + mustAdd(q, i); } } @@ -434,7 +431,7 @@ public class LinkedBlockingDequeTest ext * push(null) throws NPE */ public void testPushNull() { - LinkedBlockingDeque q = new LinkedBlockingDeque(1); + LinkedBlockingDeque q = new LinkedBlockingDeque(1); try { q.push(null); shouldThrow(); @@ -442,18 +439,18 @@ public class LinkedBlockingDequeTest ext } /** - * push succeeds if not full; throws ISE if full + * push succeeds if not full; throws IllegalStateException if full */ public void testPush() { - LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - Integer x = new Integer(i); + Item x = itemFor(i); q.push(x); - assertEquals(x, q.peek()); + mustEqual(x, q.peek()); } - assertEquals(0, q.remainingCapacity()); + mustEqual(0, q.remainingCapacity()); try { - q.push(new Integer(SIZE)); + q.push(itemFor(SIZE)); shouldThrow(); } catch (IllegalStateException success) {} } @@ -462,7 +459,7 @@ public class LinkedBlockingDequeTest ext * peekFirst returns element inserted with push */ public void testPushWithPeek() { - LinkedBlockingDeque q = populatedDeque(3); + LinkedBlockingDeque q = populatedDeque(3); q.pollLast(); q.push(four); assertSame(four, q.peekFirst()); @@ -472,9 +469,9 @@ public class LinkedBlockingDequeTest ext * pop removes next element, or throws NSEE if empty */ public void testPop() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.pop()); + mustEqual(i, q.pop()); } try { q.pop(); @@ -486,30 +483,30 @@ public class LinkedBlockingDequeTest ext * Offer succeeds if not full; fails if full */ public void testOffer() { - LinkedBlockingDeque q = new LinkedBlockingDeque(1); + LinkedBlockingDeque q = new LinkedBlockingDeque(1); assertTrue(q.offer(zero)); assertFalse(q.offer(one)); } /** - * add succeeds if not full; throws ISE if full + * add succeeds if not full; throws IllegalStateException if full */ public void testAdd() { - LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); for (int i = 0; i < SIZE; ++i) - assertTrue(q.add(new Integer(i))); - assertEquals(0, q.remainingCapacity()); + mustAdd(q, i); + mustEqual(0, q.remainingCapacity()); try { - q.add(new Integer(SIZE)); + q.add(itemFor(SIZE)); shouldThrow(); } catch (IllegalStateException success) {} } /** - * addAll(this) throws IAE + * addAll(this) throws IllegalArgumentException */ public void testAddAllSelf() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); try { q.addAll(q); shouldThrow(); @@ -521,11 +518,9 @@ public class LinkedBlockingDequeTest ext * possibly adding some elements */ public void testAddAll3() { - LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE - 1; ++i) - ints[i] = new Integer(i); - Collection elements = Arrays.asList(ints); + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + Item[] items = new Item[2]; items[0] = zero; + Collection elements = Arrays.asList(items); try { q.addAll(elements); shouldThrow(); @@ -536,11 +531,9 @@ public class LinkedBlockingDequeTest ext * addAll throws IllegalStateException if not enough room */ public void testAddAll4() { - LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE - 1); - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(i); - Collection elements = Arrays.asList(ints); + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE - 1); + Item[] items = defaultItems; + Collection elements = Arrays.asList(items); try { q.addAll(elements); shouldThrow(); @@ -551,64 +544,62 @@ public class LinkedBlockingDequeTest ext * Deque 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); - LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + Item[] empty = new Item[0]; + Item[] items = defaultItems; + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); assertFalse(q.addAll(Arrays.asList(empty))); - assertTrue(q.addAll(Arrays.asList(ints))); + assertTrue(q.addAll(Arrays.asList(items))); for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], q.poll()); + mustEqual(items[i], q.poll()); } /** * all elements successfully put are contained */ public void testPut() throws InterruptedException { - LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - Integer x = new Integer(i); + Item x = itemFor(i); q.put(x); - assertTrue(q.contains(x)); + mustContain(q, x); } - assertEquals(0, q.remainingCapacity()); + mustEqual(0, q.remainingCapacity()); } /** * put blocks interruptibly if full */ public void testBlockingPut() throws InterruptedException { - final LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + final LinkedBlockingDeque q = new LinkedBlockingDeque(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()); + q.put(itemFor(i)); + mustEqual(SIZE, q.size()); + mustEqual(0, q.remainingCapacity()); Thread.currentThread().interrupt(); try { - q.put(99); + q.put(ninetynine); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); pleaseInterrupt.countDown(); try { - q.put(99); + q.put(ninetynine); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); }}); await(pleaseInterrupt); - assertThreadBlocks(t, Thread.State.WAITING); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING); t.interrupt(); awaitTermination(t); - assertEquals(SIZE, q.size()); - assertEquals(0, q.remainingCapacity()); + mustEqual(SIZE, q.size()); + mustEqual(0, q.remainingCapacity()); } /** @@ -616,57 +607,74 @@ public class LinkedBlockingDequeTest ext */ public void testPutWithTake() throws InterruptedException { final int capacity = 2; - final LinkedBlockingDeque q = new LinkedBlockingDeque(capacity); + final LinkedBlockingDeque q = new LinkedBlockingDeque(capacity); 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); + q.put(itemFor(i)); pleaseTake.countDown(); - q.put(86); + q.put(eightysix); + + Thread.currentThread().interrupt(); + try { + q.put(ninetynine); + shouldThrow(); + } catch (InterruptedException success) {} + assertFalse(Thread.interrupted()); pleaseInterrupt.countDown(); try { - q.put(99); + q.put(ninetynine); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); }}); await(pleaseTake); - assertEquals(0, q.remainingCapacity()); - assertEquals(0, q.take()); + mustEqual(0, q.remainingCapacity()); + mustEqual(0, q.take()); await(pleaseInterrupt); - assertThreadBlocks(t, Thread.State.WAITING); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING); t.interrupt(); awaitTermination(t); - assertEquals(0, q.remainingCapacity()); + mustEqual(0, q.remainingCapacity()); } /** * timed offer times out if full and elements not taken */ - public void testTimedOffer() throws InterruptedException { - final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + public void testTimedOffer() { + final LinkedBlockingDeque q = new LinkedBlockingDeque(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()); + q.put(zero); + q.put(one); long startTime = System.nanoTime(); - assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS)); + + assertFalse(q.offer(two, timeoutMillis(), MILLISECONDS)); assertTrue(millisElapsedSince(startTime) >= timeoutMillis()); + + Thread.currentThread().interrupt(); + try { + q.offer(three, randomTimeout(), randomTimeUnit()); + shouldThrow(); + } catch (InterruptedException success) {} + assertFalse(Thread.interrupted()); + pleaseInterrupt.countDown(); try { - q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS); + q.offer(four, LONGER_DELAY_MS, MILLISECONDS); shouldThrow(); } catch (InterruptedException success) {} + assertFalse(Thread.interrupted()); }}); await(pleaseInterrupt); - assertThreadBlocks(t, Thread.State.TIMED_WAITING); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING); t.interrupt(); awaitTermination(t); } @@ -675,9 +683,9 @@ public class LinkedBlockingDequeTest ext * take retrieves elements in FIFO order */ public void testTake() throws InterruptedException { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.take()); + mustEqual(i, q.take()); } } @@ -685,11 +693,11 @@ public class LinkedBlockingDequeTest ext * take removes existing elements until empty, then blocks interruptibly */ public void testBlockingTake() throws InterruptedException { - final LinkedBlockingDeque q = populatedDeque(SIZE); + final LinkedBlockingDeque q = populatedDeque(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()); + for (int i = 0; i < SIZE; i++) mustEqual(i, q.take()); Thread.currentThread().interrupt(); try { @@ -707,7 +715,7 @@ public class LinkedBlockingDequeTest ext }}); await(pleaseInterrupt); - assertThreadBlocks(t, Thread.State.WAITING); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING); t.interrupt(); awaitTermination(t); } @@ -716,9 +724,9 @@ public class LinkedBlockingDequeTest ext * poll succeeds unless empty */ public void testPoll() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.poll()); + mustEqual(i, q.poll()); } assertNull(q.poll()); } @@ -727,9 +735,9 @@ public class LinkedBlockingDequeTest ext * timed poll with zero timeout succeeds when non-empty, else times out */ public void testTimedPoll0() throws InterruptedException { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.poll(0, MILLISECONDS)); + mustEqual(i, q.poll(0, MILLISECONDS)); } assertNull(q.poll(0, MILLISECONDS)); } @@ -738,10 +746,10 @@ public class LinkedBlockingDequeTest ext * timed poll with nonzero timeout succeeds when non-empty, else times out */ public void testTimedPoll() throws InterruptedException { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { long startTime = System.nanoTime(); - assertEquals(i, q.poll(LONG_DELAY_MS, MILLISECONDS)); + mustEqual(i, q.poll(LONG_DELAY_MS, MILLISECONDS)); assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS); } long startTime = System.nanoTime(); @@ -755,25 +763,30 @@ public class LinkedBlockingDequeTest ext * returning timeout status */ public void testInterruptedTimedPoll() throws InterruptedException { - final BlockingQueue q = populatedDeque(SIZE); - final CountDownLatch aboutToWait = new CountDownLatch(1); + final BlockingQueue q = populatedDeque(SIZE); + final CountDownLatch pleaseInterrupt = new CountDownLatch(1); Thread t = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { - long startTime = System.nanoTime(); - for (int i = 0; i < SIZE; ++i) { - assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS)); - } - aboutToWait.countDown(); + for (int i = 0; i < SIZE; i++) + mustEqual(i, q.poll(LONG_DELAY_MS, MILLISECONDS)); + + Thread.currentThread().interrupt(); try { - q.poll(LONG_DELAY_MS, MILLISECONDS); + q.poll(randomTimeout(), randomTimeUnit()); + shouldThrow(); + } catch (InterruptedException success) {} + assertFalse(Thread.interrupted()); + + pleaseInterrupt.countDown(); + try { + q.poll(LONGER_DELAY_MS, MILLISECONDS); shouldThrow(); - } catch (InterruptedException success) { - assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS); - } + } catch (InterruptedException success) {} + assertFalse(Thread.interrupted()); }}); - await(aboutToWait); - waitForThreadToEnterWaitState(t); + await(pleaseInterrupt); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING); t.interrupt(); awaitTermination(t); checkEmpty(q); @@ -783,7 +796,7 @@ public class LinkedBlockingDequeTest ext * putFirst(null) throws NPE */ public void testPutFirstNull() throws InterruptedException { - LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); try { q.putFirst(null); shouldThrow(); @@ -794,49 +807,49 @@ public class LinkedBlockingDequeTest ext * all elements successfully putFirst are contained */ public void testPutFirst() throws InterruptedException { - LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - Integer x = new Integer(i); + Item x = itemFor(i); q.putFirst(x); - assertTrue(q.contains(x)); + mustContain(q, x); } - assertEquals(0, q.remainingCapacity()); + mustEqual(0, q.remainingCapacity()); } /** * putFirst blocks interruptibly if full */ public void testBlockingPutFirst() throws InterruptedException { - final LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + final LinkedBlockingDeque q = new LinkedBlockingDeque(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.putFirst(i); - assertEquals(SIZE, q.size()); - assertEquals(0, q.remainingCapacity()); + q.putFirst(itemFor(i)); + mustEqual(SIZE, q.size()); + mustEqual(0, q.remainingCapacity()); Thread.currentThread().interrupt(); try { - q.putFirst(99); + q.putFirst(ninetynine); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); pleaseInterrupt.countDown(); try { - q.putFirst(99); + q.putFirst(ninetynine); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); }}); await(pleaseInterrupt); - assertThreadBlocks(t, Thread.State.WAITING); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING); t.interrupt(); awaitTermination(t); - assertEquals(SIZE, q.size()); - assertEquals(0, q.remainingCapacity()); + mustEqual(SIZE, q.size()); + mustEqual(0, q.remainingCapacity()); } /** @@ -844,57 +857,67 @@ public class LinkedBlockingDequeTest ext */ public void testPutFirstWithTake() throws InterruptedException { final int capacity = 2; - final LinkedBlockingDeque q = new LinkedBlockingDeque(capacity); + final LinkedBlockingDeque q = new LinkedBlockingDeque(capacity); 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.putFirst(i); + q.putFirst(itemFor(i)); pleaseTake.countDown(); - q.putFirst(86); + q.putFirst(eightysix); pleaseInterrupt.countDown(); try { - q.putFirst(99); + q.putFirst(ninetynine); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); }}); await(pleaseTake); - assertEquals(0, q.remainingCapacity()); - assertEquals(capacity - 1, q.take()); + mustEqual(0, q.remainingCapacity()); + mustEqual(capacity - 1, q.take()); await(pleaseInterrupt); - assertThreadBlocks(t, Thread.State.WAITING); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING); t.interrupt(); awaitTermination(t); - assertEquals(0, q.remainingCapacity()); + mustEqual(0, q.remainingCapacity()); } /** * timed offerFirst times out if full and elements not taken */ - public void testTimedOfferFirst() throws InterruptedException { - final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + public void testTimedOfferFirst() { + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); final CountDownLatch pleaseInterrupt = new CountDownLatch(1); Thread t = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { - q.putFirst(new Object()); - q.putFirst(new Object()); + q.putFirst(zero); + q.putFirst(one); long startTime = System.nanoTime(); - assertFalse(q.offerFirst(new Object(), timeoutMillis(), MILLISECONDS)); + + assertFalse(q.offerFirst(two, timeoutMillis(), MILLISECONDS)); assertTrue(millisElapsedSince(startTime) >= timeoutMillis()); + + Thread.currentThread().interrupt(); + try { + q.offerFirst(three, randomTimeout(), randomTimeUnit()); + shouldThrow(); + } catch (InterruptedException success) {} + assertFalse(Thread.interrupted()); + pleaseInterrupt.countDown(); try { - q.offerFirst(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS); + q.offerFirst(four, LONGER_DELAY_MS, MILLISECONDS); shouldThrow(); } catch (InterruptedException success) {} + assertFalse(Thread.interrupted()); }}); await(pleaseInterrupt); - assertThreadBlocks(t, Thread.State.TIMED_WAITING); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING); t.interrupt(); awaitTermination(t); } @@ -903,9 +926,9 @@ public class LinkedBlockingDequeTest ext * take retrieves elements in FIFO order */ public void testTakeFirst() throws InterruptedException { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.takeFirst()); + mustEqual(i, q.takeFirst()); } } @@ -913,7 +936,7 @@ public class LinkedBlockingDequeTest ext * takeFirst() blocks interruptibly when empty */ public void testTakeFirstFromEmptyBlocksInterruptibly() { - final BlockingDeque q = new LinkedBlockingDeque(); + final BlockingDeque q = new LinkedBlockingDeque(); final CountDownLatch threadStarted = new CountDownLatch(1); Thread t = newStartedThread(new CheckedRunnable() { public void realRun() { @@ -926,7 +949,7 @@ public class LinkedBlockingDequeTest ext }}); await(threadStarted); - assertThreadBlocks(t, Thread.State.WAITING); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING); t.interrupt(); awaitTermination(t); } @@ -936,7 +959,7 @@ public class LinkedBlockingDequeTest ext * before waiting */ public void testTakeFirstFromEmptyAfterInterrupt() { - final BlockingDeque q = new LinkedBlockingDeque(); + final BlockingDeque q = new LinkedBlockingDeque(); Thread t = newStartedThread(new CheckedRunnable() { public void realRun() { Thread.currentThread().interrupt(); @@ -954,7 +977,7 @@ public class LinkedBlockingDequeTest ext * takeLast() blocks interruptibly when empty */ public void testTakeLastFromEmptyBlocksInterruptibly() { - final BlockingDeque q = new LinkedBlockingDeque(); + final BlockingDeque q = new LinkedBlockingDeque(); final CountDownLatch threadStarted = new CountDownLatch(1); Thread t = newStartedThread(new CheckedRunnable() { public void realRun() { @@ -967,7 +990,7 @@ public class LinkedBlockingDequeTest ext }}); await(threadStarted); - assertThreadBlocks(t, Thread.State.WAITING); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING); t.interrupt(); awaitTermination(t); } @@ -977,7 +1000,7 @@ public class LinkedBlockingDequeTest ext * before waiting */ public void testTakeLastFromEmptyAfterInterrupt() { - final BlockingDeque q = new LinkedBlockingDeque(); + final BlockingDeque q = new LinkedBlockingDeque(); Thread t = newStartedThread(new CheckedRunnable() { public void realRun() { Thread.currentThread().interrupt(); @@ -995,11 +1018,11 @@ public class LinkedBlockingDequeTest ext * takeFirst removes existing elements until empty, then blocks interruptibly */ public void testBlockingTakeFirst() throws InterruptedException { - final LinkedBlockingDeque q = populatedDeque(SIZE); + final LinkedBlockingDeque q = populatedDeque(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.takeFirst()); + for (int i = 0; i < SIZE; i++) mustEqual(i, q.takeFirst()); Thread.currentThread().interrupt(); try { @@ -1017,7 +1040,7 @@ public class LinkedBlockingDequeTest ext }}); await(pleaseInterrupt); - assertThreadBlocks(t, Thread.State.WAITING); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING); t.interrupt(); awaitTermination(t); } @@ -1026,9 +1049,9 @@ public class LinkedBlockingDequeTest ext * timed pollFirst with zero timeout succeeds when non-empty, else times out */ public void testTimedPollFirst0() throws InterruptedException { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.pollFirst(0, MILLISECONDS)); + mustEqual(i, q.pollFirst(0, MILLISECONDS)); } assertNull(q.pollFirst(0, MILLISECONDS)); } @@ -1037,10 +1060,10 @@ public class LinkedBlockingDequeTest ext * timed pollFirst with nonzero timeout succeeds when non-empty, else times out */ public void testTimedPollFirst() throws InterruptedException { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { long startTime = System.nanoTime(); - assertEquals(i, q.pollFirst(LONG_DELAY_MS, MILLISECONDS)); + mustEqual(i, q.pollFirst(LONG_DELAY_MS, MILLISECONDS)); assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS); } long startTime = System.nanoTime(); @@ -1054,33 +1077,30 @@ public class LinkedBlockingDequeTest ext * returning timeout status */ public void testInterruptedTimedPollFirst() throws InterruptedException { - final LinkedBlockingDeque q = populatedDeque(SIZE); + final LinkedBlockingDeque q = populatedDeque(SIZE); final CountDownLatch pleaseInterrupt = new CountDownLatch(1); Thread t = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { - long startTime = System.nanoTime(); - for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.pollFirst(LONG_DELAY_MS, MILLISECONDS)); - } + for (int i = 0; i < SIZE; i++) + mustEqual(i, q.pollFirst(LONG_DELAY_MS, MILLISECONDS)); Thread.currentThread().interrupt(); try { - q.pollFirst(LONG_DELAY_MS, MILLISECONDS); + q.pollFirst(randomTimeout(), randomTimeUnit()); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); pleaseInterrupt.countDown(); try { - q.pollFirst(LONG_DELAY_MS, MILLISECONDS); + q.pollFirst(LONGER_DELAY_MS, MILLISECONDS); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); - assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS); }}); await(pleaseInterrupt); - assertThreadStaysAlive(t); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING); t.interrupt(); awaitTermination(t); } @@ -1090,7 +1110,7 @@ public class LinkedBlockingDequeTest ext * on interruption throws */ public void testTimedPollFirstWithOfferFirst() throws InterruptedException { - final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); final CheckedBarrier barrier = new CheckedBarrier(2); Thread t = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { @@ -1104,7 +1124,7 @@ public class LinkedBlockingDequeTest ext Thread.currentThread().interrupt(); try { - q.pollFirst(LONG_DELAY_MS, MILLISECONDS); + q.pollFirst(randomTimeout(), randomTimeUnit()); shouldThrow(); } catch (InterruptedException success) {} @@ -1113,6 +1133,8 @@ public class LinkedBlockingDequeTest ext q.pollFirst(LONG_DELAY_MS, MILLISECONDS); shouldThrow(); } catch (InterruptedException success) {} + assertFalse(Thread.interrupted()); + assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS); }}); @@ -1121,7 +1143,7 @@ public class LinkedBlockingDequeTest ext assertTrue(q.offerFirst(zero, LONG_DELAY_MS, MILLISECONDS)); assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS); barrier.await(); - assertThreadStaysAlive(t); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING); t.interrupt(); awaitTermination(t); } @@ -1130,7 +1152,7 @@ public class LinkedBlockingDequeTest ext * putLast(null) throws NPE */ public void testPutLastNull() throws InterruptedException { - LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); try { q.putLast(null); shouldThrow(); @@ -1141,49 +1163,49 @@ public class LinkedBlockingDequeTest ext * all elements successfully putLast are contained */ public void testPutLast() throws InterruptedException { - LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - Integer x = new Integer(i); + Item x = itemFor(i); q.putLast(x); - assertTrue(q.contains(x)); + mustContain(q, x); } - assertEquals(0, q.remainingCapacity()); + mustEqual(0, q.remainingCapacity()); } /** * putLast blocks interruptibly if full */ public void testBlockingPutLast() throws InterruptedException { - final LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); + final LinkedBlockingDeque q = new LinkedBlockingDeque(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.putLast(i); - assertEquals(SIZE, q.size()); - assertEquals(0, q.remainingCapacity()); + q.putLast(itemFor(i)); + mustEqual(SIZE, q.size()); + mustEqual(0, q.remainingCapacity()); Thread.currentThread().interrupt(); try { - q.putLast(99); + q.putLast(ninetynine); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); pleaseInterrupt.countDown(); try { - q.putLast(99); + q.putLast(ninetynine); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); }}); await(pleaseInterrupt); - assertThreadBlocks(t, Thread.State.WAITING); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING); t.interrupt(); awaitTermination(t); - assertEquals(SIZE, q.size()); - assertEquals(0, q.remainingCapacity()); + mustEqual(SIZE, q.size()); + mustEqual(0, q.remainingCapacity()); } /** @@ -1191,57 +1213,72 @@ public class LinkedBlockingDequeTest ext */ public void testPutLastWithTake() throws InterruptedException { final int capacity = 2; - final LinkedBlockingDeque q = new LinkedBlockingDeque(capacity); + final LinkedBlockingDeque q = new LinkedBlockingDeque(capacity); 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.putLast(i); + q.putLast(itemFor(i)); pleaseTake.countDown(); - q.putLast(86); + q.putLast(eightysix); + + Thread.currentThread().interrupt(); + try { + q.putLast(ninetynine); + shouldThrow(); + } catch (InterruptedException success) {} + assertFalse(Thread.interrupted()); pleaseInterrupt.countDown(); try { - q.putLast(99); + q.putLast(ninetynine); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); }}); await(pleaseTake); - assertEquals(0, q.remainingCapacity()); - assertEquals(0, q.take()); + mustEqual(0, q.remainingCapacity()); + mustEqual(0, q.take()); await(pleaseInterrupt); - assertThreadBlocks(t, Thread.State.WAITING); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING); t.interrupt(); awaitTermination(t); - assertEquals(0, q.remainingCapacity()); + mustEqual(0, q.remainingCapacity()); } /** * timed offerLast times out if full and elements not taken */ - public void testTimedOfferLast() throws InterruptedException { - final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + public void testTimedOfferLast() { + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); final CountDownLatch pleaseInterrupt = new CountDownLatch(1); Thread t = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { - q.putLast(new Object()); - q.putLast(new Object()); + q.putLast(zero); + q.putLast(one); long startTime = System.nanoTime(); - assertFalse(q.offerLast(new Object(), timeoutMillis(), MILLISECONDS)); + + assertFalse(q.offerLast(two, timeoutMillis(), MILLISECONDS)); assertTrue(millisElapsedSince(startTime) >= timeoutMillis()); + + Thread.currentThread().interrupt(); + try { + q.offerLast(three, randomTimeout(), randomTimeUnit()); + shouldThrow(); + } catch (InterruptedException success) {} + pleaseInterrupt.countDown(); try { - q.offerLast(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS); + q.offerLast(four, LONGER_DELAY_MS, MILLISECONDS); shouldThrow(); } catch (InterruptedException success) {} }}); await(pleaseInterrupt); - assertThreadBlocks(t, Thread.State.TIMED_WAITING); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING); t.interrupt(); awaitTermination(t); } @@ -1250,9 +1287,9 @@ public class LinkedBlockingDequeTest ext * takeLast retrieves elements in FIFO order */ public void testTakeLast() throws InterruptedException { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(SIZE - i - 1, q.takeLast()); + mustEqual(SIZE - i - 1, q.takeLast()); } } @@ -1260,12 +1297,12 @@ public class LinkedBlockingDequeTest ext * takeLast removes existing elements until empty, then blocks interruptibly */ public void testBlockingTakeLast() throws InterruptedException { - final LinkedBlockingDeque q = populatedDeque(SIZE); + final LinkedBlockingDeque q = populatedDeque(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(SIZE - i - 1, q.takeLast()); + mustEqual(SIZE - i - 1, q.takeLast()); Thread.currentThread().interrupt(); try { @@ -1283,7 +1320,7 @@ public class LinkedBlockingDequeTest ext }}); await(pleaseInterrupt); - assertThreadBlocks(t, Thread.State.WAITING); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING); t.interrupt(); awaitTermination(t); } @@ -1292,9 +1329,9 @@ public class LinkedBlockingDequeTest ext * timed pollLast with zero timeout succeeds when non-empty, else times out */ public void testTimedPollLast0() throws InterruptedException { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(SIZE - i - 1, q.pollLast(0, MILLISECONDS)); + mustEqual(SIZE - i - 1, q.pollLast(0, MILLISECONDS)); } assertNull(q.pollLast(0, MILLISECONDS)); } @@ -1303,10 +1340,10 @@ public class LinkedBlockingDequeTest ext * timed pollLast with nonzero timeout succeeds when non-empty, else times out */ public void testTimedPollLast() throws InterruptedException { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { long startTime = System.nanoTime(); - assertEquals(SIZE - i - 1, q.pollLast(LONG_DELAY_MS, MILLISECONDS)); + mustEqual(SIZE - i - 1, q.pollLast(LONG_DELAY_MS, MILLISECONDS)); assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS); } long startTime = System.nanoTime(); @@ -1320,35 +1357,31 @@ public class LinkedBlockingDequeTest ext * returning timeout status */ public void testInterruptedTimedPollLast() throws InterruptedException { - final LinkedBlockingDeque q = populatedDeque(SIZE); + final LinkedBlockingDeque q = populatedDeque(SIZE); final CountDownLatch pleaseInterrupt = new CountDownLatch(1); Thread t = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { - long startTime = System.nanoTime(); - for (int i = 0; i < SIZE; ++i) { - assertEquals(SIZE - i - 1, + for (int i = 0; i < SIZE; i++) + mustEqual(SIZE - i - 1, q.pollLast(LONG_DELAY_MS, MILLISECONDS)); - } Thread.currentThread().interrupt(); try { - q.pollLast(LONG_DELAY_MS, MILLISECONDS); + q.pollLast(randomTimeout(), randomTimeUnit()); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); pleaseInterrupt.countDown(); try { - q.pollLast(LONG_DELAY_MS, MILLISECONDS); + q.pollLast(LONGER_DELAY_MS, MILLISECONDS); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); - - assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS); }}); await(pleaseInterrupt); - assertThreadStaysAlive(t); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING); t.interrupt(); awaitTermination(t); checkEmpty(q); @@ -1359,7 +1392,7 @@ public class LinkedBlockingDequeTest ext * on interruption throws */ public void testTimedPollWithOfferLast() throws InterruptedException { - final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); final CheckedBarrier barrier = new CheckedBarrier(2); Thread t = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { @@ -1373,7 +1406,7 @@ public class LinkedBlockingDequeTest ext Thread.currentThread().interrupt(); try { - q.poll(LONG_DELAY_MS, MILLISECONDS); + q.poll(randomTimeout(), randomTimeUnit()); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); @@ -1394,7 +1427,7 @@ public class LinkedBlockingDequeTest ext assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS); barrier.await(); - assertThreadStaysAlive(t); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING); t.interrupt(); awaitTermination(t); } @@ -1403,9 +1436,9 @@ public class LinkedBlockingDequeTest ext * element returns next element, or throws NSEE if empty */ public void testElement() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.element()); + mustEqual(i, q.element()); q.poll(); } try { @@ -1418,11 +1451,11 @@ public class LinkedBlockingDequeTest ext * contains(x) reports true when elements added but not yet removed */ public void testContains() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertTrue(q.contains(new Integer(i))); + mustContain(q, i); q.poll(); - assertFalse(q.contains(new Integer(i))); + mustNotContain(q, i); } } @@ -1430,14 +1463,14 @@ public class LinkedBlockingDequeTest ext * clear removes all elements */ public void testClear() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); q.clear(); assertTrue(q.isEmpty()); - assertEquals(0, q.size()); - assertEquals(SIZE, q.remainingCapacity()); + mustEqual(0, q.size()); + mustEqual(SIZE, q.remainingCapacity()); q.add(one); assertFalse(q.isEmpty()); - assertTrue(q.contains(one)); + mustContain(q, one); q.clear(); assertTrue(q.isEmpty()); } @@ -1446,12 +1479,12 @@ public class LinkedBlockingDequeTest ext * containsAll(c) is true when c contains a subset of elements */ public void testContainsAll() { - LinkedBlockingDeque q = populatedDeque(SIZE); - LinkedBlockingDeque p = new LinkedBlockingDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque p = new LinkedBlockingDeque(SIZE); for (int i = 0; i < SIZE; ++i) { assertTrue(q.containsAll(p)); assertFalse(p.containsAll(q)); - p.add(new Integer(i)); + mustAdd(p, i); } assertTrue(p.containsAll(q)); } @@ -1460,8 +1493,8 @@ public class LinkedBlockingDequeTest ext * retainAll(c) retains only those elements of c and reports true if changed */ public void testRetainAll() { - LinkedBlockingDeque q = populatedDeque(SIZE); - LinkedBlockingDeque p = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque p = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { boolean changed = q.retainAll(p); if (i == 0) @@ -1470,7 +1503,7 @@ public class LinkedBlockingDequeTest ext assertTrue(changed); assertTrue(q.containsAll(p)); - assertEquals(SIZE - i, q.size()); + mustEqual(SIZE - i, q.size()); p.remove(); } } @@ -1480,13 +1513,12 @@ public class LinkedBlockingDequeTest ext */ public void testRemoveAll() { for (int i = 1; i < SIZE; ++i) { - LinkedBlockingDeque q = populatedDeque(SIZE); - LinkedBlockingDeque p = populatedDeque(i); + LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque p = populatedDeque(i); assertTrue(q.removeAll(p)); - assertEquals(SIZE - i, q.size()); + mustEqual(SIZE - i, q.size()); for (int j = 0; j < i; ++j) { - Integer x = (Integer)(p.remove()); - assertFalse(q.contains(x)); + mustNotContain(q, p.remove()); } } } @@ -1495,29 +1527,32 @@ public class LinkedBlockingDequeTest ext * toArray contains all elements in FIFO order */ public void testToArray() throws InterruptedException { - LinkedBlockingDeque q = populatedDeque(SIZE); - Object[] o = q.toArray(); - for (int i = 0; i < o.length; i++) - assertSame(o[i], q.poll()); + LinkedBlockingDeque q = populatedDeque(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() { - LinkedBlockingDeque q = populatedDeque(SIZE); - Integer[] ints = new Integer[SIZE]; - Integer[] array = q.toArray(ints); - assertSame(ints, array); - for (int i = 0; i < ints.length; i++) - assertSame(ints[i], q.remove()); + LinkedBlockingDeque q = populatedDeque(SIZE); + Item[] items = new Item[SIZE]; + Item[] array = q.toArray(items); + assertSame(items, array); + for (Item o : items) + assertSame(o, q.remove()); + assertTrue(q.isEmpty()); } /** * toArray(incompatible array type) throws ArrayStoreException */ public void testToArray1_BadArg() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); try { q.toArray(new String[10]); shouldThrow(); @@ -1528,18 +1563,18 @@ public class LinkedBlockingDequeTest ext * iterator iterates through all elements */ public void testIterator() throws InterruptedException { - LinkedBlockingDeque q = populatedDeque(SIZE); - Iterator it = q.iterator(); + LinkedBlockingDeque q = populatedDeque(SIZE); + Iterator it = q.iterator(); int i; for (i = 0; it.hasNext(); i++) - assertTrue(q.contains(it.next())); - assertEquals(i, SIZE); + mustContain(q, it.next()); + mustEqual(i, SIZE); assertIteratorExhausted(it); it = q.iterator(); for (i = 0; it.hasNext(); i++) - assertEquals(it.next(), q.take()); - assertEquals(i, SIZE); + mustEqual(it.next(), q.take()); + mustEqual(i, SIZE); assertIteratorExhausted(it); } @@ -1547,7 +1582,7 @@ public class LinkedBlockingDequeTest ext * iterator of empty collection has no elements */ public void testEmptyIterator() { - Deque c = new LinkedBlockingDeque(); + Deque c = new LinkedBlockingDeque(); assertIteratorExhausted(c.iterator()); assertIteratorExhausted(c.descendingIterator()); } @@ -1556,12 +1591,12 @@ public class LinkedBlockingDequeTest ext * iterator.remove removes current element */ public void testIteratorRemove() { - final LinkedBlockingDeque q = new LinkedBlockingDeque(3); + final LinkedBlockingDeque q = new LinkedBlockingDeque(3); q.add(two); q.add(one); q.add(three); - Iterator it = q.iterator(); + Iterator it = q.iterator(); it.next(); it.remove(); @@ -1575,45 +1610,45 @@ public class LinkedBlockingDequeTest ext * iterator ordering is FIFO */ public void testIteratorOrdering() { - final LinkedBlockingDeque q = new LinkedBlockingDeque(3); + final LinkedBlockingDeque q = new LinkedBlockingDeque(3); q.add(one); q.add(two); q.add(three); - assertEquals(0, q.remainingCapacity()); + mustEqual(0, q.remainingCapacity()); int k = 0; - for (Iterator it = q.iterator(); it.hasNext();) { - assertEquals(++k, it.next()); + for (Iterator it = q.iterator(); it.hasNext();) { + mustEqual(++k, it.next()); } - assertEquals(3, k); + mustEqual(3, k); } /** * Modifications do not cause iterators to fail */ public void testWeaklyConsistentIteration() { - final LinkedBlockingDeque q = new LinkedBlockingDeque(3); + final LinkedBlockingDeque q = new LinkedBlockingDeque(3); q.add(one); q.add(two); q.add(three); - for (Iterator it = q.iterator(); it.hasNext();) { + for (Iterator it = q.iterator(); it.hasNext();) { q.remove(); it.next(); } - assertEquals(0, q.size()); + mustEqual(0, q.size()); } /** * Descending iterator iterates through all elements */ public void testDescendingIterator() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); int i = 0; - Iterator it = q.descendingIterator(); + Iterator it = q.descendingIterator(); while (it.hasNext()) { - assertTrue(q.contains(it.next())); + mustContain(q, it.next()); ++i; } - assertEquals(i, SIZE); + mustEqual(i, SIZE); assertFalse(it.hasNext()); try { it.next(); @@ -1625,17 +1660,18 @@ public class LinkedBlockingDequeTest ext * Descending iterator ordering is reverse FIFO */ public void testDescendingIteratorOrdering() { - final LinkedBlockingDeque q = new LinkedBlockingDeque(); + final LinkedBlockingDeque q = new LinkedBlockingDeque(); for (int iters = 0; iters < 100; ++iters) { - q.add(new Integer(3)); - q.add(new Integer(2)); - q.add(new Integer(1)); + mustAdd(q, three); + mustAdd(q, two); + mustAdd(q, one); + int k = 0; - for (Iterator it = q.descendingIterator(); it.hasNext();) { - assertEquals(++k, it.next()); + for (Iterator it = q.descendingIterator(); it.hasNext();) { + mustEqual(++k, it.next()); } - assertEquals(3, k); + mustEqual(3, k); q.remove(); q.remove(); q.remove(); @@ -1646,18 +1682,18 @@ public class LinkedBlockingDequeTest ext * descendingIterator.remove removes current element */ public void testDescendingIteratorRemove() { - final LinkedBlockingDeque q = new LinkedBlockingDeque(); + final LinkedBlockingDeque q = new LinkedBlockingDeque(); for (int iters = 0; iters < 100; ++iters) { - q.add(new Integer(3)); - q.add(new Integer(2)); - q.add(new Integer(1)); - Iterator it = q.descendingIterator(); - assertEquals(it.next(), new Integer(1)); + mustAdd(q, three); + mustAdd(q, two); + mustAdd(q, one); + Iterator it = q.descendingIterator(); + mustEqual(it.next(), one); it.remove(); - assertEquals(it.next(), new Integer(2)); + mustEqual(it.next(), two); it = q.descendingIterator(); - assertEquals(it.next(), new Integer(2)); - assertEquals(it.next(), new Integer(3)); + mustEqual(it.next(), two); + mustEqual(it.next(), three); it.remove(); assertFalse(it.hasNext()); q.remove(); @@ -1668,7 +1704,7 @@ public class LinkedBlockingDequeTest ext * toString contains toStrings of elements */ public void testToString() { - LinkedBlockingDeque q = populatedDeque(SIZE); + LinkedBlockingDeque q = populatedDeque(SIZE); String s = q.toString(); for (int i = 0; i < SIZE; ++i) { assertTrue(s.contains(String.valueOf(i))); @@ -1679,7 +1715,7 @@ public class LinkedBlockingDequeTest ext * offer transfers elements across Executor tasks */ public void testOfferInExecutor() { - final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); q.add(one); q.add(two); final CheckedBarrier threadsStarted = new CheckedBarrier(2); @@ -1690,7 +1726,7 @@ public class LinkedBlockingDequeTest ext assertFalse(q.offer(three)); threadsStarted.await(); assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS)); - assertEquals(0, q.remainingCapacity()); + mustEqual(0, q.remainingCapacity()); }}); executor.execute(new CheckedRunnable() { @@ -1705,7 +1741,7 @@ public class LinkedBlockingDequeTest ext * timed poll retrieves elements across Executor threads */ public void testPollInExecutor() { - final LinkedBlockingDeque q = new LinkedBlockingDeque(2); + final LinkedBlockingDeque q = new LinkedBlockingDeque(2); final CheckedBarrier threadsStarted = new CheckedBarrier(2); final ExecutorService executor = Executors.newFixedThreadPool(2); try (PoolCleaner cleaner = cleaner(executor)) { @@ -1726,19 +1762,19 @@ public class LinkedBlockingDequeTest ext } /** - * A deserialized serialized deque has same elements in same order + * A deserialized/reserialized deque has same elements in same order */ public void testSerialization() throws Exception { - Queue x = populatedDeque(SIZE); - Queue y = serialClone(x); + Queue x = populatedDeque(SIZE); + Queue y = serialClone(x); assertNotSame(y, x); - assertEquals(x.size(), y.size()); - assertEquals(x.toString(), y.toString()); + mustEqual(x.size(), y.size()); + mustEqual(x.toString(), y.toString()); assertTrue(Arrays.equals(x.toArray(), y.toArray())); while (!x.isEmpty()) { assertFalse(y.isEmpty()); - assertEquals(x.remove(), y.remove()); + mustEqual(x.remove(), y.remove()); } assertTrue(y.isEmpty()); } @@ -1747,42 +1783,42 @@ public class LinkedBlockingDequeTest ext * drainTo(c) empties deque into another collection c */ public void testDrainTo() { - LinkedBlockingDeque q = populatedDeque(SIZE); - ArrayList l = new ArrayList(); + LinkedBlockingDeque q = populatedDeque(SIZE); + ArrayList l = new ArrayList(); q.drainTo(l); - assertEquals(0, q.size()); - assertEquals(SIZE, l.size()); + mustEqual(0, q.size()); + mustEqual(SIZE, l.size()); for (int i = 0; i < SIZE; ++i) - assertEquals(l.get(i), new Integer(i)); + mustEqual(l.get(i), i); q.add(zero); q.add(one); assertFalse(q.isEmpty()); - assertTrue(q.contains(zero)); - assertTrue(q.contains(one)); + mustContain(q, zero); + mustContain(q, one); l.clear(); q.drainTo(l); - assertEquals(0, q.size()); - assertEquals(2, l.size()); + mustEqual(0, q.size()); + mustEqual(2, l.size()); for (int i = 0; i < 2; ++i) - assertEquals(l.get(i), new Integer(i)); + mustEqual(l.get(i), i); } /** * drainTo empties full deque, unblocking a waiting put. */ public void testDrainToWithActivePut() throws InterruptedException { - final LinkedBlockingDeque q = populatedDeque(SIZE); + final LinkedBlockingDeque q = populatedDeque(SIZE); Thread t = new Thread(new CheckedRunnable() { public void realRun() throws InterruptedException { - q.put(new Integer(SIZE + 1)); + q.put(new Item(SIZE + 1)); }}); t.start(); - ArrayList l = new ArrayList(); + ArrayList l = new ArrayList(); q.drainTo(l); assertTrue(l.size() >= SIZE); for (int i = 0; i < SIZE; ++i) - assertEquals(l.get(i), new Integer(i)); + mustEqual(l.get(i), i); t.join(); assertTrue(q.size() + l.size() >= SIZE); } @@ -1791,17 +1827,17 @@ public class LinkedBlockingDequeTest ext * drainTo(c, n) empties first min(n, size) elements of queue into c */ public void testDrainToN() { - LinkedBlockingDeque q = new LinkedBlockingDeque(); + LinkedBlockingDeque q = new LinkedBlockingDeque(); for (int i = 0; i < SIZE + 2; ++i) { for (int j = 0; j < SIZE; j++) - assertTrue(q.offer(new Integer(j))); - ArrayList l = new ArrayList(); + mustOffer(q, j); + ArrayList l = new ArrayList(); q.drainTo(l, i); int k = (i < SIZE) ? i : SIZE; - assertEquals(k, l.size()); - assertEquals(SIZE - k, q.size()); + mustEqual(k, l.size()); + mustEqual(SIZE - k, q.size()); for (int j = 0; j < k; ++j) - assertEquals(l.get(j), new Integer(j)); + mustEqual(l.get(j), j); do {} while (q.poll() != null); } }