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.15 by jsr166, Sat Nov 21 21:12:55 2009 UTC vs.
Revision 1.24 by jsr166, Wed Oct 6 07:49:22 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 98 | Line 113 | public class LinkedBlockingDequeTest ext
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		}
#	Line 109 | Line 124 | public class LinkedBlockingDequeTest ext
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		}
#	Line 120 | Line 135 | public class LinkedBlockingDequeTest ext
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		}
#	Line 134 | Line 149 | public class LinkedBlockingDequeTest ext
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		}
#	Line 148 | Line 163 | public class LinkedBlockingDequeTest ext
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 224 | Line 239 | public class LinkedBlockingDequeTest ext
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
#	Line 447 | Line 462 | public class LinkedBlockingDequeTest ext
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 540 | Line 557 | public class LinkedBlockingDequeTest ext
557		shouldThrow();
558		} catch (IllegalStateException success) {}
559		}
560	+
561		/**
562		* Deque contains all elements, in traversal order, of successful addAll
563		*/
#	Line 584 | 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));
594	<	++added;
595	<	}
596	<	q.put(new Integer(SIZE));
597	<	threadShouldThrow();
598	<	} catch (InterruptedException success) {
599	<	threadAssertEquals(added, SIZE);
600	<	}
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());
621	<	++added;
622	<	q.put(new Object());
623	<	++added;
624	<	q.put(new Object());
625	<	++added;
626	<	threadShouldThrow();
627	<	} catch (InterruptedException success) {
628	<	threadAssertTrue(added >= 2);
629	<	}
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 641 | Line 654 | public class LinkedBlockingDequeTest ext
654		*/
655		public void testTimedOffer() throws InterruptedException {
656		final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
657	<	Thread t = new ThreadShouldThrow(InterruptedException.class) {
657	>	Thread t = new Thread(new CheckedRunnable() {
658		public void realRun() throws InterruptedException {
659		q.put(new Object());
660		q.put(new Object());
661	<	threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS));
662	<	q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
663	<	}};
661	>	assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS));
662	>	try {
663	>	q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
664	>	shouldThrow();
665	>	} catch (InterruptedException success) {}
666	>	}});
667
668		t.start();
669		Thread.sleep(SMALL_DELAY_MS);
#	Line 661 | 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 685 | 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 {
690	–	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 707 | 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 718 | 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 729 | 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 743 | 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 758 | Line 777 | public class LinkedBlockingDequeTest ext
777		}
778
779		/**
761	–	*  timed poll before a delayed offer fails; after offer succeeds;
762	–	*  on interruption throws
763	–	*/
764	–	public void testTimedPollWithOffer() throws InterruptedException {
765	–	final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
766	–	Thread t = new Thread(new CheckedRunnable() {
767	–	public void realRun() throws InterruptedException {
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);
778	–	assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
779	–	t.interrupt();
780	–	t.join();
781	–	}
782	–
783	–
784	–	/**
780		* putFirst(null) throws NPE
781		*/
782		public void testPutFirstNull() throws InterruptedException {
#	Line 809 | 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));
819	<	++added;
820	<	}
821	<	q.putFirst(new Integer(SIZE));
822	<	threadShouldThrow();
823	<	} catch (InterruptedException success) {
824	<	threadAssertEquals(added, SIZE);
825	<	}
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());
846	<	++added;
847	<	q.putFirst(new Object());
848	<	++added;
849	<	q.putFirst(new Object());
850	<	++added;
851	<	threadShouldThrow();
852	<	} catch (InterruptedException success) {
853	<	threadAssertTrue(added >= 2);
854	<	}
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 866 | Line 856 | public class LinkedBlockingDequeTest ext
856		*/
857		public void testTimedOfferFirst() throws InterruptedException {
858		final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
859	<	Thread t = new ThreadShouldThrow(InterruptedException.class) {
859	>	Thread t = new Thread(new CheckedRunnable() {
860		public void realRun() throws InterruptedException {
861		q.putFirst(new Object());
862		q.putFirst(new Object());
863	<	threadAssertFalse(q.offerFirst(new Object(), SHORT_DELAY_MS, MILLISECONDS));
864	<	q.offerFirst(new Object(), LONG_DELAY_MS, MILLISECONDS);
865	<	}};
863	>	assertFalse(q.offerFirst(new Object(), SHORT_DELAY_MS, MILLISECONDS));
864	>	try {
865	>	q.offerFirst(new Object(), LONG_DELAY_MS, MILLISECONDS);
866	>	shouldThrow();
867	>	} catch (InterruptedException success) {}
868	>	}});
869
870		t.start();
871		Thread.sleep(SMALL_DELAY_MS);
#	Line 886 | 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 910 | 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 932 | 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 943 | 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 957 | 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 1022 | 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));
1032	<	++added;
1033	<	}
1034	<	q.putLast(new Integer(SIZE));
1035	<	threadShouldThrow();
1036	<	} catch (InterruptedException success) {
1037	<	threadAssertEquals(added, SIZE);
1038	<	}
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());
1059	<	++added;
1060	<	q.putLast(new Object());
1061	<	++added;
1062	<	q.putLast(new Object());
1063	<	++added;
1064	<	threadShouldThrow();
1065	<	} catch (InterruptedException success) {
1066	<	threadAssertTrue(added >= 2);
1067	<	}
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 1079 | Line 1069 | public class LinkedBlockingDequeTest ext
1069		*/
1070		public void testTimedOfferLast() throws InterruptedException {
1071		final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
1072	<	Thread t = new ThreadShouldThrow(InterruptedException.class) {
1072	>	Thread t = new Thread(new CheckedRunnable() {
1073		public void realRun() throws InterruptedException {
1074		q.putLast(new Object());
1075		q.putLast(new Object());
1076	<	threadAssertFalse(q.offerLast(new Object(), SHORT_DELAY_MS, MILLISECONDS));
1077	<	q.offerLast(new Object(), LONG_DELAY_MS, MILLISECONDS);
1078	<	}};
1076	>	assertFalse(q.offerLast(new Object(), SHORT_DELAY_MS, MILLISECONDS));
1077	>	try {
1078	>	q.offerLast(new Object(), LONG_DELAY_MS, MILLISECONDS);
1079	>	shouldThrow();
1080	>	} catch (InterruptedException success) {}
1081	>	}});
1082
1083		t.start();
1084		Thread.sleep(SMALL_DELAY_MS);
#	Line 1099 | 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 1123 | 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 1138 | Line 1133 | public class LinkedBlockingDequeTest ext
1133		t.join();
1134		}
1135
1141	–
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 1156 | 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 1170 | 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 1185 | 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 1214 | 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 1340 | Line 1334 | public class LinkedBlockingDequeTest ext
1334		* toArray(null) throws NPE
1335		*/
1336		public void testToArray_BadArg() {
1337	+	LinkedBlockingDeque q = populatedDeque(SIZE);
1338		try {
1344	–	LinkedBlockingDeque q = populatedDeque(SIZE);
1339		Object o[] = q.toArray(null);
1340		shouldThrow();
1341		} catch (NullPointerException success) {}
#	Line 1351 | 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);
1356	<	Object o[] = q.toArray(new String[10] );
1350	>	Object o[] = q.toArray(new String[10]);
1351		shouldThrow();
1352		} catch (ArrayStoreException success) {}
1353		}
#	Line 1373 | 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 1384 | 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 1401 | 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();
1405	<	assertEquals(++k, i);
1398	>	assertEquals(++k, it.next());
1399		}
1400		assertEquals(3, k);
1401		}
#	Line 1410 | 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 1453 | 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();
1457	<	assertEquals(++k, i);
1449	>	assertEquals(++k, it.next());
1450		}
1451
1452		assertEquals(3, k);
#	Line 1467 | 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 1509 | 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 1531 | 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() {

Diff Legend

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