ViewVC Help

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

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

Comparing jsr166/src/test/tck/LinkedTransferQueueTest.java (file contents):
Revision 1.28 by jsr166, Thu Oct 28 17:57:26 2010 UTC vs.
Revision 1.39 by jsr166, Fri Nov 5 00:17:22 2010 UTC

#	Line 40 | Line 40 | public class LinkedTransferQueueTest ext
40		new Generic().testSuite());
41		}
42
43	<	void checkEmpty(LinkedTransferQueue q) throws InterruptedException {
44	<	assertTrue(q.isEmpty());
45	<	assertEquals(0, q.size());
46	<	assertNull(q.peek());
47	<	assertNull(q.poll());
48	<	assertNull(q.poll(0, MILLISECONDS));
49	<	assertEquals(q.toString(), "[]");
50	<	assertTrue(Arrays.equals(q.toArray(), new Object[0]));
51	<	assertFalse(q.iterator().hasNext());
52	<	try {
53	<	q.element();
54	<	shouldThrow();
55	<	} catch (NoSuchElementException success) {}
56	<	try {
57	<	q.iterator().next();
58	<	shouldThrow();
59	<	} catch (NoSuchElementException success) {}
43	>	void checkEmpty(BlockingQueue q) {
44		try {
45	<	q.remove();
46	<	shouldThrow();
47	<	} catch (NoSuchElementException success) {}
45	>	assertTrue(q.isEmpty());
46	>	assertEquals(0, q.size());
47	>	assertNull(q.peek());
48	>	assertNull(q.poll());
49	>	assertNull(q.poll(0, MILLISECONDS));
50	>	assertEquals(q.toString(), "[]");
51	>	assertTrue(Arrays.equals(q.toArray(), new Object[0]));
52	>	assertFalse(q.iterator().hasNext());
53	>	try {
54	>	q.element();
55	>	shouldThrow();
56	>	} catch (NoSuchElementException success) {}
57	>	try {
58	>	q.iterator().next();
59	>	shouldThrow();
60	>	} catch (NoSuchElementException success) {}
61	>	try {
62	>	q.remove();
63	>	shouldThrow();
64	>	} catch (NoSuchElementException success) {}
65	>	} catch (InterruptedException ie) {
66	>	threadUnexpectedException(ie);
67	>	}
68		}
69
70		/**
#	Line 277 | Line 281 | public class LinkedTransferQueueTest ext
281		* take removes existing elements until empty, then blocks interruptibly
282		*/
283		public void testBlockingTake() throws InterruptedException {
284	<	final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
285	<	Thread t = new Thread(new CheckedRunnable() {
284	>	final BlockingQueue<Integer> q = populatedQueue(SIZE);
285	>	final CountDownLatch aboutToWait = new CountDownLatch(1);
286	>	Thread t = newStartedThread(new CheckedRunnable() {
287		public void realRun() throws InterruptedException {
288		for (int i = 0; i < SIZE; ++i) {
289		assertEquals(i, (int) q.take());
290		}
291	+	aboutToWait.countDown();
292		try {
293		q.take();
294		shouldThrow();
295		} catch (InterruptedException success) {}
296		}});
297
298	<	t.start();
299	<	Thread.sleep(SHORT_DELAY_MS);
298	>	aboutToWait.await();
299	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
300		t.interrupt();
301	<	t.join();
301	>	awaitTermination(t, MEDIUM_DELAY_MS);
302		checkEmpty(q);
303		}
304
#	Line 309 | Line 315 | public class LinkedTransferQueueTest ext
315		}
316
317		/**
318	<	* timed pool with zero timeout succeeds when non-empty, else times out
318	>	* timed poll with zero timeout succeeds when non-empty, else times out
319		*/
320		public void testTimedPoll0() throws InterruptedException {
321		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
#	Line 321 | Line 327 | public class LinkedTransferQueueTest ext
327		}
328
329		/**
330	<	* timed pool with nonzero timeout succeeds when non-empty, else times out
330	>	* timed poll with nonzero timeout succeeds when non-empty, else times out
331		*/
332		public void testTimedPoll() throws InterruptedException {
333		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
334		for (int i = 0; i < SIZE; ++i) {
335		long t0 = System.nanoTime();
336	<	assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
336	>	assertEquals(i, (int) q.poll(SMALL_DELAY_MS, MILLISECONDS));
337		assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
338		}
339	+	long t0 = System.nanoTime();
340		assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
341	+	assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
342		checkEmpty(q);
343		}
344
#	Line 339 | Line 347 | public class LinkedTransferQueueTest ext
347		* returning timeout status
348		*/
349		public void testInterruptedTimedPoll() throws InterruptedException {
350	<	final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
350	>	final BlockingQueue<Integer> q = populatedQueue(SIZE);
351	>	final CountDownLatch aboutToWait = new CountDownLatch(1);
352		Thread t = newStartedThread(new CheckedRunnable() {
353		public void realRun() throws InterruptedException {
354		for (int i = 0; i < SIZE; ++i) {
#	Line 347 | Line 356 | public class LinkedTransferQueueTest ext
356		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
357		assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
358		}
359	+	long t0 = System.nanoTime();
360	+	aboutToWait.countDown();
361		try {
362	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
362	>	q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
363		shouldThrow();
364	<	} catch (InterruptedException success) {}
364	>	} catch (InterruptedException success) {
365	>	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
366	>	}
367		}});
368
369	<	Thread.sleep(SMALL_DELAY_MS);
369	>	aboutToWait.await();
370	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
371		t.interrupt();
372	<	t.join();
372	>	awaitTermination(t, MEDIUM_DELAY_MS);
373	>	checkEmpty(q);
374	>	}
375	>
376	>	/**
377	>	* timed poll after thread interrupted throws InterruptedException
378	>	* instead of returning timeout status
379	>	*/
380	>	public void testTimedPollAfterInterrupt() throws InterruptedException {
381	>	final BlockingQueue<Integer> q = populatedQueue(SIZE);
382	>	Thread t = newStartedThread(new CheckedRunnable() {
383	>	public void realRun() throws InterruptedException {
384	>	Thread.currentThread().interrupt();
385	>	for (int i = 0; i < SIZE; ++i) {
386	>	long t0 = System.nanoTime();
387	>	assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
388	>	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
389	>	}
390	>	try {
391	>	q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
392	>	shouldThrow();
393	>	} catch (InterruptedException success) {}
394	>	}});
395	>
396	>	awaitTermination(t, MEDIUM_DELAY_MS);
397		checkEmpty(q);
398		}
399
#	Line 512 | Line 550 | public class LinkedTransferQueueTest ext
550		}
551
552		/**
553	<	* toArray() contains all elements
553	>	* toArray() contains all elements in FIFO order
554		*/
555	<	public void testToArray() throws InterruptedException {
555	>	public void testToArray() {
556		LinkedTransferQueue q = populatedQueue(SIZE);
557		Object[] o = q.toArray();
558		for (int i = 0; i < o.length; i++) {
559	<	assertEquals(o[i], q.take());
559	>	assertSame(o[i], q.poll());
560		}
561		}
562
563		/**
564	<	* toArray(a) contains all elements
564	>	* toArray(a) contains all elements in FIFO order
565		*/
566	<	public void testToArray2() throws InterruptedException {
566	>	public void testToArray2() {
567		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
568		Integer[] ints = new Integer[SIZE];
569	<	ints = q.toArray(ints);
569	>	Integer[] array = q.toArray(ints);
570	>	assertSame(ints, array);
571		for (int i = 0; i < ints.length; i++) {
572	<	assertEquals(ints[i], q.take());
572	>	assertSame(ints[i], q.poll());
573		}
574		}
575
576		/**
577		* toArray(null) throws NullPointerException
578		*/
579	<	public void testToArray_BadArg() {
579	>	public void testToArray_NullArg() {
580		LinkedTransferQueue q = populatedQueue(SIZE);
581		try {
582	<	Object o[] = q.toArray(null);
582	>	q.toArray(null);
583		shouldThrow();
584		} catch (NullPointerException success) {}
585		}
586
587		/**
588	<	* toArray(incompatible array type) throws CCE
588	>	* toArray(incompatible array type) throws ArrayStoreException
589		*/
590		public void testToArray1_BadArg() {
591		LinkedTransferQueue q = populatedQueue(SIZE);
592		try {
593	<	Object o[] = q.toArray(new String[10]);
593	>	q.toArray(new String[10]);
594		shouldThrow();
595		} catch (ArrayStoreException success) {}
596		}
#	Line 637 | Line 676 | public class LinkedTransferQueueTest ext
676		*/
677		public void testOfferInExecutor() {
678		final LinkedTransferQueue q = new LinkedTransferQueue();
679	<	q.add(one);
641	<	q.add(two);
679	>	final CountDownLatch threadsStarted = new CountDownLatch(2);
680		ExecutorService executor = Executors.newFixedThreadPool(2);
681
682		executor.execute(new CheckedRunnable() {
683	<	public void realRun() {
684	<	assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
683	>	public void realRun() throws InterruptedException {
684	>	threadsStarted.countDown();
685	>	threadsStarted.await();
686	>	assertTrue(q.offer(one, MEDIUM_DELAY_MS, MILLISECONDS));
687		}});
688
689		executor.execute(new CheckedRunnable() {
690		public void realRun() throws InterruptedException {
691	<	Thread.sleep(SMALL_DELAY_MS);
691	>	threadsStarted.countDown();
692	>	threadsStarted.await();
693		assertSame(one, q.take());
694	+	checkEmpty(q);
695		}});
696
697		joinPool(executor);
#	Line 660 | Line 702 | public class LinkedTransferQueueTest ext
702		*/
703		public void testPollInExecutor() {
704		final LinkedTransferQueue q = new LinkedTransferQueue();
705	+	final CountDownLatch threadsStarted = new CountDownLatch(2);
706		ExecutorService executor = Executors.newFixedThreadPool(2);
707
708		executor.execute(new CheckedRunnable() {
709		public void realRun() throws InterruptedException {
710		assertNull(q.poll());
711	<	assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
712	<	assertTrue(q.isEmpty());
711	>	threadsStarted.countDown();
712	>	threadsStarted.await();
713	>	assertSame(one, q.poll(SMALL_DELAY_MS, MILLISECONDS));
714	>	checkEmpty(q);
715		}});
716
717		executor.execute(new CheckedRunnable() {
718		public void realRun() throws InterruptedException {
719	<	Thread.sleep(SMALL_DELAY_MS);
719	>	threadsStarted.countDown();
720	>	threadsStarted.await();
721		q.put(one);
722		}});
723
#	Line 697 | Line 743 | public class LinkedTransferQueueTest ext
743		LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
744
745		assertEquals(q.size(), r.size());
746	+	assertEquals(q.toString(), r.toString());
747	+	assertTrue(Arrays.equals(q.toArray(), r.toArray()));
748		while (!q.isEmpty()) {
749		assertEquals(q.remove(), r.remove());
750		}
#	Line 765 | Line 813 | public class LinkedTransferQueueTest ext
813		for (int i = 0; i < SIZE; ++i) {
814		assertEquals(l.get(i), i);
815		}
816	<	t.join();
816	>	awaitTermination(t, MEDIUM_DELAY_MS);
817		assertTrue(q.size() + l.size() >= SIZE);
818		}
819
#	Line 821 | Line 869 | public class LinkedTransferQueueTest ext
869		final LinkedTransferQueue q = new LinkedTransferQueue();
870		assertEquals(q.getWaitingConsumerCount(), 0);
871		assertFalse(q.hasWaitingConsumer());
872	+	final CountDownLatch threadStarted = new CountDownLatch(1);
873
874		Thread t = newStartedThread(new CheckedRunnable() {
875		public void realRun() throws InterruptedException {
876	<	Thread.sleep(SMALL_DELAY_MS);
877	<	assertTrue(q.hasWaitingConsumer());
829	<	assertEquals(q.getWaitingConsumerCount(), 1);
830	<	assertTrue(q.offer(one));
831	<	assertFalse(q.hasWaitingConsumer());
876	>	threadStarted.countDown();
877	>	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
878		assertEquals(q.getWaitingConsumerCount(), 0);
879	+	assertFalse(q.hasWaitingConsumer());
880		}});
881
882	<	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
882	>	threadStarted.await();
883	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
884	>	assertEquals(q.getWaitingConsumerCount(), 1);
885	>	assertTrue(q.hasWaitingConsumer());
886	>
887	>	assertTrue(q.offer(one));
888		assertEquals(q.getWaitingConsumerCount(), 0);
889		assertFalse(q.hasWaitingConsumer());
890	<	t.join();
890	>
891	>	awaitTermination(t, MEDIUM_DELAY_MS);
892		}
893
894		/**
#	Line 856 | Line 909 | public class LinkedTransferQueueTest ext
909		public void testTransfer2() throws InterruptedException {
910		final LinkedTransferQueue<Integer> q
911		= new LinkedTransferQueue<Integer>();
912	+	final CountDownLatch threadStarted = new CountDownLatch(1);
913
914		Thread t = newStartedThread(new CheckedRunnable() {
915		public void realRun() throws InterruptedException {
916	<	q.transfer(SIZE);
917	<	assertTrue(q.isEmpty());
916	>	threadStarted.countDown();
917	>	q.transfer(five);
918	>	checkEmpty(q);
919		}});
920
921	<	Thread.sleep(SHORT_DELAY_MS);
921	>	threadStarted.await();
922	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
923		assertEquals(1, q.size());
924	<	assertEquals(SIZE, (int) q.poll());
925	<	assertTrue(q.isEmpty());
926	<	t.join();
924	>	assertSame(five, q.poll());
925	>	checkEmpty(q);
926	>	awaitTermination(t, MEDIUM_DELAY_MS);
927		}
928
929		/**
#	Line 879 | Line 935 | public class LinkedTransferQueueTest ext
935
936		Thread first = newStartedThread(new CheckedRunnable() {
937		public void realRun() throws InterruptedException {
938	<	Integer i = SIZE + 1;
939	<	q.transfer(i);
884	<	assertTrue(!q.contains(i));
938	>	q.transfer(four);
939	>	assertTrue(!q.contains(four));
940		assertEquals(1, q.size());
941		}});
942
943		Thread interruptedThread = newStartedThread(
944		new CheckedInterruptedRunnable() {
945		public void realRun() throws InterruptedException {
946	<	while (q.size() == 0)
946	>	while (q.isEmpty())
947		Thread.yield();
948	<	q.transfer(SIZE);
948	>	q.transfer(five);
949		}});
950
951		while (q.size() < 2)
952		Thread.yield();
953		assertEquals(2, q.size());
954	<	assertEquals(SIZE + 1, (int) q.poll());
954	>	assertSame(four, q.poll());
955		first.join();
956		assertEquals(1, q.size());
957		interruptedThread.interrupt();
958		interruptedThread.join();
959	<	assertEquals(0, q.size());
905	<	assertTrue(q.isEmpty());
959	>	checkEmpty(q);
960		}
961
962		/**
#	Line 919 | Line 973 | public class LinkedTransferQueueTest ext
973		assertSame(three, q.poll());
974		}});
975
976	<	Thread.sleep(SHORT_DELAY_MS);
976	>	while (q.isEmpty())
977	>	Thread.yield();
978	>	assertFalse(q.isEmpty());
979	>	assertEquals(1, q.size());
980		assertTrue(q.offer(three));
981		assertSame(four, q.poll());
982	<	t.join();
982	>	awaitTermination(t, MEDIUM_DELAY_MS);
983		}
984
985		/**
#	Line 935 | Line 992 | public class LinkedTransferQueueTest ext
992
993		Thread t = newStartedThread(new CheckedRunnable() {
994		public void realRun() throws InterruptedException {
995	<	q.transfer(SIZE);
995	>	q.transfer(four);
996		checkEmpty(q);
997		}});
998
999	<	Thread.sleep(SHORT_DELAY_MS);
1000	<	assertEquals(SIZE, (int) q.take());
999	>	while (q.isEmpty())
1000	>	Thread.yield();
1001	>	assertFalse(q.isEmpty());
1002	>	assertEquals(1, q.size());
1003	>	assertSame(four, q.take());
1004		checkEmpty(q);
1005	<	t.join();
1005	>	awaitTermination(t, MEDIUM_DELAY_MS);
1006		}
1007
1008		/**
#	Line 980 | Line 1040 | public class LinkedTransferQueueTest ext
1040		while (! q.hasWaitingConsumer())
1041		Thread.yield();
1042		assertTrue(q.hasWaitingConsumer());
1043	<	assertTrue(q.isEmpty());
984	<	assertEquals(q.size(), 0);
1043	>	checkEmpty(q);
1044		assertTrue(q.tryTransfer(hotPotato));
1045		}});
1046
1047		assertSame(hotPotato, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
1048		checkEmpty(q);
1049	<	t.join();
1049	>	awaitTermination(t, MEDIUM_DELAY_MS);
1050		}
1051
1052		/**
#	Line 1003 | Line 1062 | public class LinkedTransferQueueTest ext
1062		while (! q.hasWaitingConsumer())
1063		Thread.yield();
1064		assertTrue(q.hasWaitingConsumer());
1065	<	assertTrue(q.isEmpty());
1007	<	assertEquals(q.size(), 0);
1065	>	checkEmpty(q);
1066		assertTrue(q.tryTransfer(hotPotato));
1067		}});
1068
1069		assertSame(q.take(), hotPotato);
1070		checkEmpty(q);
1071	<	t.join();
1071	>	awaitTermination(t, MEDIUM_DELAY_MS);
1072		}
1073
1074		/**
#	Line 1019 | Line 1077 | public class LinkedTransferQueueTest ext
1077		*/
1078		public void testTryTransfer5() throws InterruptedException {
1079		final LinkedTransferQueue q = new LinkedTransferQueue();
1080	+	final CountDownLatch threadStarted = new CountDownLatch(1);
1081
1082	<	Thread toInterrupt = newStartedThread(new CheckedInterruptedRunnable() {
1082	>	Thread t = newStartedThread(new CheckedRunnable() {
1083		public void realRun() throws InterruptedException {
1084	<	q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1084	>	long t0 = System.nanoTime();
1085	>	threadStarted.countDown();
1086	>	try {
1087	>	q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1088	>	shouldThrow();
1089	>	} catch (InterruptedException success) {}
1090	>	assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
1091		}});
1092
1093	<	Thread.sleep(SMALL_DELAY_MS);
1094	<	toInterrupt.interrupt();
1095	<	toInterrupt.join();
1093	>	threadStarted.await();
1094	>	Thread.sleep(SHORT_DELAY_MS);
1095	>	t.interrupt();
1096	>	awaitTermination(t, MEDIUM_DELAY_MS);
1097	>	checkEmpty(q);
1098		}
1099
1100		/**
1101	<	* tryTransfer gives up after the timeout and return false
1101	>	* tryTransfer gives up after the timeout and returns false
1102		*/
1103		public void testTryTransfer6() throws InterruptedException {
1104		final LinkedTransferQueue q = new LinkedTransferQueue();
#	Line 1042 | Line 1109 | public class LinkedTransferQueueTest ext
1109		assertFalse(q.tryTransfer(new Object(),
1110		SHORT_DELAY_MS, MILLISECONDS));
1111		assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
1112	+	checkEmpty(q);
1113		}});
1114
1047	–	checkEmpty(q);
1115		awaitTermination(t, MEDIUM_DELAY_MS);
1116		checkEmpty(q);
1117		}
#	Line 1060 | Line 1127 | public class LinkedTransferQueueTest ext
1127		Thread t = newStartedThread(new CheckedRunnable() {
1128		public void realRun() throws InterruptedException {
1129		assertTrue(q.tryTransfer(five, MEDIUM_DELAY_MS, MILLISECONDS));
1130	<	assertTrue(q.isEmpty());
1130	>	checkEmpty(q);
1131		}});
1132
1133	<	Thread.sleep(SHORT_DELAY_MS);
1133	>	while (q.size() != 2)
1134	>	Thread.yield();
1135		assertEquals(2, q.size());
1136		assertSame(four, q.poll());
1137		assertSame(five, q.poll());
1138		checkEmpty(q);
1139	<	t.join();
1139	>	awaitTermination(t, MEDIUM_DELAY_MS);
1140		}
1141
1142		/**
#	Line 1079 | Line 1147 | public class LinkedTransferQueueTest ext
1147		final LinkedTransferQueue q = new LinkedTransferQueue();
1148		assertTrue(q.offer(four));
1149		assertEquals(1, q.size());
1150	+	long t0 = System.nanoTime();
1151		assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, MILLISECONDS));
1152	+	assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
1153		assertEquals(1, q.size());
1154		assertSame(four, q.poll());
1155		assertNull(q.poll());
#	Line 1088 | Line 1158 | public class LinkedTransferQueueTest ext
1158
1159		private LinkedTransferQueue<Integer> populatedQueue(int n) {
1160		LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1161	<	assertTrue(q.isEmpty());
1161	>	checkEmpty(q);
1162		for (int i = 0; i < n; i++) {
1163		assertEquals(i, q.size());
1164		assertTrue(q.offer(i));

Diff Legend

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