ViewVC Help

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

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

Comparing jsr166/src/test/tck/LinkedBlockingQueueTest.java (file contents):
Revision 1.10 by dl, Sun Oct 31 14:55:14 2004 UTC vs.
Revision 1.13 by jsr166, Mon Nov 16 04:57:10 2009 UTC

#	Line 2 | Line 2
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4		* http://creativecommons.org/licenses/publicdomain
5	<	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	<	* Pat Fisher, Mike Judd.
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9		import junit.framework.*;
#	Line 14 | Line 14 | import java.io.*;
14		public class LinkedBlockingQueueTest extends JSR166TestCase {
15
16		public static void main(String[] args) {
17	<	junit.textui.TestRunner.run (suite());
17	>	junit.textui.TestRunner.run (suite());
18		}
19
20		public static Test suite() {
#	Line 29 | Line 29 | public class LinkedBlockingQueueTest ext
29		private LinkedBlockingQueue populatedQueue(int n) {
30		LinkedBlockingQueue q = new LinkedBlockingQueue(n);
31		assertTrue(q.isEmpty());
32	<	for(int i = 0; i < n; i++)
32	>	for (int i = 0; i < n; i++)
33		assertTrue(q.offer(new Integer(i)));
34		assertFalse(q.isEmpty());
35		assertEquals(0, q.remainingCapacity());
36		assertEquals(n, q.size());
37		return q;
38		}
39	<
39	>
40		/**
41		* A new queue has the indicated capacity, or Integer.MAX_VALUE if
42		* none given
#	Line 149 | Line 149 | public class LinkedBlockingQueueTest ext
149		LinkedBlockingQueue q = new LinkedBlockingQueue(1);
150		q.offer(null);
151		shouldThrow();
152	<	} catch (NullPointerException success) { }
152	>	} catch (NullPointerException success) { }
153		}
154
155		/**
#	Line 160 | Line 160 | public class LinkedBlockingQueueTest ext
160		LinkedBlockingQueue q = new LinkedBlockingQueue(1);
161		q.add(null);
162		shouldThrow();
163	<	} catch (NullPointerException success) { }
163	>	} catch (NullPointerException success) { }
164		}
165
166		/**
#	Line 184 | Line 184 | public class LinkedBlockingQueueTest ext
184		assertEquals(0, q.remainingCapacity());
185		q.add(new Integer(SIZE));
186		} catch (IllegalStateException success){
187	<	}
187	>	}
188		}
189
190		/**
#	Line 278 | Line 278 | public class LinkedBlockingQueueTest ext
278		LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
279		q.put(null);
280		shouldThrow();
281	<	}
281	>	}
282		catch (NullPointerException success){
283	<	}
283	>	}
284		catch (InterruptedException ie) {
285		unexpectedException();
286		}
#	Line 321 | Line 321 | public class LinkedBlockingQueueTest ext
321		threadShouldThrow();
322		} catch (InterruptedException ie){
323		threadAssertEquals(added, SIZE);
324	<	}
324	>	}
325		}});
326		t.start();
327	<	try {
328	<	Thread.sleep(SHORT_DELAY_MS);
327	>	try {
328	>	Thread.sleep(SHORT_DELAY_MS);
329		t.interrupt();
330		t.join();
331		}
#	Line 384 | Line 384 | public class LinkedBlockingQueueTest ext
384		} catch (InterruptedException success){}
385		}
386		});
387	<
387	>
388		try {
389		t.start();
390		Thread.sleep(SMALL_DELAY_MS);
#	Line 406 | Line 406 | public class LinkedBlockingQueueTest ext
406		}
407		} catch (InterruptedException e){
408		unexpectedException();
409	<	}
409	>	}
410		}
411
412		/**
#	Line 419 | Line 419 | public class LinkedBlockingQueueTest ext
419		try {
420		q.take();
421		threadShouldThrow();
422	<	} catch (InterruptedException success){ }
422	>	} catch (InterruptedException success){ }
423		}
424		});
425		try {
#	Line 446 | Line 446 | public class LinkedBlockingQueueTest ext
446		q.take();
447		threadShouldThrow();
448		} catch (InterruptedException success){
449	<	}
449	>	}
450		}});
451		t.start();
452	<	try {
453	<	Thread.sleep(SHORT_DELAY_MS);
452	>	try {
453	>	Thread.sleep(SHORT_DELAY_MS);
454		t.interrupt();
455		t.join();
456		}
#	Line 483 | Line 483 | public class LinkedBlockingQueueTest ext
483		assertNull(q.poll(0, TimeUnit.MILLISECONDS));
484		} catch (InterruptedException e){
485		unexpectedException();
486	<	}
486	>	}
487		}
488
489		/**
#	Line 498 | Line 498 | public class LinkedBlockingQueueTest ext
498		assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
499		} catch (InterruptedException e){
500		unexpectedException();
501	<	}
501	>	}
502		}
503
504		/**
#	Line 515 | Line 515 | public class LinkedBlockingQueueTest ext
515		}
516		threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
517		} catch (InterruptedException success){
518	<	}
518	>	}
519		}});
520		t.start();
521	<	try {
522	<	Thread.sleep(SHORT_DELAY_MS);
521	>	try {
522	>	Thread.sleep(SHORT_DELAY_MS);
523		t.interrupt();
524		t.join();
525		}
#	Line 541 | Line 541 | public class LinkedBlockingQueueTest ext
541		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
542		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
543		threadShouldThrow();
544	<	} catch (InterruptedException success) { }
544	>	} catch (InterruptedException success) { }
545		}
546		});
547		try {
#	Line 553 | Line 553 | public class LinkedBlockingQueueTest ext
553		} catch (Exception e){
554		unexpectedException();
555		}
556	<	}
556	>	}
557
558		/**
559		* peek returns next element, or null if empty
#	Line 597 | Line 597 | public class LinkedBlockingQueueTest ext
597		q.remove();
598		shouldThrow();
599		} catch (NoSuchElementException success){
600	<	}
600	>	}
601		}
602
603		/**
#	Line 614 | Line 614 | public class LinkedBlockingQueueTest ext
614		}
615		assertTrue(q.isEmpty());
616		}
617	<
617	>
618	>	/**
619	>	* An add following remove(x) succeeds
620	>	*/
621	>	public void testRemoveElementAndAdd() {
622	>	try {
623	>	LinkedBlockingQueue q = new LinkedBlockingQueue();
624	>	assertTrue(q.add(new Integer(1)));
625	>	assertTrue(q.add(new Integer(2)));
626	>	assertTrue(q.remove(new Integer(1)));
627	>	assertTrue(q.remove(new Integer(2)));
628	>	assertTrue(q.add(new Integer(3)));
629	>	assertTrue(q.take() != null);
630	>	} catch (Exception e){
631	>	unexpectedException();
632	>	}
633	>	}
634	>
635		/**
636		* contains(x) reports true when elements added but not yet removed
637		*/
#	Line 699 | Line 716 | public class LinkedBlockingQueueTest ext
716		LinkedBlockingQueue q = populatedQueue(SIZE);
717		Object[] o = q.toArray();
718		try {
719	<	for(int i = 0; i < o.length; i++)
719	>	for (int i = 0; i < o.length; i++)
720		assertEquals(o[i], q.take());
721		} catch (InterruptedException e){
722		unexpectedException();
723	<	}
723	>	}
724		}
725
726		/**
#	Line 714 | Line 731 | public class LinkedBlockingQueueTest ext
731		Integer[] ints = new Integer[SIZE];
732		ints = (Integer[])q.toArray(ints);
733		try {
734	<	for(int i = 0; i < ints.length; i++)
734	>	for (int i = 0; i < ints.length; i++)
735		assertEquals(ints[i], q.take());
736		} catch (InterruptedException e){
737		unexpectedException();
738	<	}
738	>	}
739		}
740
741		/**
#	Line 729 | Line 746 | public class LinkedBlockingQueueTest ext
746		LinkedBlockingQueue q = populatedQueue(SIZE);
747		Object o[] = q.toArray(null);
748		shouldThrow();
749	<	} catch(NullPointerException success){}
749	>	} catch (NullPointerException success){}
750		}
751
752		/**
#	Line 740 | Line 757 | public class LinkedBlockingQueueTest ext
757		LinkedBlockingQueue q = populatedQueue(SIZE);
758		Object o[] = q.toArray(new String[10] );
759		shouldThrow();
760	<	} catch(ArrayStoreException  success){}
760	>	} catch (ArrayStoreException  success){}
761		}
762
763	<
763	>
764		/**
765		* iterator iterates through all elements
766		*/
#	Line 751 | Line 768 | public class LinkedBlockingQueueTest ext
768		LinkedBlockingQueue q = populatedQueue(SIZE);
769		Iterator it = q.iterator();
770		try {
771	<	while(it.hasNext()){
771	>	while (it.hasNext()){
772		assertEquals(it.next(), q.take());
773		}
774		} catch (InterruptedException e){
775		unexpectedException();
776	<	}
776	>	}
777		}
778
779		/**
#	Line 771 | Line 788 | public class LinkedBlockingQueueTest ext
788		Iterator it = q.iterator();
789		it.next();
790		it.remove();
791	<
791	>
792		it = q.iterator();
793		assertEquals(it.next(), one);
794		assertEquals(it.next(), three);
#	Line 826 | Line 843 | public class LinkedBlockingQueueTest ext
843		for (int i = 0; i < SIZE; ++i) {
844		assertTrue(s.indexOf(String.valueOf(i)) >= 0);
845		}
846	<	}
846	>	}
847
848
849		/**
#	Line 861 | Line 878 | public class LinkedBlockingQueueTest ext
878		}
879		}
880		});
881	<
881	>
882		joinPool(executor);
883		}
884
#	Line 895 | Line 912 | public class LinkedBlockingQueueTest ext
912		}
913		}
914		});
915	<
915	>
916		joinPool(executor);
917		}
918
#	Line 915 | Line 932 | public class LinkedBlockingQueueTest ext
932		ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
933		LinkedBlockingQueue r = (LinkedBlockingQueue)in.readObject();
934		assertEquals(q.size(), r.size());
935	<	while (!q.isEmpty())
935	>	while (!q.isEmpty())
936		assertEquals(q.remove(), r.remove());
937	<	} catch(Exception e){
937	>	} catch (Exception e){
938		unexpectedException();
939		}
940		}
941
942		/**
943		* drainTo(null) throws NPE
944	<	*/
944	>	*/
945		public void testDrainToNull() {
946		LinkedBlockingQueue q = populatedQueue(SIZE);
947		try {
948		q.drainTo(null);
949		shouldThrow();
950	<	} catch(NullPointerException success) {
950	>	} catch (NullPointerException success) {
951		}
952		}
953
954		/**
955		* drainTo(this) throws IAE
956	<	*/
956	>	*/
957		public void testDrainToSelf() {
958		LinkedBlockingQueue q = populatedQueue(SIZE);
959		try {
960		q.drainTo(q);
961		shouldThrow();
962	<	} catch(IllegalArgumentException success) {
962	>	} catch (IllegalArgumentException success) {
963		}
964		}
965
966		/**
967		* drainTo(c) empties queue into another collection c
968	<	*/
968	>	*/
969		public void testDrainTo() {
970		LinkedBlockingQueue q = populatedQueue(SIZE);
971		ArrayList l = new ArrayList();
972		q.drainTo(l);
973		assertEquals(q.size(), 0);
974		assertEquals(l.size(), SIZE);
975	<	for (int i = 0; i < SIZE; ++i)
975	>	for (int i = 0; i < SIZE; ++i)
976		assertEquals(l.get(i), new Integer(i));
977		q.add(zero);
978		q.add(one);
#	Line 966 | Line 983 | public class LinkedBlockingQueueTest ext
983		q.drainTo(l);
984		assertEquals(q.size(), 0);
985		assertEquals(l.size(), 2);
986	<	for (int i = 0; i < 2; ++i)
986	>	for (int i = 0; i < 2; ++i)
987		assertEquals(l.get(i), new Integer(i));
988		}
989
990		/**
991		* drainTo empties full queue, unblocking a waiting put.
992	<	*/
992	>	*/
993		public void testDrainToWithActivePut() {
994		final LinkedBlockingQueue q = populatedQueue(SIZE);
995		Thread t = new Thread(new Runnable() {
996		public void run() {
997		try {
998		q.put(new Integer(SIZE+1));
999	<	} catch (InterruptedException ie){
999	>	} catch (InterruptedException ie){
1000		threadUnexpectedException();
1001		}
1002		}
#	Line 989 | Line 1006 | public class LinkedBlockingQueueTest ext
1006		ArrayList l = new ArrayList();
1007		q.drainTo(l);
1008		assertTrue(l.size() >= SIZE);
1009	<	for (int i = 0; i < SIZE; ++i)
1009	>	for (int i = 0; i < SIZE; ++i)
1010		assertEquals(l.get(i), new Integer(i));
1011		t.join();
1012		assertTrue(q.size() + l.size() >= SIZE);
1013	<	} catch(Exception e){
1013	>	} catch (Exception e){
1014		unexpectedException();
1015		}
1016		}
1017
1018		/**
1019		* drainTo(null, n) throws NPE
1020	<	*/
1020	>	*/
1021		public void testDrainToNullN() {
1022		LinkedBlockingQueue q = populatedQueue(SIZE);
1023		try {
1024		q.drainTo(null, 0);
1025		shouldThrow();
1026	<	} catch(NullPointerException success) {
1026	>	} catch (NullPointerException success) {
1027		}
1028		}
1029
1030		/**
1031		* drainTo(this, n) throws IAE
1032	<	*/
1032	>	*/
1033		public void testDrainToSelfN() {
1034		LinkedBlockingQueue q = populatedQueue(SIZE);
1035		try {
1036		q.drainTo(q, 0);
1037		shouldThrow();
1038	<	} catch(IllegalArgumentException success) {
1038	>	} catch (IllegalArgumentException success) {
1039		}
1040		}
1041
1042		/**
1043		* drainTo(c, n) empties first max {n, size} elements of queue into c
1044	<	*/
1044	>	*/
1045		public void testDrainToN() {
1046		LinkedBlockingQueue q = new LinkedBlockingQueue();
1047		for (int i = 0; i < SIZE + 2; ++i) {
1048	<	for(int j = 0; j < SIZE; j++)
1048	>	for (int j = 0; j < SIZE; j++)
1049		assertTrue(q.offer(new Integer(j)));
1050		ArrayList l = new ArrayList();
1051		q.drainTo(l, i);
1052		int k = (i < SIZE)? i : SIZE;
1053		assertEquals(l.size(), k);
1054		assertEquals(q.size(), SIZE-k);
1055	<	for (int j = 0; j < k; ++j)
1055	>	for (int j = 0; j < k; ++j)
1056		assertEquals(l.get(j), new Integer(j));
1057		while (q.poll() != null) ;
1058		}

Diff Legend

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