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.16 by jsr166, Sat Nov 21 22:00:46 2009 UTC vs.
Revision 1.27 by jsr166, Tue Oct 19 00:43:49 2010 UTC

#	Line 11 | Line 11 | import static java.util.concurrent.TimeU
11		import java.io.*;
12
13		public class LinkedBlockingDequeTest extends JSR166TestCase {
14	+
15	+	public static class Unbounded extends BlockingQueueTest {
16	+	protected BlockingQueue emptyCollection() {
17	+	return new LinkedBlockingDeque();
18	+	}
19	+	}
20	+
21	+	public static class Bounded extends BlockingQueueTest {
22	+	protected BlockingQueue emptyCollection() {
23	+	return new LinkedBlockingDeque(20);
24	+	}
25	+	}
26	+
27		public static void main(String[] args) {
28	<	junit.textui.TestRunner.run (suite());
28	>	junit.textui.TestRunner.run(suite());
29		}
30
31		public static Test suite() {
32	<	return new TestSuite(LinkedBlockingDequeTest.class);
32	>	return newTestSuite(LinkedBlockingDequeTest.class,
33	>	new Unbounded().testSuite(),
34	>	new Bounded().testSuite());
35		}
36
37		/**
#	Line 93 | Line 108 | public class LinkedBlockingDequeTest ext
108		}
109
110		/**
111	<	*  pollFirst succeeds unless empty
111	>	* pollFirst succeeds unless empty
112		*/
113		public void testPollFirst() {
114		LinkedBlockingDeque q = populatedDeque(SIZE);
115		for (int i = 0; i < SIZE; ++i) {
116	<	assertEquals(i, ((Integer)q.pollFirst()).intValue());
116	>	assertEquals(i, q.pollFirst());
117		}
118		assertNull(q.pollFirst());
119		}
120
121		/**
122	<	*  pollLast succeeds unless empty
122	>	* pollLast succeeds unless empty
123		*/
124		public void testPollLast() {
125		LinkedBlockingDeque q = populatedDeque(SIZE);
126		for (int i = SIZE-1; i >= 0; --i) {
127	<	assertEquals(i, ((Integer)q.pollLast()).intValue());
127	>	assertEquals(i, q.pollLast());
128		}
129		assertNull(q.pollLast());
130		}
131
132		/**
133	<	*  peekFirst returns next element, or null if empty
133	>	* peekFirst returns next element, or null if empty
134		*/
135		public void testPeekFirst() {
136		LinkedBlockingDeque q = populatedDeque(SIZE);
137		for (int i = 0; i < SIZE; ++i) {
138	<	assertEquals(i, ((Integer)q.peekFirst()).intValue());
139	<	q.pollFirst();
138	>	assertEquals(i, q.peekFirst());
139	>	assertEquals(i, q.pollFirst());
140		assertTrue(q.peekFirst() == null ||
141	<	i != ((Integer)q.peekFirst()).intValue());
141	>	!q.peekFirst().equals(i));
142		}
143		assertNull(q.peekFirst());
144		}
145
146		/**
147	<	*  peek returns next element, or null if empty
147	>	* peek returns next element, or null if empty
148		*/
149		public void testPeek() {
150		LinkedBlockingDeque q = populatedDeque(SIZE);
151		for (int i = 0; i < SIZE; ++i) {
152	<	assertEquals(i, ((Integer)q.peek()).intValue());
153	<	q.pollFirst();
152	>	assertEquals(i, q.peek());
153	>	assertEquals(i, q.pollFirst());
154		assertTrue(q.peek() == null ||
155	<	i != ((Integer)q.peek()).intValue());
155	>	!q.peek().equals(i));
156		}
157		assertNull(q.peek());
158		}
159
160		/**
161	<	*  peekLast returns next element, or null if empty
161	>	* peekLast returns next element, or null if empty
162		*/
163		public void testPeekLast() {
164		LinkedBlockingDeque q = populatedDeque(SIZE);
165		for (int i = SIZE-1; i >= 0; --i) {
166	<	assertEquals(i, ((Integer)q.peekLast()).intValue());
167	<	q.pollLast();
166	>	assertEquals(i, q.peekLast());
167	>	assertEquals(i, q.pollLast());
168		assertTrue(q.peekLast() == null ||
169	<	i != ((Integer)q.peekLast()).intValue());
169	>	!q.peekLast().equals(i));
170		}
171		assertNull(q.peekLast());
172		}
173
174		/**
175	<	* getFirst returns next getFirst, or throws NSEE if empty
175	>	* getFirst() returns first element, or throws NSEE if empty
176		*/
177		public void testFirstElement() {
178		LinkedBlockingDeque q = populatedDeque(SIZE);
179		for (int i = 0; i < SIZE; ++i) {
180	<	assertEquals(i, ((Integer)q.getFirst()).intValue());
181	<	q.pollFirst();
180	>	assertEquals(i, q.getFirst());
181	>	assertEquals(i, q.pollFirst());
182		}
183		try {
184		q.getFirst();
#	Line 173 | Line 188 | public class LinkedBlockingDequeTest ext
188		}
189
190		/**
191	<	*  getLast returns next element, or throws NSEE if empty
191	>	* getLast() returns last element, or throws NSEE if empty
192		*/
193		public void testLastElement() {
194		LinkedBlockingDeque q = populatedDeque(SIZE);
195		for (int i = SIZE-1; i >= 0; --i) {
196	<	assertEquals(i, ((Integer)q.getLast()).intValue());
197	<	q.pollLast();
196	>	assertEquals(i, q.getLast());
197	>	assertEquals(i, q.pollLast());
198		}
199		try {
200		q.getLast();
#	Line 189 | Line 204 | public class LinkedBlockingDequeTest ext
204		}
205
206		/**
207	<	*  removeFirst removes next element, or throws NSEE if empty
207	>	* removeFirst() removes first element, or throws NSEE if empty
208		*/
209		public void testRemoveFirst() {
210		LinkedBlockingDeque q = populatedDeque(SIZE);
211		for (int i = 0; i < SIZE; ++i) {
212	<	assertEquals(i, ((Integer)q.removeFirst()).intValue());
212	>	assertEquals(i, q.removeFirst());
213		}
214		try {
215		q.removeFirst();
#	Line 204 | Line 219 | public class LinkedBlockingDequeTest ext
219		}
220
221		/**
222	<	*  removeLast removes last element, or throws NSEE if empty
222	>	* removeLast() removes last element, or throws NSEE if empty
223		*/
224		public void testRemoveLast() {
225		LinkedBlockingDeque q = populatedDeque(SIZE);
226		for (int i = SIZE - 1; i >= 0; --i) {
227	<	assertEquals(i, ((Integer)q.removeLast()).intValue());
227	>	assertEquals(i, q.removeLast());
228		}
229		try {
230		q.removeLast();
#	Line 219 | Line 234 | public class LinkedBlockingDequeTest ext
234		}
235
236		/**
237	<	*  remove removes next element, or throws NSEE if empty
237	>	* remove removes next element, or throws NSEE if empty
238		*/
239		public void testRemove() {
240		LinkedBlockingDeque q = populatedDeque(SIZE);
241		for (int i = 0; i < SIZE; ++i) {
242	<	assertEquals(i, ((Integer)q.remove()).intValue());
242	>	assertEquals(i, q.remove());
243		}
244		try {
245		q.remove();
#	Line 269 | Line 284 | public class LinkedBlockingDequeTest ext
284		LinkedBlockingDeque q = populatedDeque(3);
285		q.pollLast();
286		q.addFirst(four);
287	<	assertEquals(four,q.peekFirst());
287	>	assertSame(four, q.peekFirst());
288		}
289
290		/**
#	Line 279 | Line 294 | public class LinkedBlockingDequeTest ext
294		LinkedBlockingDeque q = populatedDeque(3);
295		q.pollLast();
296		q.addLast(four);
297	<	assertEquals(four,q.peekLast());
297	>	assertSame(four, q.peekLast());
298		}
299
300
#	Line 437 | Line 452 | public class LinkedBlockingDequeTest ext
452		LinkedBlockingDeque q = populatedDeque(3);
453		q.pollLast();
454		q.push(four);
455	<	assertEquals(four,q.peekFirst());
455	>	assertSame(four, q.peekFirst());
456		}
457
458
459		/**
460	<	*  pop removes next element, or throws NSEE if empty
460	>	* pop removes next element, or throws NSEE if empty
461		*/
462		public void testPop() {
463		LinkedBlockingDeque q = populatedDeque(SIZE);
464		for (int i = 0; i < SIZE; ++i) {
465	<	assertEquals(i, ((Integer)q.pop()).intValue());
465	>	assertEquals(i, q.pop());
466		}
467		try {
468		q.pop();
#	Line 513 | Line 528 | public class LinkedBlockingDequeTest ext
528		shouldThrow();
529		} catch (NullPointerException success) {}
530		}
531	+
532		/**
533		* addAll of a collection with any null elements throws NPE after
534		* possibly adding some elements
#	Line 527 | Line 543 | public class LinkedBlockingDequeTest ext
543		shouldThrow();
544		} catch (NullPointerException success) {}
545		}
546	+
547		/**
548		* addAll throws ISE if not enough room
549		*/
#	Line 585 | Line 602 | public class LinkedBlockingDequeTest ext
602		* put blocks interruptibly if full
603		*/
604		public void testBlockingPut() throws InterruptedException {
605	+	final LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
606		Thread t = new Thread(new CheckedRunnable() {
607	<	public void realRun() {
608	<	int added = 0;
607	>	public void realRun() throws InterruptedException {
608	>	for (int i = 0; i < SIZE; ++i)
609	>	q.put(i);
610	>	assertEquals(SIZE, q.size());
611	>	assertEquals(0, q.remainingCapacity());
612		try {
613	<	LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
614	<	for (int i = 0; i < SIZE; ++i) {
615	<	q.put(new Integer(i));
595	<	++added;
596	<	}
597	<	q.put(new Integer(SIZE));
598	<	threadShouldThrow();
599	<	} catch (InterruptedException success) {
600	<	threadAssertEquals(added, SIZE);
601	<	}
613	>	q.put(99);
614	>	shouldThrow();
615	>	} catch (InterruptedException success) {}
616		}});
617
618		t.start();
619		Thread.sleep(SHORT_DELAY_MS);
620		t.interrupt();
621		t.join();
622	+	assertEquals(SIZE, q.size());
623	+	assertEquals(0, q.remainingCapacity());
624		}
625
626		/**
627		* put blocks waiting for take when full
628		*/
629		public void testPutWithTake() throws InterruptedException {
630	<	final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
630	>	final int capacity = 2;
631	>	final LinkedBlockingDeque q = new LinkedBlockingDeque(capacity);
632		Thread t = new Thread(new CheckedRunnable() {
633	<	public void realRun() {
634	<	int added = 0;
633	>	public void realRun() throws InterruptedException {
634	>	for (int i = 0; i < capacity + 1; i++)
635	>	q.put(i);
636		try {
637	<	q.put(new Object());
638	<	++added;
639	<	q.put(new Object());
622	<	++added;
623	<	q.put(new Object());
624	<	++added;
625	<	q.put(new Object());
626	<	++added;
627	<	threadShouldThrow();
628	<	} catch (InterruptedException success) {
629	<	threadAssertTrue(added >= 2);
630	<	}
637	>	q.put(99);
638	>	shouldThrow();
639	>	} catch (InterruptedException success) {}
640		}});
641
642		t.start();
643		Thread.sleep(SHORT_DELAY_MS);
644	<	q.take();
644	>	assertEquals(q.remainingCapacity(), 0);
645	>	assertEquals(0, q.take());
646	>	Thread.sleep(SHORT_DELAY_MS);
647		t.interrupt();
648		t.join();
649	+	assertEquals(q.remainingCapacity(), 0);
650		}
651
652		/**
#	Line 665 | Line 677 | public class LinkedBlockingDequeTest ext
677		public void testTake() throws InterruptedException {
678		LinkedBlockingDeque q = populatedDeque(SIZE);
679		for (int i = 0; i < SIZE; ++i) {
680	<	assertEquals(i, ((Integer)q.take()).intValue());
680	>	assertEquals(i, q.take());
681		}
682		}
683
#	Line 689 | Line 701 | public class LinkedBlockingDequeTest ext
701		* Take removes existing elements until empty, then blocks interruptibly
702		*/
703		public void testBlockingTake() throws InterruptedException {
704	<	Thread t = new ThreadShouldThrow(InterruptedException.class) {
704	>	final LinkedBlockingDeque q = populatedDeque(SIZE);
705	>	Thread t = new Thread(new CheckedRunnable() {
706		public void realRun() throws InterruptedException {
694	–	LinkedBlockingDeque q = populatedDeque(SIZE);
707		for (int i = 0; i < SIZE; ++i) {
708	<	assertEquals(i, ((Integer)q.take()).intValue());
708	>	assertEquals(i, q.take());
709		}
710	<	q.take();
711	<	}};
710	>	try {
711	>	q.take();
712	>	shouldThrow();
713	>	} catch (InterruptedException success) {}
714	>	}});
715
716		t.start();
717		Thread.sleep(SHORT_DELAY_MS);
#	Line 711 | Line 726 | public class LinkedBlockingDequeTest ext
726		public void testPoll() {
727		LinkedBlockingDeque q = populatedDeque(SIZE);
728		for (int i = 0; i < SIZE; ++i) {
729	<	assertEquals(i, ((Integer)q.poll()).intValue());
729	>	assertEquals(i, q.poll());
730		}
731		assertNull(q.poll());
732		}
#	Line 722 | Line 737 | public class LinkedBlockingDequeTest ext
737		public void testTimedPoll0() throws InterruptedException {
738		LinkedBlockingDeque q = populatedDeque(SIZE);
739		for (int i = 0; i < SIZE; ++i) {
740	<	assertEquals(i, ((Integer)q.poll(0, MILLISECONDS)).intValue());
740	>	assertEquals(i, q.poll(0, MILLISECONDS));
741		}
742		assertNull(q.poll(0, MILLISECONDS));
743		}
#	Line 733 | Line 748 | public class LinkedBlockingDequeTest ext
748		public void testTimedPoll() throws InterruptedException {
749		LinkedBlockingDeque q = populatedDeque(SIZE);
750		for (int i = 0; i < SIZE; ++i) {
751	<	assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
751	>	assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));
752		}
753		assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
754		}
#	Line 747 | Line 762 | public class LinkedBlockingDequeTest ext
762		public void realRun() throws InterruptedException {
763		LinkedBlockingDeque q = populatedDeque(SIZE);
764		for (int i = 0; i < SIZE; ++i) {
765	<	assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
765	>	assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));
766		}
767		try {
768		q.poll(SMALL_DELAY_MS, MILLISECONDS);
#	Line 762 | Line 777 | public class LinkedBlockingDequeTest ext
777		}
778
779		/**
765	–	*  timed poll before a delayed offer fails; after offer succeeds;
766	–	*  on interruption throws
767	–	*/
768	–	public void testTimedPollWithOffer() throws InterruptedException {
769	–	final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
770	–	Thread t = new Thread(new CheckedRunnable() {
771	–	public void realRun() throws InterruptedException {
772	–	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
773	–	assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
774	–	try {
775	–	q.poll(LONG_DELAY_MS, MILLISECONDS);
776	–	shouldThrow();
777	–	} catch (InterruptedException success) {}
778	–	}});
779	–
780	–	t.start();
781	–	Thread.sleep(SMALL_DELAY_MS);
782	–	assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
783	–	t.interrupt();
784	–	t.join();
785	–	}
786	–
787	–
788	–	/**
780		* putFirst(null) throws NPE
781		*/
782		public void testPutFirstNull() throws InterruptedException {
#	Line 813 | Line 804 | public class LinkedBlockingDequeTest ext
804		* putFirst blocks interruptibly if full
805		*/
806		public void testBlockingPutFirst() throws InterruptedException {
807	+	final LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
808		Thread t = new Thread(new CheckedRunnable() {
809	<	public void realRun() {
810	<	int added = 0;
809	>	public void realRun() throws InterruptedException {
810	>	for (int i = 0; i < SIZE; ++i)
811	>	q.putFirst(i);
812	>	assertEquals(SIZE, q.size());
813	>	assertEquals(0, q.remainingCapacity());
814		try {
815	<	LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
816	<	for (int i = 0; i < SIZE; ++i) {
817	<	q.putFirst(new Integer(i));
823	<	++added;
824	<	}
825	<	q.putFirst(new Integer(SIZE));
826	<	threadShouldThrow();
827	<	} catch (InterruptedException success) {
828	<	threadAssertEquals(added, SIZE);
829	<	}
815	>	q.putFirst(99);
816	>	shouldThrow();
817	>	} catch (InterruptedException success) {}
818		}});
819
820		t.start();
821		Thread.sleep(SHORT_DELAY_MS);
822		t.interrupt();
823		t.join();
824	+	assertEquals(SIZE, q.size());
825	+	assertEquals(0, q.remainingCapacity());
826		}
827
828		/**
829		* putFirst blocks waiting for take when full
830		*/
831		public void testPutFirstWithTake() throws InterruptedException {
832	<	final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
832	>	final int capacity = 2;
833	>	final LinkedBlockingDeque q = new LinkedBlockingDeque(capacity);
834		Thread t = new Thread(new CheckedRunnable() {
835	<	public void realRun() {
836	<	int added = 0;
835	>	public void realRun() throws InterruptedException {
836	>	for (int i = 0; i < capacity + 1; i++)
837	>	q.putFirst(i);
838		try {
839	<	q.putFirst(new Object());
840	<	++added;
841	<	q.putFirst(new Object());
850	<	++added;
851	<	q.putFirst(new Object());
852	<	++added;
853	<	q.putFirst(new Object());
854	<	++added;
855	<	threadShouldThrow();
856	<	} catch (InterruptedException success) {
857	<	threadAssertTrue(added >= 2);
858	<	}
839	>	q.putFirst(99);
840	>	shouldThrow();
841	>	} catch (InterruptedException success) {}
842		}});
843
844		t.start();
845		Thread.sleep(SHORT_DELAY_MS);
846	<	q.take();
846	>	assertEquals(q.remainingCapacity(), 0);
847	>	assertEquals(capacity - 1, q.take());
848	>	Thread.sleep(SHORT_DELAY_MS);
849		t.interrupt();
850		t.join();
851	+	assertEquals(q.remainingCapacity(), 0);
852		}
853
854		/**
#	Line 893 | Line 879 | public class LinkedBlockingDequeTest ext
879		public void testTakeFirst() throws InterruptedException {
880		LinkedBlockingDeque q = populatedDeque(SIZE);
881		for (int i = 0; i < SIZE; ++i) {
882	<	assertEquals(i, ((Integer)q.takeFirst()).intValue());
882	>	assertEquals(i, q.takeFirst());
883		}
884		}
885
#	Line 917 | Line 903 | public class LinkedBlockingDequeTest ext
903		* TakeFirst removes existing elements until empty, then blocks interruptibly
904		*/
905		public void testBlockingTakeFirst() throws InterruptedException {
906	<	Thread t = new ThreadShouldThrow(InterruptedException.class) {
906	>	final LinkedBlockingDeque q = populatedDeque(SIZE);
907	>	Thread t = new Thread(new CheckedRunnable() {
908		public void realRun() throws InterruptedException {
909	<	LinkedBlockingDeque q = populatedDeque(SIZE);
910	<	for (int i = 0; i < SIZE; ++i) {
911	<	assertEquals(i, ((Integer)q.takeFirst()).intValue());
912	<	}
913	<	q.takeFirst();
914	<	}};
909	>	for (int i = 0; i < SIZE; ++i)
910	>	assertEquals(i, q.takeFirst());
911	>	try {
912	>	q.takeFirst();
913	>	shouldThrow();
914	>	} catch (InterruptedException success) {}
915	>	}});
916
917		t.start();
918		Thread.sleep(SHORT_DELAY_MS);
#	Line 939 | Line 927 | public class LinkedBlockingDequeTest ext
927		public void testTimedPollFirst0() throws InterruptedException {
928		LinkedBlockingDeque q = populatedDeque(SIZE);
929		for (int i = 0; i < SIZE; ++i) {
930	<	assertEquals(i, ((Integer)q.pollFirst(0, MILLISECONDS)).intValue());
930	>	assertEquals(i, q.pollFirst(0, MILLISECONDS));
931		}
932		assertNull(q.pollFirst(0, MILLISECONDS));
933		}
#	Line 950 | Line 938 | public class LinkedBlockingDequeTest ext
938		public void testTimedPollFirst() throws InterruptedException {
939		LinkedBlockingDeque q = populatedDeque(SIZE);
940		for (int i = 0; i < SIZE; ++i) {
941	<	assertEquals(i, ((Integer)q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)).intValue());
941	>	assertEquals(i, q.pollFirst(SHORT_DELAY_MS, MILLISECONDS));
942		}
943		assertNull(q.pollFirst(SHORT_DELAY_MS, MILLISECONDS));
944		}
#	Line 964 | Line 952 | public class LinkedBlockingDequeTest ext
952		public void realRun() throws InterruptedException {
953		LinkedBlockingDeque q = populatedDeque(SIZE);
954		for (int i = 0; i < SIZE; ++i) {
955	<	assertEquals(i, ((Integer)q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)).intValue());
955	>	assertEquals(i, q.pollFirst(SHORT_DELAY_MS, MILLISECONDS));
956		}
957		try {
958		q.pollFirst(SMALL_DELAY_MS, MILLISECONDS);
#	Line 979 | Line 967 | public class LinkedBlockingDequeTest ext
967		}
968
969		/**
970	<	*  timed pollFirst before a delayed offerFirst fails; after offerFirst succeeds;
971	<	*  on interruption throws
970	>	* timed pollFirst before a delayed offerFirst fails; after offerFirst succeeds;
971	>	* on interruption throws
972		*/
973		public void testTimedPollFirstWithOfferFirst() throws InterruptedException {
974		final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
#	Line 1029 | Line 1017 | public class LinkedBlockingDequeTest ext
1017		* putLast blocks interruptibly if full
1018		*/
1019		public void testBlockingPutLast() throws InterruptedException {
1020	+	final LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
1021		Thread t = new Thread(new CheckedRunnable() {
1022	<	public void realRun() {
1023	<	int added = 0;
1022	>	public void realRun() throws InterruptedException {
1023	>	for (int i = 0; i < SIZE; ++i)
1024	>	q.putLast(i);
1025	>	assertEquals(SIZE, q.size());
1026	>	assertEquals(0, q.remainingCapacity());
1027		try {
1028	<	LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
1029	<	for (int i = 0; i < SIZE; ++i) {
1030	<	q.putLast(new Integer(i));
1039	<	++added;
1040	<	}
1041	<	q.putLast(new Integer(SIZE));
1042	<	threadShouldThrow();
1043	<	} catch (InterruptedException success) {
1044	<	threadAssertEquals(added, SIZE);
1045	<	}
1028	>	q.putLast(99);
1029	>	shouldThrow();
1030	>	} catch (InterruptedException success) {}
1031		}});
1032
1033		t.start();
1034		Thread.sleep(SHORT_DELAY_MS);
1035		t.interrupt();
1036		t.join();
1037	+	assertEquals(SIZE, q.size());
1038	+	assertEquals(0, q.remainingCapacity());
1039		}
1040
1041		/**
1042		* putLast blocks waiting for take when full
1043		*/
1044		public void testPutLastWithTake() throws InterruptedException {
1045	<	final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
1045	>	final int capacity = 2;
1046	>	final LinkedBlockingDeque q = new LinkedBlockingDeque(capacity);
1047		Thread t = new Thread(new CheckedRunnable() {
1048	<	public void realRun() {
1049	<	int added = 0;
1048	>	public void realRun() throws InterruptedException {
1049	>	for (int i = 0; i < capacity + 1; i++)
1050	>	q.putLast(i);
1051		try {
1052	<	q.putLast(new Object());
1053	<	++added;
1054	<	q.putLast(new Object());
1066	<	++added;
1067	<	q.putLast(new Object());
1068	<	++added;
1069	<	q.putLast(new Object());
1070	<	++added;
1071	<	threadShouldThrow();
1072	<	} catch (InterruptedException success) {
1073	<	threadAssertTrue(added >= 2);
1074	<	}
1052	>	q.putLast(99);
1053	>	shouldThrow();
1054	>	} catch (InterruptedException success) {}
1055		}});
1056
1057		t.start();
1058		Thread.sleep(SHORT_DELAY_MS);
1059	<	q.take();
1059	>	assertEquals(q.remainingCapacity(), 0);
1060	>	assertEquals(0, q.take());
1061	>	Thread.sleep(SHORT_DELAY_MS);
1062		t.interrupt();
1063		t.join();
1064	+	assertEquals(q.remainingCapacity(), 0);
1065		}
1066
1067		/**
#	Line 1109 | Line 1092 | public class LinkedBlockingDequeTest ext
1092		public void testTakeLast() throws InterruptedException {
1093		LinkedBlockingDeque q = populatedDeque(SIZE);
1094		for (int i = 0; i < SIZE; ++i) {
1095	<	assertEquals(SIZE-i-1, ((Integer)q.takeLast()).intValue());
1095	>	assertEquals(SIZE-i-1, q.takeLast());
1096		}
1097		}
1098
#	Line 1133 | Line 1116 | public class LinkedBlockingDequeTest ext
1116		* TakeLast removes existing elements until empty, then blocks interruptibly
1117		*/
1118		public void testBlockingTakeLast() throws InterruptedException {
1119	<	Thread t = new ThreadShouldThrow(InterruptedException.class) {
1119	>	final LinkedBlockingDeque q = populatedDeque(SIZE);
1120	>	Thread t = new Thread(new CheckedRunnable() {
1121		public void realRun() throws InterruptedException {
1122	<	LinkedBlockingDeque q = populatedDeque(SIZE);
1123	<	for (int i = 0; i < SIZE; ++i) {
1124	<	assertEquals(SIZE-i-1, ((Integer)q.takeLast()).intValue());
1125	<	}
1126	<	q.takeLast();
1127	<	}};
1122	>	for (int i = 0; i < SIZE; ++i)
1123	>	assertEquals(SIZE - 1 - i, q.takeLast());
1124	>	try {
1125	>	q.takeLast();
1126	>	shouldThrow();
1127	>	} catch (InterruptedException success) {}
1128	>	}});
1129
1130		t.start();
1131		Thread.sleep(SHORT_DELAY_MS);
#	Line 1148 | Line 1133 | public class LinkedBlockingDequeTest ext
1133		t.join();
1134		}
1135
1151	–
1136		/**
1137		* timed pollLast with zero timeout succeeds when non-empty, else times out
1138		*/
1139		public void testTimedPollLast0() throws InterruptedException {
1140		LinkedBlockingDeque q = populatedDeque(SIZE);
1141		for (int i = 0; i < SIZE; ++i) {
1142	<	assertEquals(SIZE-i-1, ((Integer)q.pollLast(0, MILLISECONDS)).intValue());
1142	>	assertEquals(SIZE-i-1, q.pollLast(0, MILLISECONDS));
1143		}
1144		assertNull(q.pollLast(0, MILLISECONDS));
1145		}
#	Line 1166 | Line 1150 | public class LinkedBlockingDequeTest ext
1150		public void testTimedPollLast() throws InterruptedException {
1151		LinkedBlockingDeque q = populatedDeque(SIZE);
1152		for (int i = 0; i < SIZE; ++i) {
1153	<	assertEquals(SIZE-i-1, ((Integer)q.pollLast(SHORT_DELAY_MS, MILLISECONDS)).intValue());
1153	>	assertEquals(SIZE-i-1, q.pollLast(SHORT_DELAY_MS, MILLISECONDS));
1154		}
1155		assertNull(q.pollLast(SHORT_DELAY_MS, MILLISECONDS));
1156		}
#	Line 1180 | Line 1164 | public class LinkedBlockingDequeTest ext
1164		public void realRun() throws InterruptedException {
1165		LinkedBlockingDeque q = populatedDeque(SIZE);
1166		for (int i = 0; i < SIZE; ++i) {
1167	<	assertEquals(SIZE-i-1, ((Integer)q.pollLast(SHORT_DELAY_MS, MILLISECONDS)).intValue());
1167	>	assertEquals(SIZE-i-1, q.pollLast(SHORT_DELAY_MS, MILLISECONDS));
1168		}
1169		try {
1170		q.pollLast(SMALL_DELAY_MS, MILLISECONDS);
#	Line 1195 | Line 1179 | public class LinkedBlockingDequeTest ext
1179		}
1180
1181		/**
1182	<	*  timed poll before a delayed offerLast fails; after offerLast succeeds;
1183	<	*  on interruption throws
1182	>	* timed poll before a delayed offerLast fails; after offerLast succeeds;
1183	>	* on interruption throws
1184		*/
1185		public void testTimedPollWithOfferLast() throws InterruptedException {
1186		final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
#	Line 1224 | Line 1208 | public class LinkedBlockingDequeTest ext
1208		public void testElement() {
1209		LinkedBlockingDeque q = populatedDeque(SIZE);
1210		for (int i = 0; i < SIZE; ++i) {
1211	<	assertEquals(i, ((Integer)q.element()).intValue());
1211	>	assertEquals(i, q.element());
1212		q.poll();
1213		}
1214		try {
#	Line 1350 | Line 1334 | public class LinkedBlockingDequeTest ext
1334		* toArray(null) throws NPE
1335		*/
1336		public void testToArray_BadArg() {
1337	+	LinkedBlockingDeque q = populatedDeque(SIZE);
1338		try {
1354	–	LinkedBlockingDeque q = populatedDeque(SIZE);
1339		Object o[] = q.toArray(null);
1340		shouldThrow();
1341		} catch (NullPointerException success) {}
#	Line 1361 | Line 1345 | public class LinkedBlockingDequeTest ext
1345		* toArray with incompatible array type throws CCE
1346		*/
1347		public void testToArray1_BadArg() {
1348	+	LinkedBlockingDeque q = populatedDeque(SIZE);
1349		try {
1350	<	LinkedBlockingDeque q = populatedDeque(SIZE);
1366	<	Object o[] = q.toArray(new String[10] );
1350	>	Object o[] = q.toArray(new String[10]);
1351		shouldThrow();
1352		} catch (ArrayStoreException success) {}
1353		}
#	Line 1383 | Line 1367 | public class LinkedBlockingDequeTest ext
1367		/**
1368		* iterator.remove removes current element
1369		*/
1370	<	public void testIteratorRemove () {
1370	>	public void testIteratorRemove() {
1371		final LinkedBlockingDeque q = new LinkedBlockingDeque(3);
1372		q.add(two);
1373		q.add(one);
#	Line 1394 | Line 1378 | public class LinkedBlockingDequeTest ext
1378		it.remove();
1379
1380		it = q.iterator();
1381	<	assertEquals(it.next(), one);
1382	<	assertEquals(it.next(), three);
1381	>	assertSame(it.next(), one);
1382	>	assertSame(it.next(), three);
1383		assertFalse(it.hasNext());
1384		}
1385
#	Line 1411 | Line 1395 | public class LinkedBlockingDequeTest ext
1395		assertEquals(0, q.remainingCapacity());
1396		int k = 0;
1397		for (Iterator it = q.iterator(); it.hasNext();) {
1398	<	int i = ((Integer)(it.next())).intValue();
1415	<	assertEquals(++k, i);
1398	>	assertEquals(++k, it.next());
1399		}
1400		assertEquals(3, k);
1401		}
#	Line 1420 | Line 1403 | public class LinkedBlockingDequeTest ext
1403		/**
1404		* Modifications do not cause iterators to fail
1405		*/
1406	<	public void testWeaklyConsistentIteration () {
1406	>	public void testWeaklyConsistentIteration() {
1407		final LinkedBlockingDeque q = new LinkedBlockingDeque(3);
1408		q.add(one);
1409		q.add(two);
#	Line 1434 | Line 1417 | public class LinkedBlockingDequeTest ext
1417
1418
1419		/**
1420	<	*  Descending iterator iterates through all elements
1420	>	* Descending iterator iterates through all elements
1421		*/
1422		public void testDescendingIterator() {
1423		LinkedBlockingDeque q = populatedDeque(SIZE);
#	Line 1453 | Line 1436 | public class LinkedBlockingDequeTest ext
1436		}
1437
1438		/**
1439	<	*  Descending iterator ordering is reverse FIFO
1439	>	* Descending iterator ordering is reverse FIFO
1440		*/
1441		public void testDescendingIteratorOrdering() {
1442		final LinkedBlockingDeque q = new LinkedBlockingDeque();
#	Line 1463 | Line 1446 | public class LinkedBlockingDequeTest ext
1446		q.add(new Integer(1));
1447		int k = 0;
1448		for (Iterator it = q.descendingIterator(); it.hasNext();) {
1449	<	int i = ((Integer)(it.next())).intValue();
1467	<	assertEquals(++k, i);
1449	>	assertEquals(++k, it.next());
1450		}
1451
1452		assertEquals(3, k);
#	Line 1477 | Line 1459 | public class LinkedBlockingDequeTest ext
1459		/**
1460		* descendingIterator.remove removes current element
1461		*/
1462	<	public void testDescendingIteratorRemove () {
1462	>	public void testDescendingIteratorRemove() {
1463		final LinkedBlockingDeque q = new LinkedBlockingDeque();
1464		for (int iters = 0; iters < 100; ++iters) {
1465		q.add(new Integer(3));
#	Line 1519 | Line 1501 | public class LinkedBlockingDequeTest ext
1501		ExecutorService executor = Executors.newFixedThreadPool(2);
1502		executor.execute(new CheckedRunnable() {
1503		public void realRun() throws InterruptedException {
1504	<	threadAssertFalse(q.offer(three));
1505	<	threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
1506	<	threadAssertEquals(0, q.remainingCapacity());
1504	>	assertFalse(q.offer(three));
1505	>	assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
1506	>	assertEquals(0, q.remainingCapacity());
1507		}});
1508
1509		executor.execute(new CheckedRunnable() {
1510		public void realRun() throws InterruptedException {
1511		Thread.sleep(SMALL_DELAY_MS);
1512	<	threadAssertEquals(one, q.take());
1512	>	assertSame(one, q.take());
1513		}});
1514
1515		joinPool(executor);
#	Line 1541 | Line 1523 | public class LinkedBlockingDequeTest ext
1523		ExecutorService executor = Executors.newFixedThreadPool(2);
1524		executor.execute(new CheckedRunnable() {
1525		public void realRun() throws InterruptedException {
1526	<	threadAssertNull(q.poll());
1527	<	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
1528	<	threadAssertTrue(q.isEmpty());
1526	>	assertNull(q.poll());
1527	>	assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
1528	>	assertTrue(q.isEmpty());
1529		}});
1530
1531		executor.execute(new CheckedRunnable() {
#	Line 1663 | Line 1645 | public class LinkedBlockingDequeTest ext
1645		}
1646
1647		/**
1648	<	* drainTo(c, n) empties first max {n, size} elements of deque into c
1648	>	* drainTo(c, n) empties first min(n, size) elements of queue into c
1649		*/
1650		public void testDrainToN() {
1651		LinkedBlockingDeque q = new LinkedBlockingDeque();
#	Line 1672 | Line 1654 | public class LinkedBlockingDequeTest ext
1654		assertTrue(q.offer(new Integer(j)));
1655		ArrayList l = new ArrayList();
1656		q.drainTo(l, i);
1657	<	int k = (i < SIZE)? i : SIZE;
1657	>	int k = (i < SIZE) ? i : SIZE;
1658		assertEquals(l.size(), k);
1659		assertEquals(q.size(), SIZE-k);
1660		for (int j = 0; j < k; ++j)

Diff Legend

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