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.17 by jsr166, Sun Nov 22 00:17:37 2009 UTC vs.
Revision 1.18 by jsr166, Sun Nov 22 18:57:17 2009 UTC

#	Line 98 | Line 98 | public class LinkedBlockingDequeTest ext
98		public void testPollFirst() {
99		LinkedBlockingDeque q = populatedDeque(SIZE);
100		for (int i = 0; i < SIZE; ++i) {
101	<	assertEquals(i, ((Integer)q.pollFirst()).intValue());
101	>	assertEquals(i, q.pollFirst());
102		}
103		assertNull(q.pollFirst());
104		}
#	Line 109 | Line 109 | public class LinkedBlockingDequeTest ext
109		public void testPollLast() {
110		LinkedBlockingDeque q = populatedDeque(SIZE);
111		for (int i = SIZE-1; i >= 0; --i) {
112	<	assertEquals(i, ((Integer)q.pollLast()).intValue());
112	>	assertEquals(i, q.pollLast());
113		}
114		assertNull(q.pollLast());
115		}
#	Line 120 | Line 120 | public class LinkedBlockingDequeTest ext
120		public void testPeekFirst() {
121		LinkedBlockingDeque q = populatedDeque(SIZE);
122		for (int i = 0; i < SIZE; ++i) {
123	<	assertEquals(i, ((Integer)q.peekFirst()).intValue());
124	<	q.pollFirst();
123	>	assertEquals(i, q.peekFirst());
124	>	assertEquals(i, q.pollFirst());
125		assertTrue(q.peekFirst() == null ||
126	<	i != ((Integer)q.peekFirst()).intValue());
126	>	!q.peekFirst().equals(i));
127		}
128		assertNull(q.peekFirst());
129		}
#	Line 134 | Line 134 | public class LinkedBlockingDequeTest ext
134		public void testPeek() {
135		LinkedBlockingDeque q = populatedDeque(SIZE);
136		for (int i = 0; i < SIZE; ++i) {
137	<	assertEquals(i, ((Integer)q.peek()).intValue());
138	<	q.pollFirst();
137	>	assertEquals(i, q.peek());
138	>	assertEquals(i, q.pollFirst());
139		assertTrue(q.peek() == null ||
140	<	i != ((Integer)q.peek()).intValue());
140	>	!q.peek().equals(i));
141		}
142		assertNull(q.peek());
143		}
#	Line 148 | Line 148 | public class LinkedBlockingDequeTest ext
148		public void testPeekLast() {
149		LinkedBlockingDeque q = populatedDeque(SIZE);
150		for (int i = SIZE-1; i >= 0; --i) {
151	<	assertEquals(i, ((Integer)q.peekLast()).intValue());
152	<	q.pollLast();
151	>	assertEquals(i, q.peekLast());
152	>	assertEquals(i, q.pollLast());
153		assertTrue(q.peekLast() == null ||
154	<	i != ((Integer)q.peekLast()).intValue());
154	>	!q.peekLast().equals(i));
155		}
156		assertNull(q.peekLast());
157		}
#	Line 162 | Line 162 | public class LinkedBlockingDequeTest ext
162		public void testFirstElement() {
163		LinkedBlockingDeque q = populatedDeque(SIZE);
164		for (int i = 0; i < SIZE; ++i) {
165	<	assertEquals(i, ((Integer)q.getFirst()).intValue());
166	<	q.pollFirst();
165	>	assertEquals(i, q.getFirst());
166	>	assertEquals(i, q.pollFirst());
167		}
168		try {
169		q.getFirst();
#	Line 178 | Line 178 | public class LinkedBlockingDequeTest ext
178		public void testLastElement() {
179		LinkedBlockingDeque q = populatedDeque(SIZE);
180		for (int i = SIZE-1; i >= 0; --i) {
181	<	assertEquals(i, ((Integer)q.getLast()).intValue());
182	<	q.pollLast();
181	>	assertEquals(i, q.getLast());
182	>	assertEquals(i, q.pollLast());
183		}
184		try {
185		q.getLast();
#	Line 194 | Line 194 | public class LinkedBlockingDequeTest ext
194		public void testRemoveFirst() {
195		LinkedBlockingDeque q = populatedDeque(SIZE);
196		for (int i = 0; i < SIZE; ++i) {
197	<	assertEquals(i, ((Integer)q.removeFirst()).intValue());
197	>	assertEquals(i, q.removeFirst());
198		}
199		try {
200		q.removeFirst();
#	Line 209 | Line 209 | public class LinkedBlockingDequeTest ext
209		public void testRemoveLast() {
210		LinkedBlockingDeque q = populatedDeque(SIZE);
211		for (int i = SIZE - 1; i >= 0; --i) {
212	<	assertEquals(i, ((Integer)q.removeLast()).intValue());
212	>	assertEquals(i, q.removeLast());
213		}
214		try {
215		q.removeLast();
#	Line 224 | Line 224 | public class LinkedBlockingDequeTest ext
224		public void testRemove() {
225		LinkedBlockingDeque q = populatedDeque(SIZE);
226		for (int i = 0; i < SIZE; ++i) {
227	<	assertEquals(i, ((Integer)q.remove()).intValue());
227	>	assertEquals(i, q.remove());
228		}
229		try {
230		q.remove();
#	Line 447 | Line 447 | public class LinkedBlockingDequeTest ext
447		public void testPop() {
448		LinkedBlockingDeque q = populatedDeque(SIZE);
449		for (int i = 0; i < SIZE; ++i) {
450	<	assertEquals(i, ((Integer)q.pop()).intValue());
450	>	assertEquals(i, q.pop());
451		}
452		try {
453		q.pop();
#	Line 660 | Line 660 | public class LinkedBlockingDequeTest ext
660		public void testTake() throws InterruptedException {
661		LinkedBlockingDeque q = populatedDeque(SIZE);
662		for (int i = 0; i < SIZE; ++i) {
663	<	assertEquals(i, ((Integer)q.take()).intValue());
663	>	assertEquals(i, q.take());
664		}
665		}
666
#	Line 688 | Line 688 | public class LinkedBlockingDequeTest ext
688		Thread t = new Thread(new CheckedRunnable() {
689		public void realRun() throws InterruptedException {
690		for (int i = 0; i < SIZE; ++i) {
691	<	assertEquals(i, ((Integer)q.take()).intValue());
691	>	assertEquals(i, q.take());
692		}
693		try {
694		q.take();
#	Line 709 | Line 709 | public class LinkedBlockingDequeTest ext
709		public void testPoll() {
710		LinkedBlockingDeque q = populatedDeque(SIZE);
711		for (int i = 0; i < SIZE; ++i) {
712	<	assertEquals(i, ((Integer)q.poll()).intValue());
712	>	assertEquals(i, q.poll());
713		}
714		assertNull(q.poll());
715		}
#	Line 720 | Line 720 | public class LinkedBlockingDequeTest ext
720		public void testTimedPoll0() throws InterruptedException {
721		LinkedBlockingDeque q = populatedDeque(SIZE);
722		for (int i = 0; i < SIZE; ++i) {
723	<	assertEquals(i, ((Integer)q.poll(0, MILLISECONDS)).intValue());
723	>	assertEquals(i, q.poll(0, MILLISECONDS));
724		}
725		assertNull(q.poll(0, MILLISECONDS));
726		}
#	Line 731 | Line 731 | public class LinkedBlockingDequeTest ext
731		public void testTimedPoll() throws InterruptedException {
732		LinkedBlockingDeque q = populatedDeque(SIZE);
733		for (int i = 0; i < SIZE; ++i) {
734	<	assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
734	>	assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));
735		}
736		assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
737		}
#	Line 745 | Line 745 | public class LinkedBlockingDequeTest ext
745		public void realRun() throws InterruptedException {
746		LinkedBlockingDeque q = populatedDeque(SIZE);
747		for (int i = 0; i < SIZE; ++i) {
748	<	assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
748	>	assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));
749		}
750		try {
751		q.poll(SMALL_DELAY_MS, MILLISECONDS);
#	Line 886 | Line 886 | public class LinkedBlockingDequeTest ext
886		public void testTakeFirst() throws InterruptedException {
887		LinkedBlockingDeque q = populatedDeque(SIZE);
888		for (int i = 0; i < SIZE; ++i) {
889	<	assertEquals(i, ((Integer)q.takeFirst()).intValue());
889	>	assertEquals(i, q.takeFirst());
890		}
891		}
892
#	Line 934 | Line 934 | public class LinkedBlockingDequeTest ext
934		public void testTimedPollFirst0() throws InterruptedException {
935		LinkedBlockingDeque q = populatedDeque(SIZE);
936		for (int i = 0; i < SIZE; ++i) {
937	<	assertEquals(i, ((Integer)q.pollFirst(0, MILLISECONDS)).intValue());
937	>	assertEquals(i, q.pollFirst(0, MILLISECONDS));
938		}
939		assertNull(q.pollFirst(0, MILLISECONDS));
940		}
#	Line 945 | Line 945 | public class LinkedBlockingDequeTest ext
945		public void testTimedPollFirst() throws InterruptedException {
946		LinkedBlockingDeque q = populatedDeque(SIZE);
947		for (int i = 0; i < SIZE; ++i) {
948	<	assertEquals(i, ((Integer)q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)).intValue());
948	>	assertEquals(i, q.pollFirst(SHORT_DELAY_MS, MILLISECONDS));
949		}
950		assertNull(q.pollFirst(SHORT_DELAY_MS, MILLISECONDS));
951		}
#	Line 959 | Line 959 | public class LinkedBlockingDequeTest ext
959		public void realRun() throws InterruptedException {
960		LinkedBlockingDeque q = populatedDeque(SIZE);
961		for (int i = 0; i < SIZE; ++i) {
962	<	assertEquals(i, ((Integer)q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)).intValue());
962	>	assertEquals(i, q.pollFirst(SHORT_DELAY_MS, MILLISECONDS));
963		}
964		try {
965		q.pollFirst(SMALL_DELAY_MS, MILLISECONDS);
#	Line 1099 | Line 1099 | public class LinkedBlockingDequeTest ext
1099		public void testTakeLast() throws InterruptedException {
1100		LinkedBlockingDeque q = populatedDeque(SIZE);
1101		for (int i = 0; i < SIZE; ++i) {
1102	<	assertEquals(SIZE-i-1, ((Integer)q.takeLast()).intValue());
1102	>	assertEquals(SIZE-i-1, q.takeLast());
1103		}
1104		}
1105
#	Line 1146 | Line 1146 | public class LinkedBlockingDequeTest ext
1146		public void testTimedPollLast0() throws InterruptedException {
1147		LinkedBlockingDeque q = populatedDeque(SIZE);
1148		for (int i = 0; i < SIZE; ++i) {
1149	<	assertEquals(SIZE-i-1, ((Integer)q.pollLast(0, MILLISECONDS)).intValue());
1149	>	assertEquals(SIZE-i-1, q.pollLast(0, MILLISECONDS));
1150		}
1151		assertNull(q.pollLast(0, MILLISECONDS));
1152		}
#	Line 1157 | Line 1157 | public class LinkedBlockingDequeTest ext
1157		public void testTimedPollLast() throws InterruptedException {
1158		LinkedBlockingDeque q = populatedDeque(SIZE);
1159		for (int i = 0; i < SIZE; ++i) {
1160	<	assertEquals(SIZE-i-1, ((Integer)q.pollLast(SHORT_DELAY_MS, MILLISECONDS)).intValue());
1160	>	assertEquals(SIZE-i-1, q.pollLast(SHORT_DELAY_MS, MILLISECONDS));
1161		}
1162		assertNull(q.pollLast(SHORT_DELAY_MS, MILLISECONDS));
1163		}
#	Line 1171 | Line 1171 | public class LinkedBlockingDequeTest ext
1171		public void realRun() throws InterruptedException {
1172		LinkedBlockingDeque q = populatedDeque(SIZE);
1173		for (int i = 0; i < SIZE; ++i) {
1174	<	assertEquals(SIZE-i-1, ((Integer)q.pollLast(SHORT_DELAY_MS, MILLISECONDS)).intValue());
1174	>	assertEquals(SIZE-i-1, q.pollLast(SHORT_DELAY_MS, MILLISECONDS));
1175		}
1176		try {
1177		q.pollLast(SMALL_DELAY_MS, MILLISECONDS);
#	Line 1215 | Line 1215 | public class LinkedBlockingDequeTest ext
1215		public void testElement() {
1216		LinkedBlockingDeque q = populatedDeque(SIZE);
1217		for (int i = 0; i < SIZE; ++i) {
1218	<	assertEquals(i, ((Integer)q.element()).intValue());
1218	>	assertEquals(i, q.element());
1219		q.poll();
1220		}
1221		try {
#	Line 1341 | Line 1341 | public class LinkedBlockingDequeTest ext
1341		* toArray(null) throws NPE
1342		*/
1343		public void testToArray_BadArg() {
1344	+	LinkedBlockingDeque q = populatedDeque(SIZE);
1345		try {
1345	–	LinkedBlockingDeque q = populatedDeque(SIZE);
1346		Object o[] = q.toArray(null);
1347		shouldThrow();
1348		} catch (NullPointerException success) {}
#	Line 1352 | Line 1352 | public class LinkedBlockingDequeTest ext
1352		* toArray with incompatible array type throws CCE
1353		*/
1354		public void testToArray1_BadArg() {
1355	+	LinkedBlockingDeque q = populatedDeque(SIZE);
1356		try {
1357	<	LinkedBlockingDeque q = populatedDeque(SIZE);
1357	<	Object o[] = q.toArray(new String[10] );
1357	>	Object o[] = q.toArray(new String[10]);
1358		shouldThrow();
1359		} catch (ArrayStoreException success) {}
1360		}
#	Line 1402 | Line 1402 | public class LinkedBlockingDequeTest ext
1402		assertEquals(0, q.remainingCapacity());
1403		int k = 0;
1404		for (Iterator it = q.iterator(); it.hasNext();) {
1405	<	int i = ((Integer)(it.next())).intValue();
1406	<	assertEquals(++k, i);
1405	>	assertEquals(++k, it.next());
1406		}
1407		assertEquals(3, k);
1408		}
#	Line 1454 | Line 1453 | public class LinkedBlockingDequeTest ext
1453		q.add(new Integer(1));
1454		int k = 0;
1455		for (Iterator it = q.descendingIterator(); it.hasNext();) {
1456	<	int i = ((Integer)(it.next())).intValue();
1458	<	assertEquals(++k, i);
1456	>	assertEquals(++k, it.next());
1457		}
1458
1459		assertEquals(3, k);

Diff Legend

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