ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/LinkedBlockingDequeTest.java

Comparing jsr166/src/test/tck/LinkedBlockingDequeTest.java (file contents):
Revision 1.88 by dl, Tue Jan 26 13:33:06 2021 UTC vs.
Revision 1.89 by jsr166, Wed Jan 27 01:57:24 2021 UTC

#	Line 59 | Line 59 | public class LinkedBlockingDequeTest ext
59		* Items 0 ... n - 1.
60		*/
61		private static LinkedBlockingDeque<Item> populatedDeque(int n) {
62	<	LinkedBlockingDeque<Item> q =
63	<	new LinkedBlockingDeque<Item>(n);
62	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(n);
63		assertTrue(q.isEmpty());
64		for (int i = 0; i < n; i++)
65		mustOffer(q, i);
#	Line 76 | Line 75 | public class LinkedBlockingDequeTest ext
75		* isEmpty is true before add, false after
76		*/
77		public void testEmpty() {
78	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>();
78	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>();
79		assertTrue(q.isEmpty());
80		q.add(one);
81		assertFalse(q.isEmpty());
#	Line 105 | Line 104 | public class LinkedBlockingDequeTest ext
104		* offerFirst(null) throws NullPointerException
105		*/
106		public void testOfferFirstNull() {
107	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>();
107	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>();
108		try {
109		q.offerFirst(null);
110		shouldThrow();
#	Line 116 | Line 115 | public class LinkedBlockingDequeTest ext
115		* offerLast(null) throws NullPointerException
116		*/
117		public void testOfferLastNull() {
118	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>();
118	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>();
119		try {
120		q.offerLast(null);
121		shouldThrow();
#	Line 127 | Line 126 | public class LinkedBlockingDequeTest ext
126		* OfferFirst succeeds
127		*/
128		public void testOfferFirst() {
129	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>();
129	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>();
130		assertTrue(q.offerFirst(zero));
131		assertTrue(q.offerFirst(two));
132		}
#	Line 136 | Line 135 | public class LinkedBlockingDequeTest ext
135		* OfferLast succeeds
136		*/
137		public void testOfferLast() {
138	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>();
138	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>();
139		assertTrue(q.offerLast(zero));
140		assertTrue(q.offerLast(one));
141		}
#	Line 390 | Line 389 | public class LinkedBlockingDequeTest ext
389		*/
390		public void testConstructor6() {
391		Item[] items = defaultItems;
392	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(Arrays.asList(items));
392	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(Arrays.asList(items));
393		for (int i = 0; i < SIZE; ++i)
394		mustEqual(items[i], q.poll());
395		}
#	Line 399 | Line 398 | public class LinkedBlockingDequeTest ext
398		* Deque transitions from empty to full when elements added
399		*/
400		public void testEmptyFull() {
401	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(2);
401	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(2);
402		assertTrue(q.isEmpty());
403		mustEqual(2, q.remainingCapacity());
404		q.add(one);
#	Line 431 | Line 430 | public class LinkedBlockingDequeTest ext
430		* push(null) throws NPE
431		*/
432		public void testPushNull() {
433	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(1);
433	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(1);
434		try {
435		q.push(null);
436		shouldThrow();
#	Line 442 | Line 441 | public class LinkedBlockingDequeTest ext
441		* push succeeds if not full; throws IllegalStateException if full
442		*/
443		public void testPush() {
444	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(SIZE);
444	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(SIZE);
445		for (int i = 0; i < SIZE; ++i) {
446		Item x = itemFor(i);
447		q.push(x);
#	Line 483 | Line 482 | public class LinkedBlockingDequeTest ext
482		* Offer succeeds if not full; fails if full
483		*/
484		public void testOffer() {
485	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(1);
485	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(1);
486		assertTrue(q.offer(zero));
487		assertFalse(q.offer(one));
488		}
#	Line 492 | Line 491 | public class LinkedBlockingDequeTest ext
491		* add succeeds if not full; throws IllegalStateException if full
492		*/
493		public void testAdd() {
494	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(SIZE);
494	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(SIZE);
495		for (int i = 0; i < SIZE; ++i)
496		mustAdd(q, i);
497		mustEqual(0, q.remainingCapacity());
#	Line 518 | Line 517 | public class LinkedBlockingDequeTest ext
517		* possibly adding some elements
518		*/
519		public void testAddAll3() {
520	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(SIZE);
520	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(SIZE);
521		Item[] items = new Item[2]; items[0] = zero;
522		Collection<Item> elements = Arrays.asList(items);
523		try {
#	Line 531 | Line 530 | public class LinkedBlockingDequeTest ext
530		* addAll throws IllegalStateException if not enough room
531		*/
532		public void testAddAll4() {
533	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(SIZE - 1);
533	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(SIZE - 1);
534		Item[] items = defaultItems;
535		Collection<Item> elements = Arrays.asList(items);
536		try {
#	Line 546 | Line 545 | public class LinkedBlockingDequeTest ext
545		public void testAddAll5() {
546		Item[] empty = new Item[0];
547		Item[] items = defaultItems;
548	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(SIZE);
548	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(SIZE);
549		assertFalse(q.addAll(Arrays.asList(empty)));
550		assertTrue(q.addAll(Arrays.asList(items)));
551		for (int i = 0; i < SIZE; ++i)
#	Line 557 | Line 556 | public class LinkedBlockingDequeTest ext
556		* all elements successfully put are contained
557		*/
558		public void testPut() throws InterruptedException {
559	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(SIZE);
559	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(SIZE);
560		for (int i = 0; i < SIZE; ++i) {
561		Item x = itemFor(i);
562		q.put(x);
#	Line 570 | Line 569 | public class LinkedBlockingDequeTest ext
569		* put blocks interruptibly if full
570		*/
571		public void testBlockingPut() throws InterruptedException {
572	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(SIZE);
572	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(SIZE);
573		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
574		Thread t = newStartedThread(new CheckedRunnable() {
575		public void realRun() throws InterruptedException {
#	Line 607 | Line 606 | public class LinkedBlockingDequeTest ext
606		*/
607		public void testPutWithTake() throws InterruptedException {
608		final int capacity = 2;
609	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(capacity);
609	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(capacity);
610		final CountDownLatch pleaseTake = new CountDownLatch(1);
611		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
612		Thread t = newStartedThread(new CheckedRunnable() {
#	Line 647 | Line 646 | public class LinkedBlockingDequeTest ext
646		* timed offer times out if full and elements not taken
647		*/
648		public void testTimedOffer() {
649	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(2);
649	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(2);
650		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
651		Thread t = newStartedThread(new CheckedRunnable() {
652		public void realRun() throws InterruptedException {
#	Line 796 | Line 795 | public class LinkedBlockingDequeTest ext
795		* putFirst(null) throws NPE
796		*/
797		public void testPutFirstNull() throws InterruptedException {
798	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(SIZE);
798	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(SIZE);
799		try {
800		q.putFirst(null);
801		shouldThrow();
#	Line 807 | Line 806 | public class LinkedBlockingDequeTest ext
806		* all elements successfully putFirst are contained
807		*/
808		public void testPutFirst() throws InterruptedException {
809	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(SIZE);
809	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(SIZE);
810		for (int i = 0; i < SIZE; ++i) {
811		Item x = itemFor(i);
812		q.putFirst(x);
#	Line 820 | Line 819 | public class LinkedBlockingDequeTest ext
819		* putFirst blocks interruptibly if full
820		*/
821		public void testBlockingPutFirst() throws InterruptedException {
822	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(SIZE);
822	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(SIZE);
823		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
824		Thread t = newStartedThread(new CheckedRunnable() {
825		public void realRun() throws InterruptedException {
#	Line 857 | Line 856 | public class LinkedBlockingDequeTest ext
856		*/
857		public void testPutFirstWithTake() throws InterruptedException {
858		final int capacity = 2;
859	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(capacity);
859	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(capacity);
860		final CountDownLatch pleaseTake = new CountDownLatch(1);
861		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
862		Thread t = newStartedThread(new CheckedRunnable() {
#	Line 890 | Line 889 | public class LinkedBlockingDequeTest ext
889		* timed offerFirst times out if full and elements not taken
890		*/
891		public void testTimedOfferFirst() {
892	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(2);
892	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(2);
893		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
894		Thread t = newStartedThread(new CheckedRunnable() {
895		public void realRun() throws InterruptedException {
#	Line 936 | Line 935 | public class LinkedBlockingDequeTest ext
935		* takeFirst() blocks interruptibly when empty
936		*/
937		public void testTakeFirstFromEmptyBlocksInterruptibly() {
938	<	final BlockingDeque<Item> q = new LinkedBlockingDeque<Item>();
938	>	final BlockingDeque<Item> q = new LinkedBlockingDeque<>();
939		final CountDownLatch threadStarted = new CountDownLatch(1);
940		Thread t = newStartedThread(new CheckedRunnable() {
941		public void realRun() {
#	Line 959 | Line 958 | public class LinkedBlockingDequeTest ext
958		* before waiting
959		*/
960		public void testTakeFirstFromEmptyAfterInterrupt() {
961	<	final BlockingDeque<Item> q = new LinkedBlockingDeque<Item>();
961	>	final BlockingDeque<Item> q = new LinkedBlockingDeque<>();
962		Thread t = newStartedThread(new CheckedRunnable() {
963		public void realRun() {
964		Thread.currentThread().interrupt();
#	Line 977 | Line 976 | public class LinkedBlockingDequeTest ext
976		* takeLast() blocks interruptibly when empty
977		*/
978		public void testTakeLastFromEmptyBlocksInterruptibly() {
979	<	final BlockingDeque<Item> q = new LinkedBlockingDeque<Item>();
979	>	final BlockingDeque<Item> q = new LinkedBlockingDeque<>();
980		final CountDownLatch threadStarted = new CountDownLatch(1);
981		Thread t = newStartedThread(new CheckedRunnable() {
982		public void realRun() {
#	Line 1000 | Line 999 | public class LinkedBlockingDequeTest ext
999		* before waiting
1000		*/
1001		public void testTakeLastFromEmptyAfterInterrupt() {
1002	<	final BlockingDeque<Item> q = new LinkedBlockingDeque<Item>();
1002	>	final BlockingDeque<Item> q = new LinkedBlockingDeque<>();
1003		Thread t = newStartedThread(new CheckedRunnable() {
1004		public void realRun() {
1005		Thread.currentThread().interrupt();
#	Line 1110 | Line 1109 | public class LinkedBlockingDequeTest ext
1109		* on interruption throws
1110		*/
1111		public void testTimedPollFirstWithOfferFirst() throws InterruptedException {
1112	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(2);
1112	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(2);
1113		final CheckedBarrier barrier = new CheckedBarrier(2);
1114		Thread t = newStartedThread(new CheckedRunnable() {
1115		public void realRun() throws InterruptedException {
#	Line 1152 | Line 1151 | public class LinkedBlockingDequeTest ext
1151		* putLast(null) throws NPE
1152		*/
1153		public void testPutLastNull() throws InterruptedException {
1154	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(SIZE);
1154	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(SIZE);
1155		try {
1156		q.putLast(null);
1157		shouldThrow();
#	Line 1163 | Line 1162 | public class LinkedBlockingDequeTest ext
1162		* all elements successfully putLast are contained
1163		*/
1164		public void testPutLast() throws InterruptedException {
1165	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(SIZE);
1165	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(SIZE);
1166		for (int i = 0; i < SIZE; ++i) {
1167		Item x = itemFor(i);
1168		q.putLast(x);
#	Line 1176 | Line 1175 | public class LinkedBlockingDequeTest ext
1175		* putLast blocks interruptibly if full
1176		*/
1177		public void testBlockingPutLast() throws InterruptedException {
1178	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(SIZE);
1178	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(SIZE);
1179		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1180		Thread t = newStartedThread(new CheckedRunnable() {
1181		public void realRun() throws InterruptedException {
#	Line 1213 | Line 1212 | public class LinkedBlockingDequeTest ext
1212		*/
1213		public void testPutLastWithTake() throws InterruptedException {
1214		final int capacity = 2;
1215	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(capacity);
1215	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(capacity);
1216		final CountDownLatch pleaseTake = new CountDownLatch(1);
1217		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1218		Thread t = newStartedThread(new CheckedRunnable() {
#	Line 1253 | Line 1252 | public class LinkedBlockingDequeTest ext
1252		* timed offerLast times out if full and elements not taken
1253		*/
1254		public void testTimedOfferLast() {
1255	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(2);
1255	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(2);
1256		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1257		Thread t = newStartedThread(new CheckedRunnable() {
1258		public void realRun() throws InterruptedException {
#	Line 1392 | Line 1391 | public class LinkedBlockingDequeTest ext
1391		* on interruption throws
1392		*/
1393		public void testTimedPollWithOfferLast() throws InterruptedException {
1394	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(2);
1394	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(2);
1395		final CheckedBarrier barrier = new CheckedBarrier(2);
1396		Thread t = newStartedThread(new CheckedRunnable() {
1397		public void realRun() throws InterruptedException {
#	Line 1480 | Line 1479 | public class LinkedBlockingDequeTest ext
1479		*/
1480		public void testContainsAll() {
1481		LinkedBlockingDeque<Item> q = populatedDeque(SIZE);
1482	<	LinkedBlockingDeque<Item> p = new LinkedBlockingDeque<Item>(SIZE);
1482	>	LinkedBlockingDeque<Item> p = new LinkedBlockingDeque<>(SIZE);
1483		for (int i = 0; i < SIZE; ++i) {
1484		assertTrue(q.containsAll(p));
1485		assertFalse(p.containsAll(q));
#	Line 1582 | Line 1581 | public class LinkedBlockingDequeTest ext
1581		* iterator of empty collection has no elements
1582		*/
1583		public void testEmptyIterator() {
1584	<	Deque<Item> c = new LinkedBlockingDeque<Item>();
1584	>	Deque<Item> c = new LinkedBlockingDeque<>();
1585		assertIteratorExhausted(c.iterator());
1586		assertIteratorExhausted(c.descendingIterator());
1587		}
#	Line 1591 | Line 1590 | public class LinkedBlockingDequeTest ext
1590		* iterator.remove removes current element
1591		*/
1592		public void testIteratorRemove() {
1593	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(3);
1593	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(3);
1594		q.add(two);
1595		q.add(one);
1596		q.add(three);
#	Line 1610 | Line 1609 | public class LinkedBlockingDequeTest ext
1609		* iterator ordering is FIFO
1610		*/
1611		public void testIteratorOrdering() {
1612	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(3);
1612	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(3);
1613		q.add(one);
1614		q.add(two);
1615		q.add(three);
#	Line 1626 | Line 1625 | public class LinkedBlockingDequeTest ext
1625		* Modifications do not cause iterators to fail
1626		*/
1627		public void testWeaklyConsistentIteration() {
1628	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(3);
1628	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(3);
1629		q.add(one);
1630		q.add(two);
1631		q.add(three);
#	Line 1660 | Line 1659 | public class LinkedBlockingDequeTest ext
1659		* Descending iterator ordering is reverse FIFO
1660		*/
1661		public void testDescendingIteratorOrdering() {
1662	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>();
1662	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>();
1663		for (int iters = 0; iters < 100; ++iters) {
1664		mustAdd(q, three);
1665		mustAdd(q, two);
#	Line 1682 | Line 1681 | public class LinkedBlockingDequeTest ext
1681		* descendingIterator.remove removes current element
1682		*/
1683		public void testDescendingIteratorRemove() {
1684	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>();
1684	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>();
1685		for (int iters = 0; iters < 100; ++iters) {
1686		mustAdd(q, three);
1687		mustAdd(q, two);
#	Line 1715 | Line 1714 | public class LinkedBlockingDequeTest ext
1714		* offer transfers elements across Executor tasks
1715		*/
1716		public void testOfferInExecutor() {
1717	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(2);
1717	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(2);
1718		q.add(one);
1719		q.add(two);
1720		final CheckedBarrier threadsStarted = new CheckedBarrier(2);
#	Line 1741 | Line 1740 | public class LinkedBlockingDequeTest ext
1740		* timed poll retrieves elements across Executor threads
1741		*/
1742		public void testPollInExecutor() {
1743	<	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>(2);
1743	>	final LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>(2);
1744		final CheckedBarrier threadsStarted = new CheckedBarrier(2);
1745		final ExecutorService executor = Executors.newFixedThreadPool(2);
1746		try (PoolCleaner cleaner = cleaner(executor)) {
#	Line 1784 | Line 1783 | public class LinkedBlockingDequeTest ext
1783		*/
1784		public void testDrainTo() {
1785		LinkedBlockingDeque<Item> q = populatedDeque(SIZE);
1786	<	ArrayList<Item> l = new ArrayList<Item>();
1786	>	ArrayList<Item> l = new ArrayList<>();
1787		q.drainTo(l);
1788		mustEqual(0, q.size());
1789		mustEqual(SIZE, l.size());
#	Line 1814 | Line 1813 | public class LinkedBlockingDequeTest ext
1813		}});
1814
1815		t.start();
1816	<	ArrayList<Item> l = new ArrayList<Item>();
1816	>	ArrayList<Item> l = new ArrayList<>();
1817		q.drainTo(l);
1818		assertTrue(l.size() >= SIZE);
1819		for (int i = 0; i < SIZE; ++i)
#	Line 1827 | Line 1826 | public class LinkedBlockingDequeTest ext
1826		* drainTo(c, n) empties first min(n, size) elements of queue into c
1827		*/
1828		public void testDrainToN() {
1829	<	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<Item>();
1829	>	LinkedBlockingDeque<Item> q = new LinkedBlockingDeque<>();
1830		for (int i = 0; i < SIZE + 2; ++i) {
1831		for (int j = 0; j < SIZE; j++)
1832		mustOffer(q, j);
1833	<	ArrayList<Item> l = new ArrayList<Item>();
1833	>	ArrayList<Item> l = new ArrayList<>();
1834		q.drainTo(l, i);
1835		int k = (i < SIZE) ? i : SIZE;
1836		mustEqual(k, l.size());
#	Line 1847 | Line 1846 | public class LinkedBlockingDequeTest ext
1846		*/
1847		public void testNeverContainsNull() {
1848		Deque<?>[] qs = {
1849	<	new LinkedBlockingDeque<Object>(),
1849	>	new LinkedBlockingDeque<>(),
1850		populatedDeque(2),
1851		};
1852

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines