ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/ArrayBlockingQueueTest.java

Comparing jsr166/src/test/tck/ArrayBlockingQueueTest.java (file contents):
Revision 1.12 by jsr166, Mon Nov 2 20:28:31 2009 UTC vs.
Revision 1.16 by jsr166, Sat Nov 21 02:33:20 2009 UTC

#	Line 10 | Line 10
10		import junit.framework.*;
11		import java.util.*;
12		import java.util.concurrent.*;
13	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
14		import java.io.*;
15
16		public class ArrayBlockingQueueTest extends JSR166TestCase {
17		public static void main(String[] args) {
18	<	junit.textui.TestRunner.run (suite());
18	>	junit.textui.TestRunner.run (suite());
19		}
20		public static Test suite() {
21	<	return new TestSuite(ArrayBlockingQueueTest.class);
21	>	return new TestSuite(ArrayBlockingQueueTest.class);
22		}
23
24		/**
#	Line 27 | Line 28 | public class ArrayBlockingQueueTest exte
28		private ArrayBlockingQueue populatedQueue(int n) {
29		ArrayBlockingQueue q = new ArrayBlockingQueue(n);
30		assertTrue(q.isEmpty());
31	<	for(int i = 0; i < n; i++)
32	<	assertTrue(q.offer(new Integer(i)));
31	>	for (int i = 0; i < n; i++)
32	>	assertTrue(q.offer(new Integer(i)));
33		assertFalse(q.isEmpty());
34		assertEquals(0, q.remainingCapacity());
35	<	assertEquals(n, q.size());
35	>	assertEquals(n, q.size());
36		return q;
37		}
38
#	Line 155 | Line 156 | public class ArrayBlockingQueueTest exte
156		*  offer(null) throws NPE
157		*/
158		public void testOfferNull() {
159	<	try {
159	>	try {
160		ArrayBlockingQueue q = new ArrayBlockingQueue(1);
161		q.offer(null);
162		shouldThrow();
#	Line 166 | Line 167 | public class ArrayBlockingQueueTest exte
167		*  add(null) throws NPE
168		*/
169		public void testAddNull() {
170	<	try {
170	>	try {
171		ArrayBlockingQueue q = new ArrayBlockingQueue(1);
172		q.add(null);
173		shouldThrow();
#	Line 186 | Line 187 | public class ArrayBlockingQueueTest exte
187		* add succeeds if not full; throws ISE if full
188		*/
189		public void testAdd() {
190	<	try {
190	>	try {
191		ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
192		for (int i = 0; i < SIZE; ++i) {
193		assertTrue(q.add(new Integer(i)));
194		}
195		assertEquals(0, q.remainingCapacity());
196		q.add(new Integer(SIZE));
197	<	} catch (IllegalStateException success){
198	<	}
197	>	} catch (IllegalStateException success) {
198	>	}
199		}
200
201		/**
#	Line 285 | Line 286 | public class ArrayBlockingQueueTest exte
286		*  put(null) throws NPE
287		*/
288		public void testPutNull() {
289	<	try {
289	>	try {
290		ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
291		q.put(null);
292		shouldThrow();
293		}
294	<	catch (NullPointerException success){
295	<	}
294	>	catch (NullPointerException success) {
295	>	}
296		catch (InterruptedException ie) {
297	<	unexpectedException();
297	>	unexpectedException();
298		}
299		}
300
#	Line 311 | Line 312 | public class ArrayBlockingQueueTest exte
312		assertEquals(0, q.remainingCapacity());
313		}
314		catch (InterruptedException ie) {
315	<	unexpectedException();
315	>	unexpectedException();
316		}
317		}
318
#	Line 330 | Line 331 | public class ArrayBlockingQueueTest exte
331		}
332		q.put(new Integer(SIZE));
333		threadShouldThrow();
334	<	} catch (InterruptedException ie){
334	>	} catch (InterruptedException ie) {
335		threadAssertEquals(added, SIZE);
336		}
337		}});
#	Line 341 | Line 342 | public class ArrayBlockingQueueTest exte
342		t.join();
343		}
344		catch (InterruptedException ie) {
345	<	unexpectedException();
345	>	unexpectedException();
346		}
347		}
348
#	Line 362 | Line 363 | public class ArrayBlockingQueueTest exte
363		++added;
364		q.put(new Object());
365		++added;
366	<	threadShouldThrow();
367	<	} catch (InterruptedException e){
366	>	threadShouldThrow();
367	>	} catch (InterruptedException e) {
368		threadAssertTrue(added >= 2);
369		}
370		}
#	Line 374 | Line 375 | public class ArrayBlockingQueueTest exte
375		q.take();
376		t.interrupt();
377		t.join();
378	<	} catch (Exception e){
378	>	} catch (Exception e) {
379		unexpectedException();
380		}
381		}
#	Line 389 | Line 390 | public class ArrayBlockingQueueTest exte
390		try {
391		q.put(new Object());
392		q.put(new Object());
393	<	threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));
394	<	q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
395	<	threadShouldThrow();
396	<	} catch (InterruptedException success){}
393	>	threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, MILLISECONDS));
394	>	q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
395	>	threadShouldThrow();
396	>	} catch (InterruptedException success) {}
397		}
398		});
399
#	Line 401 | Line 402 | public class ArrayBlockingQueueTest exte
402		Thread.sleep(SHORT_DELAY_MS);
403		t.interrupt();
404		t.join();
405	<	} catch (Exception e){
405	>	} catch (Exception e) {
406		unexpectedException();
407		}
408		}
#	Line 410 | Line 411 | public class ArrayBlockingQueueTest exte
411		* take retrieves elements in FIFO order
412		*/
413		public void testTake() {
414	<	try {
414	>	try {
415		ArrayBlockingQueue q = populatedQueue(SIZE);
416		for (int i = 0; i < SIZE; ++i) {
417		assertEquals(i, ((Integer)q.take()).intValue());
418		}
419	<	} catch (InterruptedException e){
420	<	unexpectedException();
421	<	}
419	>	} catch (InterruptedException e) {
420	>	unexpectedException();
421	>	}
422		}
423
424		/**
#	Line 429 | Line 430 | public class ArrayBlockingQueueTest exte
430		public void run() {
431		try {
432		q.take();
433	<	threadShouldThrow();
434	<	} catch (InterruptedException success){ }
433	>	threadShouldThrow();
434	>	} catch (InterruptedException success) { }
435		}
436		});
437		try {
#	Line 438 | Line 439 | public class ArrayBlockingQueueTest exte
439		Thread.sleep(SHORT_DELAY_MS);
440		t.interrupt();
441		t.join();
442	<	} catch (Exception e){
442	>	} catch (Exception e) {
443		unexpectedException();
444		}
445		}
#	Line 456 | Line 457 | public class ArrayBlockingQueueTest exte
457		}
458		q.take();
459		threadShouldThrow();
460	<	} catch (InterruptedException success){
460	>	} catch (InterruptedException success) {
461		}
462		}});
463		try {
#	Line 466 | Line 467 | public class ArrayBlockingQueueTest exte
467		t.join();
468		}
469		catch (InterruptedException ie) {
470	<	unexpectedException();
470	>	unexpectedException();
471		}
472		}
473
#	Line 479 | Line 480 | public class ArrayBlockingQueueTest exte
480		for (int i = 0; i < SIZE; ++i) {
481		assertEquals(i, ((Integer)q.poll()).intValue());
482		}
483	<	assertNull(q.poll());
483	>	assertNull(q.poll());
484		}
485
486		/**
#	Line 489 | Line 490 | public class ArrayBlockingQueueTest exte
490		try {
491		ArrayBlockingQueue q = populatedQueue(SIZE);
492		for (int i = 0; i < SIZE; ++i) {
493	<	assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());
493	>	assertEquals(i, ((Integer)q.poll(0, MILLISECONDS)).intValue());
494		}
495	<	assertNull(q.poll(0, TimeUnit.MILLISECONDS));
496	<	} catch (InterruptedException e){
497	<	unexpectedException();
498	<	}
495	>	assertNull(q.poll(0, MILLISECONDS));
496	>	} catch (InterruptedException e) {
497	>	unexpectedException();
498	>	}
499		}
500
501		/**
#	Line 504 | Line 505 | public class ArrayBlockingQueueTest exte
505		try {
506		ArrayBlockingQueue q = populatedQueue(SIZE);
507		for (int i = 0; i < SIZE; ++i) {
508	<	assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
508	>	assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
509		}
510	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
511	<	} catch (InterruptedException e){
512	<	unexpectedException();
513	<	}
510	>	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
511	>	} catch (InterruptedException e) {
512	>	unexpectedException();
513	>	}
514		}
515
516		/**
#	Line 522 | Line 523 | public class ArrayBlockingQueueTest exte
523		try {
524		ArrayBlockingQueue q = populatedQueue(SIZE);
525		for (int i = 0; i < SIZE; ++i) {
526	<	threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
526	>	threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
527		}
528	<	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
529	<	} catch (InterruptedException success){
528	>	threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
529	>	} catch (InterruptedException success) {
530		}
531		}});
532		try {
#	Line 535 | Line 536 | public class ArrayBlockingQueueTest exte
536		t.join();
537		}
538		catch (InterruptedException ie) {
539	<	unexpectedException();
539	>	unexpectedException();
540		}
541		}
542
#	Line 548 | Line 549 | public class ArrayBlockingQueueTest exte
549		Thread t = new Thread(new Runnable() {
550		public void run() {
551		try {
552	<	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
553	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
554	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
555	<	threadShouldThrow();
552	>	threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
553	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
554	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
555	>	threadShouldThrow();
556		} catch (InterruptedException success) { }
557		}
558		});
559		try {
560		t.start();
561		Thread.sleep(SMALL_DELAY_MS);
562	<	assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
562	>	assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
563		t.interrupt();
564		t.join();
565	<	} catch (Exception e){
565	>	} catch (Exception e) {
566		unexpectedException();
567		}
568		}
#	Line 578 | Line 579 | public class ArrayBlockingQueueTest exte
579		assertTrue(q.peek() == null ||
580		i != ((Integer)q.peek()).intValue());
581		}
582	<	assertNull(q.peek());
582	>	assertNull(q.peek());
583		}
584
585		/**
#	Line 608 | Line 609 | public class ArrayBlockingQueueTest exte
609		try {
610		q.remove();
611		shouldThrow();
612	<	} catch (NoSuchElementException success){
613	<	}
612	>	} catch (NoSuchElementException success) {
613	>	}
614		}
615
616		/**
#	Line 709 | Line 710 | public class ArrayBlockingQueueTest exte
710		*/
711		public void testToArray() {
712		ArrayBlockingQueue q = populatedQueue(SIZE);
713	<	Object[] o = q.toArray();
714	<	try {
715	<	for(int i = 0; i < o.length; i++)
716	<	assertEquals(o[i], q.take());
717	<	} catch (InterruptedException e){
718	<	unexpectedException();
719	<	}
713	>	Object[] o = q.toArray();
714	>	try {
715	>	for (int i = 0; i < o.length; i++)
716	>	assertEquals(o[i], q.take());
717	>	} catch (InterruptedException e) {
718	>	unexpectedException();
719	>	}
720		}
721
722		/**
#	Line 723 | Line 724 | public class ArrayBlockingQueueTest exte
724		*/
725		public void testToArray2() {
726		ArrayBlockingQueue q = populatedQueue(SIZE);
727	<	Integer[] ints = new Integer[SIZE];
728	<	ints = (Integer[])q.toArray(ints);
729	<	try {
730	<	for(int i = 0; i < ints.length; i++)
731	<	assertEquals(ints[i], q.take());
732	<	} catch (InterruptedException e){
733	<	unexpectedException();
734	<	}
727	>	Integer[] ints = new Integer[SIZE];
728	>	ints = (Integer[])q.toArray(ints);
729	>	try {
730	>	for (int i = 0; i < ints.length; i++)
731	>	assertEquals(ints[i], q.take());
732	>	} catch (InterruptedException e) {
733	>	unexpectedException();
734	>	}
735		}
736
737		/**
738		* toArray(null) throws NPE
739		*/
740		public void testToArray_BadArg() {
741	<	try {
741	>	try {
742		ArrayBlockingQueue q = populatedQueue(SIZE);
743	<	Object o[] = q.toArray(null);
744	<	shouldThrow();
745	<	} catch(NullPointerException success){}
743	>	Object o[] = q.toArray(null);
744	>	shouldThrow();
745	>	} catch (NullPointerException success) {}
746		}
747
748		/**
749		* toArray with incompatible array type throws CCE
750		*/
751		public void testToArray1_BadArg() {
752	<	try {
752	>	try {
753		ArrayBlockingQueue q = populatedQueue(SIZE);
754	<	Object o[] = q.toArray(new String[10] );
755	<	shouldThrow();
756	<	} catch(ArrayStoreException  success){}
754	>	Object o[] = q.toArray(new String[10] );
755	>	shouldThrow();
756	>	} catch (ArrayStoreException  success) {}
757		}
758
759
#	Line 761 | Line 762 | public class ArrayBlockingQueueTest exte
762		*/
763		public void testIterator() {
764		ArrayBlockingQueue q = populatedQueue(SIZE);
765	<	Iterator it = q.iterator();
766	<	try {
767	<	while(it.hasNext()){
768	<	assertEquals(it.next(), q.take());
769	<	}
770	<	} catch (InterruptedException e){
771	<	unexpectedException();
772	<	}
765	>	Iterator it = q.iterator();
766	>	try {
767	>	while (it.hasNext()) {
768	>	assertEquals(it.next(), q.take());
769	>	}
770	>	} catch (InterruptedException e) {
771	>	unexpectedException();
772	>	}
773		}
774
775		/**
#	Line 854 | Line 855 | public class ArrayBlockingQueueTest exte
855		public void run() {
856		threadAssertFalse(q.offer(three));
857		try {
858	<	threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
858	>	threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
859		threadAssertEquals(0, q.remainingCapacity());
860		}
861		catch (InterruptedException e) {
#	Line 889 | Line 890 | public class ArrayBlockingQueueTest exte
890		public void run() {
891		threadAssertNull(q.poll());
892		try {
893	<	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
893	>	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
894		threadAssertTrue(q.isEmpty());
895		}
896		catch (InterruptedException e) {
#	Line 931 | Line 932 | public class ArrayBlockingQueueTest exte
932		assertEquals(q.size(), r.size());
933		while (!q.isEmpty())
934		assertEquals(q.remove(), r.remove());
935	<	} catch(Exception e){
935	>	} catch (Exception e) {
936		unexpectedException();
937		}
938		}
#	Line 944 | Line 945 | public class ArrayBlockingQueueTest exte
945		try {
946		q.drainTo(null);
947		shouldThrow();
948	<	} catch(NullPointerException success) {
948	>	} catch (NullPointerException success) {
949		}
950		}
951
#	Line 956 | Line 957 | public class ArrayBlockingQueueTest exte
957		try {
958		q.drainTo(q);
959		shouldThrow();
960	<	} catch(IllegalArgumentException success) {
960	>	} catch (IllegalArgumentException success) {
961		}
962		}
963
#	Line 993 | Line 994 | public class ArrayBlockingQueueTest exte
994		public void run() {
995		try {
996		q.put(new Integer(SIZE+1));
997	<	} catch (InterruptedException ie){
997	>	} catch (InterruptedException ie) {
998		threadUnexpectedException();
999		}
1000		}
#	Line 1007 | Line 1008 | public class ArrayBlockingQueueTest exte
1008		assertEquals(l.get(i), new Integer(i));
1009		t.join();
1010		assertTrue(q.size() + l.size() >= SIZE);
1011	<	} catch(Exception e){
1011	>	} catch (Exception e) {
1012		unexpectedException();
1013		}
1014		}
#	Line 1020 | Line 1021 | public class ArrayBlockingQueueTest exte
1021		try {
1022		q.drainTo(null, 0);
1023		shouldThrow();
1024	<	} catch(NullPointerException success) {
1024	>	} catch (NullPointerException success) {
1025		}
1026		}
1027
#	Line 1032 | Line 1033 | public class ArrayBlockingQueueTest exte
1033		try {
1034		q.drainTo(q, 0);
1035		shouldThrow();
1036	<	} catch(IllegalArgumentException success) {
1036	>	} catch (IllegalArgumentException success) {
1037		}
1038		}
1039
#	Line 1042 | Line 1043 | public class ArrayBlockingQueueTest exte
1043		public void testDrainToN() {
1044		ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE*2);
1045		for (int i = 0; i < SIZE + 2; ++i) {
1046	<	for(int j = 0; j < SIZE; j++)
1046	>	for (int j = 0; j < SIZE; j++)
1047		assertTrue(q.offer(new Integer(j)));
1048		ArrayList l = new ArrayList();
1049		q.drainTo(l, i);

Diff Legend

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