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.4 by jsr166, Mon Nov 2 20:28:31 2009 UTC vs.
Revision 1.7 by jsr166, Sat Nov 21 02:07:26 2009 UTC

#	Line 11 | Line 11 | import java.io.*;
11
12		public class LinkedBlockingDequeTest extends JSR166TestCase {
13		public static void main(String[] args) {
14	<	junit.textui.TestRunner.run (suite());
14	>	junit.textui.TestRunner.run (suite());
15		}
16
17		public static Test suite() {
18	<	return new TestSuite(LinkedBlockingDequeTest.class);
18	>	return new TestSuite(LinkedBlockingDequeTest.class);
19		}
20
21		/**
#	Line 25 | Line 25 | public class LinkedBlockingDequeTest ext
25		private LinkedBlockingDeque populatedDeque(int n) {
26		LinkedBlockingDeque q = new LinkedBlockingDeque(n);
27		assertTrue(q.isEmpty());
28	<	for(int i = 0; i < n; i++)
29	<	assertTrue(q.offer(new Integer(i)));
28	>	for (int i = 0; i < n; i++)
29	>	assertTrue(q.offer(new Integer(i)));
30		assertFalse(q.isEmpty());
31		assertEquals(0, q.remainingCapacity());
32	<	assertEquals(n, q.size());
32	>	assertEquals(n, q.size());
33		return q;
34		}
35
#	Line 66 | Line 66 | public class LinkedBlockingDequeTest ext
66		* offer(null) throws NPE
67		*/
68		public void testOfferFirstNull() {
69	<	try {
69	>	try {
70		LinkedBlockingDeque q = new LinkedBlockingDeque();
71		q.offerFirst(null);
72		shouldThrow();
#	Line 100 | Line 100 | public class LinkedBlockingDequeTest ext
100		for (int i = 0; i < SIZE; ++i) {
101		assertEquals(i, ((Integer)q.pollFirst()).intValue());
102		}
103	<	assertNull(q.pollFirst());
103	>	assertNull(q.pollFirst());
104		}
105
106		/**
#	Line 111 | Line 111 | public class LinkedBlockingDequeTest ext
111		for (int i = SIZE-1; i >= 0; --i) {
112		assertEquals(i, ((Integer)q.pollLast()).intValue());
113		}
114	<	assertNull(q.pollLast());
114	>	assertNull(q.pollLast());
115		}
116
117		/**
#	Line 125 | Line 125 | public class LinkedBlockingDequeTest ext
125		assertTrue(q.peekFirst() == null ||
126		i != ((Integer)q.peekFirst()).intValue());
127		}
128	<	assertNull(q.peekFirst());
128	>	assertNull(q.peekFirst());
129		}
130
131		/**
#	Line 139 | Line 139 | public class LinkedBlockingDequeTest ext
139		assertTrue(q.peek() == null ||
140		i != ((Integer)q.peek()).intValue());
141		}
142	<	assertNull(q.peek());
142	>	assertNull(q.peek());
143		}
144
145		/**
#	Line 153 | Line 153 | public class LinkedBlockingDequeTest ext
153		assertTrue(q.peekLast() == null ||
154		i != ((Integer)q.peekLast()).intValue());
155		}
156	<	assertNull(q.peekLast());
156	>	assertNull(q.peekLast());
157		}
158
159		/**
#	Line 186 | Line 186 | public class LinkedBlockingDequeTest ext
186		shouldThrow();
187		}
188		catch (NoSuchElementException success) {}
189	<	assertNull(q.peekLast());
189	>	assertNull(q.peekLast());
190		}
191
192		/**
#	Line 200 | Line 200 | public class LinkedBlockingDequeTest ext
200		try {
201		q.removeFirst();
202		shouldThrow();
203	<	} catch (NoSuchElementException success){
204	<	}
203	>	} catch (NoSuchElementException success) {
204	>	}
205		}
206
207		/**
#	Line 215 | Line 215 | public class LinkedBlockingDequeTest ext
215		try {
216		q.remove();
217		shouldThrow();
218	<	} catch (NoSuchElementException success){
219	<	}
218	>	} catch (NoSuchElementException success) {
219	>	}
220		}
221
222		/**
#	Line 255 | Line 255 | public class LinkedBlockingDequeTest ext
255		public void testAddFirst() {
256		LinkedBlockingDeque q = populatedDeque(3);
257		q.pollLast();
258	<	q.addFirst(four);
259	<	assertEquals(four,q.peekFirst());
258	>	q.addFirst(four);
259	>	assertEquals(four,q.peekFirst());
260		}
261
262		/**
#	Line 265 | Line 265 | public class LinkedBlockingDequeTest ext
265		public void testAddLast() {
266		LinkedBlockingDeque q = populatedDeque(3);
267		q.pollLast();
268	<	q.addLast(four);
269	<	assertEquals(four,q.peekLast());
268	>	q.addLast(four);
269	>	assertEquals(four,q.peekLast());
270		}
271
272
#	Line 378 | Line 378 | public class LinkedBlockingDequeTest ext
378		* offer(null) throws NPE
379		*/
380		public void testOfferNull() {
381	<	try {
381	>	try {
382		LinkedBlockingDeque q = new LinkedBlockingDeque(1);
383		q.offer(null);
384		shouldThrow();
#	Line 389 | Line 389 | public class LinkedBlockingDequeTest ext
389		* add(null) throws NPE
390		*/
391		public void testAddNull() {
392	<	try {
392	>	try {
393		LinkedBlockingDeque q = new LinkedBlockingDeque(1);
394		q.add(null);
395		shouldThrow();
#	Line 400 | Line 400 | public class LinkedBlockingDequeTest ext
400		* push(null) throws NPE
401		*/
402		public void testPushNull() {
403	<	try {
403	>	try {
404		LinkedBlockingDeque q = new LinkedBlockingDeque(1);
405		q.push(null);
406		shouldThrow();
#	Line 411 | Line 411 | public class LinkedBlockingDequeTest ext
411		* push succeeds if not full; throws ISE if full
412		*/
413		public void testPush() {
414	<	try {
414	>	try {
415		LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
416		for (int i = 0; i < SIZE; ++i) {
417		Integer I = new Integer(i);
#	Line 420 | Line 420 | public class LinkedBlockingDequeTest ext
420		}
421		assertEquals(0, q.remainingCapacity());
422		q.push(new Integer(SIZE));
423	<	} catch (IllegalStateException success){
424	<	}
423	>	} catch (IllegalStateException success) {
424	>	}
425		}
426
427		/**
#	Line 430 | Line 430 | public class LinkedBlockingDequeTest ext
430		public void testPushWithPeek() {
431		LinkedBlockingDeque q = populatedDeque(3);
432		q.pollLast();
433	<	q.push(four);
434	<	assertEquals(four,q.peekFirst());
433	>	q.push(four);
434	>	assertEquals(four,q.peekFirst());
435		}
436
437
#	Line 446 | Line 446 | public class LinkedBlockingDequeTest ext
446		try {
447		q.pop();
448		shouldThrow();
449	<	} catch (NoSuchElementException success){
450	<	}
449	>	} catch (NoSuchElementException success) {
450	>	}
451		}
452
453
#	Line 464 | Line 464 | public class LinkedBlockingDequeTest ext
464		* add succeeds if not full; throws ISE if full
465		*/
466		public void testAdd() {
467	<	try {
467	>	try {
468		LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
469		for (int i = 0; i < SIZE; ++i) {
470		assertTrue(q.add(new Integer(i)));
471		}
472		assertEquals(0, q.remainingCapacity());
473		q.add(new Integer(SIZE));
474	<	} catch (IllegalStateException success){
475	<	}
474	>	} catch (IllegalStateException success) {
475	>	}
476		}
477
478		/**
#	Line 563 | Line 563 | public class LinkedBlockingDequeTest ext
563		* put(null) throws NPE
564		*/
565		public void testPutNull() {
566	<	try {
566	>	try {
567		LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
568		q.put(null);
569		shouldThrow();
570		}
571	<	catch (NullPointerException success){
572	<	}
571	>	catch (NullPointerException success) {
572	>	}
573		catch (InterruptedException ie) {
574	<	unexpectedException();
574	>	unexpectedException();
575		}
576		}
577
#	Line 589 | Line 589 | public class LinkedBlockingDequeTest ext
589		assertEquals(0, q.remainingCapacity());
590		}
591		catch (InterruptedException ie) {
592	<	unexpectedException();
592	>	unexpectedException();
593		}
594		}
595
#	Line 608 | Line 608 | public class LinkedBlockingDequeTest ext
608		}
609		q.put(new Integer(SIZE));
610		threadShouldThrow();
611	<	} catch (InterruptedException ie){
611	>	} catch (InterruptedException ie) {
612		threadAssertEquals(added, SIZE);
613		}
614		}});
#	Line 619 | Line 619 | public class LinkedBlockingDequeTest ext
619		t.join();
620		}
621		catch (InterruptedException ie) {
622	<	unexpectedException();
622	>	unexpectedException();
623		}
624		}
625
#	Line 640 | Line 640 | public class LinkedBlockingDequeTest ext
640		++added;
641		q.put(new Object());
642		++added;
643	<	threadShouldThrow();
644	<	} catch (InterruptedException e){
643	>	threadShouldThrow();
644	>	} catch (InterruptedException e) {
645		threadAssertTrue(added >= 2);
646		}
647		}
#	Line 652 | Line 652 | public class LinkedBlockingDequeTest ext
652		q.take();
653		t.interrupt();
654		t.join();
655	<	} catch (Exception e){
655	>	} catch (Exception e) {
656		unexpectedException();
657		}
658		}
#	Line 669 | Line 669 | public class LinkedBlockingDequeTest ext
669		q.put(new Object());
670		threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
671		q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
672	<	threadShouldThrow();
673	<	} catch (InterruptedException success){}
672	>	threadShouldThrow();
673	>	} catch (InterruptedException success) {}
674		}
675		});
676
#	Line 679 | Line 679 | public class LinkedBlockingDequeTest ext
679		Thread.sleep(SMALL_DELAY_MS);
680		t.interrupt();
681		t.join();
682	<	} catch (Exception e){
682	>	} catch (Exception e) {
683		unexpectedException();
684		}
685		}
#	Line 688 | Line 688 | public class LinkedBlockingDequeTest ext
688		* take retrieves elements in FIFO order
689		*/
690		public void testTake() {
691	<	try {
691	>	try {
692		LinkedBlockingDeque q = populatedDeque(SIZE);
693		for (int i = 0; i < SIZE; ++i) {
694		assertEquals(i, ((Integer)q.take()).intValue());
695		}
696	<	} catch (InterruptedException e){
697	<	unexpectedException();
698	<	}
696	>	} catch (InterruptedException e) {
697	>	unexpectedException();
698	>	}
699		}
700
701		/**
#	Line 707 | Line 707 | public class LinkedBlockingDequeTest ext
707		public void run() {
708		try {
709		q.take();
710	<	threadShouldThrow();
711	<	} catch (InterruptedException success){ }
710	>	threadShouldThrow();
711	>	} catch (InterruptedException success) { }
712		}
713		});
714		try {
#	Line 716 | Line 716 | public class LinkedBlockingDequeTest ext
716		Thread.sleep(SHORT_DELAY_MS);
717		t.interrupt();
718		t.join();
719	<	} catch (Exception e){
719	>	} catch (Exception e) {
720		unexpectedException();
721		}
722		}
#	Line 734 | Line 734 | public class LinkedBlockingDequeTest ext
734		}
735		q.take();
736		threadShouldThrow();
737	<	} catch (InterruptedException success){
737	>	} catch (InterruptedException success) {
738		}
739		}});
740		t.start();
#	Line 744 | Line 744 | public class LinkedBlockingDequeTest ext
744		t.join();
745		}
746		catch (InterruptedException ie) {
747	<	unexpectedException();
747	>	unexpectedException();
748		}
749		}
750
#	Line 757 | Line 757 | public class LinkedBlockingDequeTest ext
757		for (int i = 0; i < SIZE; ++i) {
758		assertEquals(i, ((Integer)q.poll()).intValue());
759		}
760	<	assertNull(q.poll());
760	>	assertNull(q.poll());
761		}
762
763		/**
#	Line 770 | Line 770 | public class LinkedBlockingDequeTest ext
770		assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());
771		}
772		assertNull(q.poll(0, TimeUnit.MILLISECONDS));
773	<	} catch (InterruptedException e){
774	<	unexpectedException();
775	<	}
773	>	} catch (InterruptedException e) {
774	>	unexpectedException();
775	>	}
776		}
777
778		/**
#	Line 785 | Line 785 | public class LinkedBlockingDequeTest ext
785		assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
786		}
787		assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
788	<	} catch (InterruptedException e){
789	<	unexpectedException();
790	<	}
788	>	} catch (InterruptedException e) {
789	>	unexpectedException();
790	>	}
791		}
792
793		/**
#	Line 803 | Line 803 | public class LinkedBlockingDequeTest ext
803		threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
804		}
805		threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
806	<	} catch (InterruptedException success){
806	>	} catch (InterruptedException success) {
807		}
808		}});
809		t.start();
#	Line 813 | Line 813 | public class LinkedBlockingDequeTest ext
813		t.join();
814		}
815		catch (InterruptedException ie) {
816	<	unexpectedException();
816	>	unexpectedException();
817		}
818		}
819
#	Line 829 | Line 829 | public class LinkedBlockingDequeTest ext
829		threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
830		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
831		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
832	<	threadShouldThrow();
832	>	threadShouldThrow();
833		} catch (InterruptedException success) { }
834		}
835		});
#	Line 839 | Line 839 | public class LinkedBlockingDequeTest ext
839		assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
840		t.interrupt();
841		t.join();
842	<	} catch (Exception e){
842	>	} catch (Exception e) {
843		unexpectedException();
844		}
845		}
#	Line 849 | Line 849 | public class LinkedBlockingDequeTest ext
849		* putFirst(null) throws NPE
850		*/
851		public void testPutFirstNull() {
852	<	try {
852	>	try {
853		LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
854		q.putFirst(null);
855		shouldThrow();
856		}
857	<	catch (NullPointerException success){
858	<	}
857	>	catch (NullPointerException success) {
858	>	}
859		catch (InterruptedException ie) {
860	<	unexpectedException();
860	>	unexpectedException();
861		}
862		}
863
#	Line 875 | Line 875 | public class LinkedBlockingDequeTest ext
875		assertEquals(0, q.remainingCapacity());
876		}
877		catch (InterruptedException ie) {
878	<	unexpectedException();
878	>	unexpectedException();
879		}
880		}
881
#	Line 894 | Line 894 | public class LinkedBlockingDequeTest ext
894		}
895		q.putFirst(new Integer(SIZE));
896		threadShouldThrow();
897	<	} catch (InterruptedException ie){
897	>	} catch (InterruptedException ie) {
898		threadAssertEquals(added, SIZE);
899		}
900		}});
#	Line 905 | Line 905 | public class LinkedBlockingDequeTest ext
905		t.join();
906		}
907		catch (InterruptedException ie) {
908	<	unexpectedException();
908	>	unexpectedException();
909		}
910		}
911
#	Line 926 | Line 926 | public class LinkedBlockingDequeTest ext
926		++added;
927		q.putFirst(new Object());
928		++added;
929	<	threadShouldThrow();
930	<	} catch (InterruptedException e){
929	>	threadShouldThrow();
930	>	} catch (InterruptedException e) {
931		threadAssertTrue(added >= 2);
932		}
933		}
#	Line 938 | Line 938 | public class LinkedBlockingDequeTest ext
938		q.take();
939		t.interrupt();
940		t.join();
941	<	} catch (Exception e){
941	>	} catch (Exception e) {
942		unexpectedException();
943		}
944		}
#	Line 955 | Line 955 | public class LinkedBlockingDequeTest ext
955		q.putFirst(new Object());
956		threadAssertFalse(q.offerFirst(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
957		q.offerFirst(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
958	<	threadShouldThrow();
959	<	} catch (InterruptedException success){}
958	>	threadShouldThrow();
959	>	} catch (InterruptedException success) {}
960		}
961		});
962
#	Line 965 | Line 965 | public class LinkedBlockingDequeTest ext
965		Thread.sleep(SMALL_DELAY_MS);
966		t.interrupt();
967		t.join();
968	<	} catch (Exception e){
968	>	} catch (Exception e) {
969		unexpectedException();
970		}
971		}
#	Line 974 | Line 974 | public class LinkedBlockingDequeTest ext
974		* take retrieves elements in FIFO order
975		*/
976		public void testTakeFirst() {
977	<	try {
977	>	try {
978		LinkedBlockingDeque q = populatedDeque(SIZE);
979		for (int i = 0; i < SIZE; ++i) {
980		assertEquals(i, ((Integer)q.takeFirst()).intValue());
981		}
982	<	} catch (InterruptedException e){
983	<	unexpectedException();
984	<	}
982	>	} catch (InterruptedException e) {
983	>	unexpectedException();
984	>	}
985		}
986
987		/**
#	Line 993 | Line 993 | public class LinkedBlockingDequeTest ext
993		public void run() {
994		try {
995		q.takeFirst();
996	<	threadShouldThrow();
997	<	} catch (InterruptedException success){ }
996	>	threadShouldThrow();
997	>	} catch (InterruptedException success) { }
998		}
999		});
1000		try {
#	Line 1002 | Line 1002 | public class LinkedBlockingDequeTest ext
1002		Thread.sleep(SHORT_DELAY_MS);
1003		t.interrupt();
1004		t.join();
1005	<	} catch (Exception e){
1005	>	} catch (Exception e) {
1006		unexpectedException();
1007		}
1008		}
#	Line 1020 | Line 1020 | public class LinkedBlockingDequeTest ext
1020		}
1021		q.takeFirst();
1022		threadShouldThrow();
1023	<	} catch (InterruptedException success){
1023	>	} catch (InterruptedException success) {
1024		}
1025		}});
1026		t.start();
#	Line 1030 | Line 1030 | public class LinkedBlockingDequeTest ext
1030		t.join();
1031		}
1032		catch (InterruptedException ie) {
1033	<	unexpectedException();
1033	>	unexpectedException();
1034		}
1035		}
1036
#	Line 1045 | Line 1045 | public class LinkedBlockingDequeTest ext
1045		assertEquals(i, ((Integer)q.pollFirst(0, TimeUnit.MILLISECONDS)).intValue());
1046		}
1047		assertNull(q.pollFirst(0, TimeUnit.MILLISECONDS));
1048	<	} catch (InterruptedException e){
1049	<	unexpectedException();
1050	<	}
1048	>	} catch (InterruptedException e) {
1049	>	unexpectedException();
1050	>	}
1051		}
1052
1053		/**
#	Line 1060 | Line 1060 | public class LinkedBlockingDequeTest ext
1060		assertEquals(i, ((Integer)q.pollFirst(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
1061		}
1062		assertNull(q.pollFirst(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1063	<	} catch (InterruptedException e){
1064	<	unexpectedException();
1065	<	}
1063	>	} catch (InterruptedException e) {
1064	>	unexpectedException();
1065	>	}
1066		}
1067
1068		/**
#	Line 1078 | Line 1078 | public class LinkedBlockingDequeTest ext
1078		threadAssertEquals(i, ((Integer)q.pollFirst(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
1079		}
1080		threadAssertNull(q.pollFirst(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1081	<	} catch (InterruptedException success){
1081	>	} catch (InterruptedException success) {
1082		}
1083		}});
1084		t.start();
#	Line 1088 | Line 1088 | public class LinkedBlockingDequeTest ext
1088		t.join();
1089		}
1090		catch (InterruptedException ie) {
1091	<	unexpectedException();
1091	>	unexpectedException();
1092		}
1093		}
1094
#	Line 1104 | Line 1104 | public class LinkedBlockingDequeTest ext
1104		threadAssertNull(q.pollFirst(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1105		q.pollFirst(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
1106		q.pollFirst(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
1107	<	threadShouldThrow();
1107	>	threadShouldThrow();
1108		} catch (InterruptedException success) { }
1109		}
1110		});
#	Line 1114 | Line 1114 | public class LinkedBlockingDequeTest ext
1114		assertTrue(q.offerFirst(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1115		t.interrupt();
1116		t.join();
1117	<	} catch (Exception e){
1117	>	} catch (Exception e) {
1118		unexpectedException();
1119		}
1120		}
#	Line 1123 | Line 1123 | public class LinkedBlockingDequeTest ext
1123		* putLast(null) throws NPE
1124		*/
1125		public void testPutLastNull() {
1126	<	try {
1126	>	try {
1127		LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
1128		q.putLast(null);
1129		shouldThrow();
1130		}
1131	<	catch (NullPointerException success){
1132	<	}
1131	>	catch (NullPointerException success) {
1132	>	}
1133		catch (InterruptedException ie) {
1134	<	unexpectedException();
1134	>	unexpectedException();
1135		}
1136		}
1137
#	Line 1149 | Line 1149 | public class LinkedBlockingDequeTest ext
1149		assertEquals(0, q.remainingCapacity());
1150		}
1151		catch (InterruptedException ie) {
1152	<	unexpectedException();
1152	>	unexpectedException();
1153		}
1154		}
1155
#	Line 1168 | Line 1168 | public class LinkedBlockingDequeTest ext
1168		}
1169		q.putLast(new Integer(SIZE));
1170		threadShouldThrow();
1171	<	} catch (InterruptedException ie){
1171	>	} catch (InterruptedException ie) {
1172		threadAssertEquals(added, SIZE);
1173		}
1174		}});
#	Line 1179 | Line 1179 | public class LinkedBlockingDequeTest ext
1179		t.join();
1180		}
1181		catch (InterruptedException ie) {
1182	<	unexpectedException();
1182	>	unexpectedException();
1183		}
1184		}
1185
#	Line 1200 | Line 1200 | public class LinkedBlockingDequeTest ext
1200		++added;
1201		q.putLast(new Object());
1202		++added;
1203	<	threadShouldThrow();
1204	<	} catch (InterruptedException e){
1203	>	threadShouldThrow();
1204	>	} catch (InterruptedException e) {
1205		threadAssertTrue(added >= 2);
1206		}
1207		}
#	Line 1212 | Line 1212 | public class LinkedBlockingDequeTest ext
1212		q.take();
1213		t.interrupt();
1214		t.join();
1215	<	} catch (Exception e){
1215	>	} catch (Exception e) {
1216		unexpectedException();
1217		}
1218		}
#	Line 1229 | Line 1229 | public class LinkedBlockingDequeTest ext
1229		q.putLast(new Object());
1230		threadAssertFalse(q.offerLast(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1231		q.offerLast(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
1232	<	threadShouldThrow();
1233	<	} catch (InterruptedException success){}
1232	>	threadShouldThrow();
1233	>	} catch (InterruptedException success) {}
1234		}
1235		});
1236
#	Line 1239 | Line 1239 | public class LinkedBlockingDequeTest ext
1239		Thread.sleep(SMALL_DELAY_MS);
1240		t.interrupt();
1241		t.join();
1242	<	} catch (Exception e){
1242	>	} catch (Exception e) {
1243		unexpectedException();
1244		}
1245		}
#	Line 1248 | Line 1248 | public class LinkedBlockingDequeTest ext
1248		* takeLast retrieves elements in FIFO order
1249		*/
1250		public void testTakeLast() {
1251	<	try {
1251	>	try {
1252		LinkedBlockingDeque q = populatedDeque(SIZE);
1253		for (int i = 0; i < SIZE; ++i) {
1254		assertEquals(SIZE-i-1, ((Integer)q.takeLast()).intValue());
1255		}
1256	<	} catch (InterruptedException e){
1257	<	unexpectedException();
1258	<	}
1256	>	} catch (InterruptedException e) {
1257	>	unexpectedException();
1258	>	}
1259		}
1260
1261		/**
#	Line 1267 | Line 1267 | public class LinkedBlockingDequeTest ext
1267		public void run() {
1268		try {
1269		q.takeLast();
1270	<	threadShouldThrow();
1271	<	} catch (InterruptedException success){ }
1270	>	threadShouldThrow();
1271	>	} catch (InterruptedException success) { }
1272		}
1273		});
1274		try {
#	Line 1276 | Line 1276 | public class LinkedBlockingDequeTest ext
1276		Thread.sleep(SHORT_DELAY_MS);
1277		t.interrupt();
1278		t.join();
1279	<	} catch (Exception e){
1279	>	} catch (Exception e) {
1280		unexpectedException();
1281		}
1282		}
#	Line 1294 | Line 1294 | public class LinkedBlockingDequeTest ext
1294		}
1295		q.takeLast();
1296		threadShouldThrow();
1297	<	} catch (InterruptedException success){
1297	>	} catch (InterruptedException success) {
1298		}
1299		}});
1300		t.start();
#	Line 1304 | Line 1304 | public class LinkedBlockingDequeTest ext
1304		t.join();
1305		}
1306		catch (InterruptedException ie) {
1307	<	unexpectedException();
1307	>	unexpectedException();
1308		}
1309		}
1310
#	Line 1319 | Line 1319 | public class LinkedBlockingDequeTest ext
1319		assertEquals(SIZE-i-1, ((Integer)q.pollLast(0, TimeUnit.MILLISECONDS)).intValue());
1320		}
1321		assertNull(q.pollLast(0, TimeUnit.MILLISECONDS));
1322	<	} catch (InterruptedException e){
1323	<	unexpectedException();
1324	<	}
1322	>	} catch (InterruptedException e) {
1323	>	unexpectedException();
1324	>	}
1325		}
1326
1327		/**
#	Line 1334 | Line 1334 | public class LinkedBlockingDequeTest ext
1334		assertEquals(SIZE-i-1, ((Integer)q.pollLast(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
1335		}
1336		assertNull(q.pollLast(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1337	<	} catch (InterruptedException e){
1338	<	unexpectedException();
1339	<	}
1337	>	} catch (InterruptedException e) {
1338	>	unexpectedException();
1339	>	}
1340		}
1341
1342		/**
#	Line 1352 | Line 1352 | public class LinkedBlockingDequeTest ext
1352		threadAssertEquals(SIZE-i-1, ((Integer)q.pollLast(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
1353		}
1354		threadAssertNull(q.pollLast(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1355	<	} catch (InterruptedException success){
1355	>	} catch (InterruptedException success) {
1356		}
1357		}});
1358		t.start();
#	Line 1362 | Line 1362 | public class LinkedBlockingDequeTest ext
1362		t.join();
1363		}
1364		catch (InterruptedException ie) {
1365	<	unexpectedException();
1365	>	unexpectedException();
1366		}
1367		}
1368
#	Line 1378 | Line 1378 | public class LinkedBlockingDequeTest ext
1378		threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1379		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
1380		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
1381	<	threadShouldThrow();
1381	>	threadShouldThrow();
1382		} catch (InterruptedException success) { }
1383		}
1384		});
#	Line 1388 | Line 1388 | public class LinkedBlockingDequeTest ext
1388		assertTrue(q.offerLast(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1389		t.interrupt();
1390		t.join();
1391	<	} catch (Exception e){
1391	>	} catch (Exception e) {
1392		unexpectedException();
1393		}
1394		}
#	Line 1507 | Line 1507 | public class LinkedBlockingDequeTest ext
1507		*/
1508		public void testToArray() {
1509		LinkedBlockingDeque q = populatedDeque(SIZE);
1510	<	Object[] o = q.toArray();
1511	<	try {
1512	<	for(int i = 0; i < o.length; i++)
1513	<	assertEquals(o[i], q.take());
1514	<	} catch (InterruptedException e){
1515	<	unexpectedException();
1516	<	}
1510	>	Object[] o = q.toArray();
1511	>	try {
1512	>	for (int i = 0; i < o.length; i++)
1513	>	assertEquals(o[i], q.take());
1514	>	} catch (InterruptedException e) {
1515	>	unexpectedException();
1516	>	}
1517		}
1518
1519		/**
#	Line 1521 | Line 1521 | public class LinkedBlockingDequeTest ext
1521		*/
1522		public void testToArray2() {
1523		LinkedBlockingDeque q = populatedDeque(SIZE);
1524	<	Integer[] ints = new Integer[SIZE];
1525	<	ints = (Integer[])q.toArray(ints);
1526	<	try {
1527	<	for(int i = 0; i < ints.length; i++)
1528	<	assertEquals(ints[i], q.take());
1529	<	} catch (InterruptedException e){
1530	<	unexpectedException();
1531	<	}
1524	>	Integer[] ints = new Integer[SIZE];
1525	>	ints = (Integer[])q.toArray(ints);
1526	>	try {
1527	>	for (int i = 0; i < ints.length; i++)
1528	>	assertEquals(ints[i], q.take());
1529	>	} catch (InterruptedException e) {
1530	>	unexpectedException();
1531	>	}
1532		}
1533
1534		/**
1535		* toArray(null) throws NPE
1536		*/
1537		public void testToArray_BadArg() {
1538	<	try {
1538	>	try {
1539		LinkedBlockingDeque q = populatedDeque(SIZE);
1540	<	Object o[] = q.toArray(null);
1541	<	shouldThrow();
1542	<	} catch(NullPointerException success){}
1540	>	Object o[] = q.toArray(null);
1541	>	shouldThrow();
1542	>	} catch (NullPointerException success) {}
1543		}
1544
1545		/**
1546		* toArray with incompatible array type throws CCE
1547		*/
1548		public void testToArray1_BadArg() {
1549	<	try {
1549	>	try {
1550		LinkedBlockingDeque q = populatedDeque(SIZE);
1551	<	Object o[] = q.toArray(new String[10] );
1552	<	shouldThrow();
1553	<	} catch(ArrayStoreException  success){}
1551	>	Object o[] = q.toArray(new String[10] );
1552	>	shouldThrow();
1553	>	} catch (ArrayStoreException  success) {}
1554		}
1555
1556
#	Line 1559 | Line 1559 | public class LinkedBlockingDequeTest ext
1559		*/
1560		public void testIterator() {
1561		LinkedBlockingDeque q = populatedDeque(SIZE);
1562	<	Iterator it = q.iterator();
1563	<	try {
1564	<	while(it.hasNext()){
1565	<	assertEquals(it.next(), q.take());
1566	<	}
1567	<	} catch (InterruptedException e){
1568	<	unexpectedException();
1569	<	}
1562	>	Iterator it = q.iterator();
1563	>	try {
1564	>	while (it.hasNext()) {
1565	>	assertEquals(it.next(), q.take());
1566	>	}
1567	>	} catch (InterruptedException e) {
1568	>	unexpectedException();
1569	>	}
1570		}
1571
1572		/**
#	Line 1633 | Line 1633 | public class LinkedBlockingDequeTest ext
1633		public void testDescendingIterator() {
1634		LinkedBlockingDeque q = populatedDeque(SIZE);
1635		int i = 0;
1636	<	Iterator it = q.descendingIterator();
1637	<	while(it.hasNext()) {
1636	>	Iterator it = q.descendingIterator();
1637	>	while (it.hasNext()) {
1638		assertTrue(q.contains(it.next()));
1639		++i;
1640		}
#	Line 1642 | Line 1642 | public class LinkedBlockingDequeTest ext
1642		assertFalse(it.hasNext());
1643		try {
1644		it.next();
1645	<	} catch(NoSuchElementException success) {
1645	>	} catch (NoSuchElementException success) {
1646		}
1647		}
1648
#	Line 1791 | Line 1791 | public class LinkedBlockingDequeTest ext
1791		assertEquals(q.size(), r.size());
1792		while (!q.isEmpty())
1793		assertEquals(q.remove(), r.remove());
1794	<	} catch(Exception e){
1794	>	} catch (Exception e) {
1795		unexpectedException();
1796		}
1797		}
#	Line 1804 | Line 1804 | public class LinkedBlockingDequeTest ext
1804		try {
1805		q.drainTo(null);
1806		shouldThrow();
1807	<	} catch(NullPointerException success) {
1807	>	} catch (NullPointerException success) {
1808		}
1809		}
1810
#	Line 1816 | Line 1816 | public class LinkedBlockingDequeTest ext
1816		try {
1817		q.drainTo(q);
1818		shouldThrow();
1819	<	} catch(IllegalArgumentException success) {
1819	>	} catch (IllegalArgumentException success) {
1820		}
1821		}
1822
#	Line 1853 | Line 1853 | public class LinkedBlockingDequeTest ext
1853		public void run() {
1854		try {
1855		q.put(new Integer(SIZE+1));
1856	<	} catch (InterruptedException ie){
1856	>	} catch (InterruptedException ie) {
1857		threadUnexpectedException();
1858		}
1859		}
#	Line 1867 | Line 1867 | public class LinkedBlockingDequeTest ext
1867		assertEquals(l.get(i), new Integer(i));
1868		t.join();
1869		assertTrue(q.size() + l.size() >= SIZE);
1870	<	} catch(Exception e){
1870	>	} catch (Exception e) {
1871		unexpectedException();
1872		}
1873		}
#	Line 1880 | Line 1880 | public class LinkedBlockingDequeTest ext
1880		try {
1881		q.drainTo(null, 0);
1882		shouldThrow();
1883	<	} catch(NullPointerException success) {
1883	>	} catch (NullPointerException success) {
1884		}
1885		}
1886
#	Line 1892 | Line 1892 | public class LinkedBlockingDequeTest ext
1892		try {
1893		q.drainTo(q, 0);
1894		shouldThrow();
1895	<	} catch(IllegalArgumentException success) {
1895	>	} catch (IllegalArgumentException success) {
1896		}
1897		}
1898
#	Line 1902 | Line 1902 | public class LinkedBlockingDequeTest ext
1902		public void testDrainToN() {
1903		LinkedBlockingDeque q = new LinkedBlockingDeque();
1904		for (int i = 0; i < SIZE + 2; ++i) {
1905	<	for(int j = 0; j < SIZE; j++)
1905	>	for (int j = 0; j < SIZE; j++)
1906		assertTrue(q.offer(new Integer(j)));
1907		ArrayList l = new ArrayList();
1908		q.drainTo(l, i);

Diff Legend

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