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.14 by jsr166, Mon Nov 16 05:30:07 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)));
#	Line 194 | Line 195 | public class ArrayBlockingQueueTest exte
195		assertEquals(0, q.remainingCapacity());
196		q.add(new Integer(SIZE));
197		} catch (IllegalStateException success) {
198	<	}
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	<	}
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 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();
366	>	threadShouldThrow();
367		} catch (InterruptedException e) {
368		threadAssertTrue(added >= 2);
369		}
#	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();
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		});
#	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	<	}
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();
433	>	threadShouldThrow();
434		} catch (InterruptedException success) { }
435		}
436		});
#	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));
495	>	assertNull(q.poll(0, MILLISECONDS));
496		} catch (InterruptedException e) {
497	<	unexpectedException();
498	<	}
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));
510	>	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
511		} catch (InterruptedException e) {
512	<	unexpectedException();
513	<	}
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));
528	>	threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
529		} catch (InterruptedException success) {
530		}
531		}});
#	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) {
#	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 609 | Line 610 | public class ArrayBlockingQueueTest exte
610		q.remove();
611		shouldThrow();
612		} catch (NoSuchElementException success) {
613	<	}
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) {

Diff Legend

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