169 |
|
q.getFirst(); |
170 |
|
shouldThrow(); |
171 |
|
} catch (NoSuchElementException success) {} |
172 |
+ |
assertNull(q.peekFirst()); |
173 |
|
} |
174 |
|
|
175 |
|
/** |
200 |
|
q.removeFirst(); |
201 |
|
shouldThrow(); |
202 |
|
} catch (NoSuchElementException success) {} |
203 |
+ |
assertNull(q.peekFirst()); |
204 |
+ |
} |
205 |
+ |
|
206 |
+ |
/** |
207 |
+ |
* removeLast removes last element, or throws NSEE if empty |
208 |
+ |
*/ |
209 |
+ |
public void testRemoveLast() { |
210 |
+ |
LinkedBlockingDeque q = populatedDeque(SIZE); |
211 |
+ |
for (int i = SIZE - 1; i >= 0; --i) { |
212 |
+ |
assertEquals(i, ((Integer)q.removeLast()).intValue()); |
213 |
+ |
} |
214 |
+ |
try { |
215 |
+ |
q.removeLast(); |
216 |
+ |
shouldThrow(); |
217 |
+ |
} catch (NoSuchElementException success) {} |
218 |
+ |
assertNull(q.peekLast()); |
219 |
|
} |
220 |
|
|
221 |
|
/** |
340 |
|
* Deque contains all elements of collection used to initialize |
341 |
|
*/ |
342 |
|
public void testConstructor6() { |
343 |
< |
try { |
344 |
< |
Integer[] ints = new Integer[SIZE]; |
345 |
< |
for (int i = 0; i < SIZE; ++i) |
346 |
< |
ints[i] = new Integer(i); |
347 |
< |
LinkedBlockingDeque q = new LinkedBlockingDeque(Arrays.asList(ints)); |
348 |
< |
for (int i = 0; i < SIZE; ++i) |
332 |
< |
assertEquals(ints[i], q.poll()); |
333 |
< |
} |
334 |
< |
finally {} |
343 |
> |
Integer[] ints = new Integer[SIZE]; |
344 |
> |
for (int i = 0; i < SIZE; ++i) |
345 |
> |
ints[i] = new Integer(i); |
346 |
> |
LinkedBlockingDeque q = new LinkedBlockingDeque(Arrays.asList(ints)); |
347 |
> |
for (int i = 0; i < SIZE; ++i) |
348 |
> |
assertEquals(ints[i], q.poll()); |
349 |
|
} |
350 |
|
|
351 |
|
/** |
544 |
|
* Deque contains all elements, in traversal order, of successful addAll |
545 |
|
*/ |
546 |
|
public void testAddAll5() { |
547 |
< |
try { |
548 |
< |
Integer[] empty = new Integer[0]; |
549 |
< |
Integer[] ints = new Integer[SIZE]; |
550 |
< |
for (int i = 0; i < SIZE; ++i) |
551 |
< |
ints[i] = new Integer(i); |
552 |
< |
LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); |
553 |
< |
assertFalse(q.addAll(Arrays.asList(empty))); |
554 |
< |
assertTrue(q.addAll(Arrays.asList(ints))); |
555 |
< |
for (int i = 0; i < SIZE; ++i) |
542 |
< |
assertEquals(ints[i], q.poll()); |
543 |
< |
} |
544 |
< |
finally {} |
547 |
> |
Integer[] empty = new Integer[0]; |
548 |
> |
Integer[] ints = new Integer[SIZE]; |
549 |
> |
for (int i = 0; i < SIZE; ++i) |
550 |
> |
ints[i] = new Integer(i); |
551 |
> |
LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE); |
552 |
> |
assertFalse(q.addAll(Arrays.asList(empty))); |
553 |
> |
assertTrue(q.addAll(Arrays.asList(ints))); |
554 |
> |
for (int i = 0; i < SIZE; ++i) |
555 |
> |
assertEquals(ints[i], q.poll()); |
556 |
|
} |
557 |
|
|
558 |
|
|
739 |
|
* returning timeout status |
740 |
|
*/ |
741 |
|
public void testInterruptedTimedPoll() throws InterruptedException { |
742 |
< |
Thread t = new ThreadShouldThrow(InterruptedException.class) { |
742 |
> |
Thread t = new Thread(new CheckedRunnable() { |
743 |
|
public void realRun() throws InterruptedException { |
744 |
|
LinkedBlockingDeque q = populatedDeque(SIZE); |
745 |
|
for (int i = 0; i < SIZE; ++i) { |
746 |
< |
threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue()); |
746 |
> |
assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue()); |
747 |
|
} |
748 |
< |
q.poll(SMALL_DELAY_MS, MILLISECONDS); |
749 |
< |
}}; |
748 |
> |
try { |
749 |
> |
q.poll(SMALL_DELAY_MS, MILLISECONDS); |
750 |
> |
shouldThrow(); |
751 |
> |
} catch (InterruptedException success) {} |
752 |
> |
}}); |
753 |
|
|
754 |
|
t.start(); |
755 |
|
Thread.sleep(SHORT_DELAY_MS); |
763 |
|
*/ |
764 |
|
public void testTimedPollWithOffer() throws InterruptedException { |
765 |
|
final LinkedBlockingDeque q = new LinkedBlockingDeque(2); |
766 |
< |
Thread t = new ThreadShouldThrow(InterruptedException.class) { |
766 |
> |
Thread t = new Thread(new CheckedRunnable() { |
767 |
|
public void realRun() throws InterruptedException { |
768 |
< |
threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); |
769 |
< |
q.poll(LONG_DELAY_MS, MILLISECONDS); |
770 |
< |
q.poll(LONG_DELAY_MS, MILLISECONDS); |
771 |
< |
}}; |
768 |
> |
assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS)); |
769 |
> |
assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS)); |
770 |
> |
try { |
771 |
> |
q.poll(LONG_DELAY_MS, MILLISECONDS); |
772 |
> |
shouldThrow(); |
773 |
> |
} catch (InterruptedException success) {} |
774 |
> |
}}); |
775 |
|
|
776 |
|
t.start(); |
777 |
|
Thread.sleep(SMALL_DELAY_MS); |
953 |
|
* returning timeout status |
954 |
|
*/ |
955 |
|
public void testInterruptedTimedPollFirst() throws InterruptedException { |
956 |
< |
Thread t = new ThreadShouldThrow(InterruptedException.class) { |
956 |
> |
Thread t = new Thread(new CheckedRunnable() { |
957 |
|
public void realRun() throws InterruptedException { |
958 |
|
LinkedBlockingDeque q = populatedDeque(SIZE); |
959 |
|
for (int i = 0; i < SIZE; ++i) { |
960 |
< |
threadAssertEquals(i, ((Integer)q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)).intValue()); |
960 |
> |
assertEquals(i, ((Integer)q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)).intValue()); |
961 |
|
} |
962 |
< |
q.pollFirst(SMALL_DELAY_MS, MILLISECONDS); |
963 |
< |
}}; |
962 |
> |
try { |
963 |
> |
q.pollFirst(SMALL_DELAY_MS, MILLISECONDS); |
964 |
> |
shouldThrow(); |
965 |
> |
} catch (InterruptedException success) {} |
966 |
> |
}}); |
967 |
|
|
968 |
|
t.start(); |
969 |
|
Thread.sleep(SHORT_DELAY_MS); |
977 |
|
*/ |
978 |
|
public void testTimedPollFirstWithOfferFirst() throws InterruptedException { |
979 |
|
final LinkedBlockingDeque q = new LinkedBlockingDeque(2); |
980 |
< |
Thread t = new ThreadShouldThrow(InterruptedException.class) { |
980 |
> |
Thread t = new Thread(new CheckedRunnable() { |
981 |
|
public void realRun() throws InterruptedException { |
982 |
< |
threadAssertNull(q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)); |
983 |
< |
q.pollFirst(LONG_DELAY_MS, MILLISECONDS); |
984 |
< |
q.pollFirst(LONG_DELAY_MS, MILLISECONDS); |
985 |
< |
}}; |
982 |
> |
assertNull(q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)); |
983 |
> |
assertSame(zero, q.pollFirst(LONG_DELAY_MS, MILLISECONDS)); |
984 |
> |
try { |
985 |
> |
q.pollFirst(LONG_DELAY_MS, MILLISECONDS); |
986 |
> |
shouldThrow(); |
987 |
> |
} catch (InterruptedException success) {} |
988 |
> |
}}); |
989 |
|
|
990 |
|
t.start(); |
991 |
|
Thread.sleep(SMALL_DELAY_MS); |
1166 |
|
* returning timeout status |
1167 |
|
*/ |
1168 |
|
public void testInterruptedTimedPollLast() throws InterruptedException { |
1169 |
< |
Thread t = new ThreadShouldThrow(InterruptedException.class) { |
1169 |
> |
Thread t = new Thread(new CheckedRunnable() { |
1170 |
|
public void realRun() throws InterruptedException { |
1171 |
|
LinkedBlockingDeque q = populatedDeque(SIZE); |
1172 |
|
for (int i = 0; i < SIZE; ++i) { |
1173 |
< |
threadAssertEquals(SIZE-i-1, ((Integer)q.pollLast(SHORT_DELAY_MS, MILLISECONDS)).intValue()); |
1173 |
> |
assertEquals(SIZE-i-1, ((Integer)q.pollLast(SHORT_DELAY_MS, MILLISECONDS)).intValue()); |
1174 |
|
} |
1175 |
< |
q.pollLast(SMALL_DELAY_MS, MILLISECONDS); |
1176 |
< |
}}; |
1175 |
> |
try { |
1176 |
> |
q.pollLast(SMALL_DELAY_MS, MILLISECONDS); |
1177 |
> |
shouldThrow(); |
1178 |
> |
} catch (InterruptedException success) {} |
1179 |
> |
}}); |
1180 |
|
|
1181 |
|
t.start(); |
1182 |
|
Thread.sleep(SHORT_DELAY_MS); |