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.5 by dl, Thu Sep 25 11:02:41 2003 UTC vs.
Revision 1.13 by jsr166, Mon Nov 16 04:57:09 2009 UTC

#	Line 1 | Line 1
1		/*
2	<	* Written by members of JCP JSR-166 Expert Group and released to the
3	<	* public domain. Use, modify, and redistribute this code in any way
4	<	* without acknowledgement. Other contributors include Andrew Wright,
5	<	* Jeffrey Hayes, Pat Fischer, Mike Judd.
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.
7		*/
8
9
#	Line 13 | Line 14 | import java.io.*;
14
15		public class ArrayBlockingQueueTest extends JSR166TestCase {
16		public static void main(String[] args) {
17	<	junit.textui.TestRunner.run (suite());
17	>	junit.textui.TestRunner.run (suite());
18		}
19		public static Test suite() {
20		return new TestSuite(ArrayBlockingQueueTest.class);
#	Line 26 | Line 27 | public class ArrayBlockingQueueTest exte
27		private ArrayBlockingQueue populatedQueue(int n) {
28		ArrayBlockingQueue q = new ArrayBlockingQueue(n);
29		assertTrue(q.isEmpty());
30	<	for(int i = 0; i < n; i++)
30	>	for (int i = 0; i < n; i++)
31		assertTrue(q.offer(new Integer(i)));
32		assertFalse(q.isEmpty());
33		assertEquals(0, q.remainingCapacity());
34		assertEquals(n, q.size());
35		return q;
36		}
37	<
37	>
38		/**
39		* A new queue has the indicated capacity
40		*/
#	Line 158 | Line 159 | public class ArrayBlockingQueueTest exte
159		ArrayBlockingQueue q = new ArrayBlockingQueue(1);
160		q.offer(null);
161		shouldThrow();
162	<	} catch (NullPointerException success) { }
162	>	} catch (NullPointerException success) { }
163	>	}
164	>
165	>	/**
166	>	*  add(null) throws NPE
167	>	*/
168	>	public void testAddNull() {
169	>	try {
170	>	ArrayBlockingQueue q = new ArrayBlockingQueue(1);
171	>	q.add(null);
172	>	shouldThrow();
173	>	} catch (NullPointerException success) { }
174		}
175
176		/**
#	Line 182 | Line 194 | public class ArrayBlockingQueueTest exte
194		assertEquals(0, q.remainingCapacity());
195		q.add(new Integer(SIZE));
196		} catch (IllegalStateException success){
197	<	}
197	>	}
198		}
199
200		/**
#	Line 196 | Line 208 | public class ArrayBlockingQueueTest exte
208		}
209		catch (NullPointerException success) {}
210		}
211	+
212	+	/**
213	+	* addAll(this) throws IAE
214	+	*/
215	+	public void testAddAllSelf() {
216	+	try {
217	+	ArrayBlockingQueue q = populatedQueue(SIZE);
218	+	q.addAll(q);
219	+	shouldThrow();
220	+	}
221	+	catch (IllegalArgumentException success) {}
222	+	}
223	+
224	+
225		/**
226		*  addAll of a collection with null elements throws NPE
227		*/
#	Line 263 | Line 289 | public class ArrayBlockingQueueTest exte
289		ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
290		q.put(null);
291		shouldThrow();
292	<	}
292	>	}
293		catch (NullPointerException success){
294	<	}
294	>	}
295		catch (InterruptedException ie) {
296		unexpectedException();
297		}
#	Line 293 | Line 319 | public class ArrayBlockingQueueTest exte
319		* put blocks interruptibly if full
320		*/
321		public void testBlockingPut() {
322	+	final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
323		Thread t = new Thread(new Runnable() {
324		public void run() {
325		int added = 0;
326		try {
300	–	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
327		for (int i = 0; i < SIZE; ++i) {
328		q.put(new Integer(i));
329		++added;
#	Line 306 | Line 332 | public class ArrayBlockingQueueTest exte
332		threadShouldThrow();
333		} catch (InterruptedException ie){
334		threadAssertEquals(added, SIZE);
335	<	}
335	>	}
336		}});
337	<	try {
337	>	try {
338		t.start();
339	<	Thread.sleep(SHORT_DELAY_MS);
339	>	Thread.sleep(MEDIUM_DELAY_MS);
340		t.interrupt();
341		t.join();
342		}
#	Line 369 | Line 395 | public class ArrayBlockingQueueTest exte
395		} catch (InterruptedException success){}
396		}
397		});
398	<
398	>
399		try {
400		t.start();
401		Thread.sleep(SHORT_DELAY_MS);
#	Line 391 | Line 417 | public class ArrayBlockingQueueTest exte
417		}
418		} catch (InterruptedException e){
419		unexpectedException();
420	<	}
420	>	}
421		}
422
423		/**
#	Line 404 | Line 430 | public class ArrayBlockingQueueTest exte
430		try {
431		q.take();
432		threadShouldThrow();
433	<	} catch (InterruptedException success){ }
433	>	} catch (InterruptedException success){ }
434		}
435		});
436		try {
#	Line 431 | Line 457 | public class ArrayBlockingQueueTest exte
457		q.take();
458		threadShouldThrow();
459		} catch (InterruptedException success){
460	<	}
460	>	}
461		}});
462	<	try {
462	>	try {
463		t.start();
464	<	Thread.sleep(SHORT_DELAY_MS);
464	>	Thread.sleep(SHORT_DELAY_MS);
465		t.interrupt();
466		t.join();
467		}
#	Line 468 | Line 494 | public class ArrayBlockingQueueTest exte
494		assertNull(q.poll(0, TimeUnit.MILLISECONDS));
495		} catch (InterruptedException e){
496		unexpectedException();
497	<	}
497	>	}
498		}
499
500		/**
#	Line 483 | Line 509 | public class ArrayBlockingQueueTest exte
509		assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
510		} catch (InterruptedException e){
511		unexpectedException();
512	<	}
512	>	}
513		}
514
515		/**
#	Line 500 | Line 526 | public class ArrayBlockingQueueTest exte
526		}
527		threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
528		} catch (InterruptedException success){
529	<	}
529	>	}
530		}});
531	<	try {
531	>	try {
532		t.start();
533	<	Thread.sleep(SHORT_DELAY_MS);
533	>	Thread.sleep(SHORT_DELAY_MS);
534		t.interrupt();
535		t.join();
536		}
#	Line 526 | Line 552 | public class ArrayBlockingQueueTest exte
552		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
553		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
554		threadShouldThrow();
555	<	} catch (InterruptedException success) { }
555	>	} catch (InterruptedException success) { }
556		}
557		});
558		try {
#	Line 538 | Line 564 | public class ArrayBlockingQueueTest exte
564		} catch (Exception e){
565		unexpectedException();
566		}
567	<	}
567	>	}
568
569
570		/**
#	Line 583 | Line 609 | public class ArrayBlockingQueueTest exte
609		q.remove();
610		shouldThrow();
611		} catch (NoSuchElementException success){
612	<	}
612	>	}
613		}
614
615		/**
#	Line 600 | Line 626 | public class ArrayBlockingQueueTest exte
626		}
627		assertTrue(q.isEmpty());
628		}
629	<
629	>
630		/**
631		* contains(x) reports true when elements added but not yet removed
632		*/
#	Line 624 | Line 650 | public class ArrayBlockingQueueTest exte
650		assertEquals(SIZE, q.remainingCapacity());
651		q.add(one);
652		assertFalse(q.isEmpty());
653	+	assertTrue(q.contains(one));
654		q.clear();
655		assertTrue(q.isEmpty());
656		}
#	Line 684 | Line 711 | public class ArrayBlockingQueueTest exte
711		ArrayBlockingQueue q = populatedQueue(SIZE);
712		Object[] o = q.toArray();
713		try {
714	<	for(int i = 0; i < o.length; i++)
714	>	for (int i = 0; i < o.length; i++)
715		assertEquals(o[i], q.take());
716		} catch (InterruptedException e){
717		unexpectedException();
718	<	}
718	>	}
719		}
720
721		/**
#	Line 699 | Line 726 | public class ArrayBlockingQueueTest exte
726		Integer[] ints = new Integer[SIZE];
727		ints = (Integer[])q.toArray(ints);
728		try {
729	<	for(int i = 0; i < ints.length; i++)
729	>	for (int i = 0; i < ints.length; i++)
730		assertEquals(ints[i], q.take());
731		} catch (InterruptedException e){
732		unexpectedException();
733	<	}
733	>	}
734	>	}
735	>
736	>	/**
737	>	* toArray(null) throws NPE
738	>	*/
739	>	public void testToArray_BadArg() {
740	>	try {
741	>	ArrayBlockingQueue q = populatedQueue(SIZE);
742	>	Object o[] = q.toArray(null);
743	>	shouldThrow();
744	>	} catch (NullPointerException success){}
745	>	}
746	>
747	>	/**
748	>	* toArray with incompatible array type throws CCE
749	>	*/
750	>	public void testToArray1_BadArg() {
751	>	try {
752	>	ArrayBlockingQueue q = populatedQueue(SIZE);
753	>	Object o[] = q.toArray(new String[10] );
754	>	shouldThrow();
755	>	} catch (ArrayStoreException  success){}
756		}
757	<
757	>
758	>
759		/**
760		* iterator iterates through all elements
761		*/
#	Line 713 | Line 763 | public class ArrayBlockingQueueTest exte
763		ArrayBlockingQueue q = populatedQueue(SIZE);
764		Iterator it = q.iterator();
765		try {
766	<	while(it.hasNext()){
766	>	while (it.hasNext()){
767		assertEquals(it.next(), q.take());
768		}
769		} catch (InterruptedException e){
770		unexpectedException();
771	<	}
771	>	}
772		}
773
774		/**
#	Line 733 | Line 783 | public class ArrayBlockingQueueTest exte
783		Iterator it = q.iterator();
784		it.next();
785		it.remove();
786	<
786	>
787		it = q.iterator();
788		assertEquals(it.next(), one);
789		assertEquals(it.next(), three);
#	Line 789 | Line 839 | public class ArrayBlockingQueueTest exte
839		for (int i = 0; i < SIZE; ++i) {
840		assertTrue(s.indexOf(String.valueOf(i)) >= 0);
841		}
842	<	}
842	>	}
843
844
845		/**
#	Line 824 | Line 874 | public class ArrayBlockingQueueTest exte
874		}
875		}
876		});
877	<
877	>
878		joinPool(executor);
879
880		}
#	Line 859 | Line 909 | public class ArrayBlockingQueueTest exte
909		}
910		}
911		});
912	<
912	>
913		joinPool(executor);
914		}
915
#	Line 879 | Line 929 | public class ArrayBlockingQueueTest exte
929		ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
930		ArrayBlockingQueue r = (ArrayBlockingQueue)in.readObject();
931		assertEquals(q.size(), r.size());
932	<	while (!q.isEmpty())
932	>	while (!q.isEmpty())
933		assertEquals(q.remove(), r.remove());
934	<	} catch(Exception e){
934	>	} catch (Exception e){
935	>	unexpectedException();
936	>	}
937	>	}
938	>
939	>	/**
940	>	* drainTo(null) throws NPE
941	>	*/
942	>	public void testDrainToNull() {
943	>	ArrayBlockingQueue q = populatedQueue(SIZE);
944	>	try {
945	>	q.drainTo(null);
946	>	shouldThrow();
947	>	} catch (NullPointerException success) {
948	>	}
949	>	}
950	>
951	>	/**
952	>	* drainTo(this) throws IAE
953	>	*/
954	>	public void testDrainToSelf() {
955	>	ArrayBlockingQueue q = populatedQueue(SIZE);
956	>	try {
957	>	q.drainTo(q);
958	>	shouldThrow();
959	>	} catch (IllegalArgumentException success) {
960	>	}
961	>	}
962	>
963	>	/**
964	>	* drainTo(c) empties queue into another collection c
965	>	*/
966	>	public void testDrainTo() {
967	>	ArrayBlockingQueue q = populatedQueue(SIZE);
968	>	ArrayList l = new ArrayList();
969	>	q.drainTo(l);
970	>	assertEquals(q.size(), 0);
971	>	assertEquals(l.size(), SIZE);
972	>	for (int i = 0; i < SIZE; ++i)
973	>	assertEquals(l.get(i), new Integer(i));
974	>	q.add(zero);
975	>	q.add(one);
976	>	assertFalse(q.isEmpty());
977	>	assertTrue(q.contains(zero));
978	>	assertTrue(q.contains(one));
979	>	l.clear();
980	>	q.drainTo(l);
981	>	assertEquals(q.size(), 0);
982	>	assertEquals(l.size(), 2);
983	>	for (int i = 0; i < 2; ++i)
984	>	assertEquals(l.get(i), new Integer(i));
985	>	}
986	>
987	>	/**
988	>	* drainTo empties full queue, unblocking a waiting put.
989	>	*/
990	>	public void testDrainToWithActivePut() {
991	>	final ArrayBlockingQueue q = populatedQueue(SIZE);
992	>	Thread t = new Thread(new Runnable() {
993	>	public void run() {
994	>	try {
995	>	q.put(new Integer(SIZE+1));
996	>	} catch (InterruptedException ie){
997	>	threadUnexpectedException();
998	>	}
999	>	}
1000	>	});
1001	>	try {
1002	>	t.start();
1003	>	ArrayList l = new ArrayList();
1004	>	q.drainTo(l);
1005	>	assertTrue(l.size() >= SIZE);
1006	>	for (int i = 0; i < SIZE; ++i)
1007	>	assertEquals(l.get(i), new Integer(i));
1008	>	t.join();
1009	>	assertTrue(q.size() + l.size() >= SIZE);
1010	>	} catch (Exception e){
1011		unexpectedException();
1012		}
1013		}
1014
1015	+	/**
1016	+	* drainTo(null, n) throws NPE
1017	+	*/
1018	+	public void testDrainToNullN() {
1019	+	ArrayBlockingQueue q = populatedQueue(SIZE);
1020	+	try {
1021	+	q.drainTo(null, 0);
1022	+	shouldThrow();
1023	+	} catch (NullPointerException success) {
1024	+	}
1025	+	}
1026	+
1027	+	/**
1028	+	* drainTo(this, n) throws IAE
1029	+	*/
1030	+	public void testDrainToSelfN() {
1031	+	ArrayBlockingQueue q = populatedQueue(SIZE);
1032	+	try {
1033	+	q.drainTo(q, 0);
1034	+	shouldThrow();
1035	+	} catch (IllegalArgumentException success) {
1036	+	}
1037	+	}
1038	+
1039	+	/**
1040	+	* drainTo(c, n) empties first max {n, size} elements of queue into c
1041	+	*/
1042	+	public void testDrainToN() {
1043	+	ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE*2);
1044	+	for (int i = 0; i < SIZE + 2; ++i) {
1045	+	for (int j = 0; j < SIZE; j++)
1046	+	assertTrue(q.offer(new Integer(j)));
1047	+	ArrayList l = new ArrayList();
1048	+	q.drainTo(l, i);
1049	+	int k = (i < SIZE)? i : SIZE;
1050	+	assertEquals(l.size(), k);
1051	+	assertEquals(q.size(), SIZE-k);
1052	+	for (int j = 0; j < k; ++j)
1053	+	assertEquals(l.get(j), new Integer(j));
1054	+	while (q.poll() != null) ;
1055	+	}
1056	+	}
1057	+
1058
1059		}

Diff Legend

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