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.24 by jsr166, Tue Dec 1 06:03:49 2009 UTC vs.
Revision 1.41 by jsr166, Thu Apr 14 22:55:08 2011 UTC

#	Line 1 | Line 1
1		/*
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
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		* Other contributors include Andrew Wright, Jeffrey Hayes,
6		* Pat Fisher, Mike Judd.
7		*/
#	Line 14 | Line 14 | import java.io.*;
14
15		public class LinkedBlockingQueueTest extends JSR166TestCase {
16
17	+	public static class Unbounded extends BlockingQueueTest {
18	+	protected BlockingQueue emptyCollection() {
19	+	return new LinkedBlockingQueue();
20	+	}
21	+	}
22	+
23	+	public static class Bounded extends BlockingQueueTest {
24	+	protected BlockingQueue emptyCollection() {
25	+	return new LinkedBlockingQueue(20);
26	+	}
27	+	}
28	+
29		public static void main(String[] args) {
30	<	junit.textui.TestRunner.run (suite());
30	>	junit.textui.TestRunner.run(suite());
31		}
32
33		public static Test suite() {
34	<	return new TestSuite(LinkedBlockingQueueTest.class);
34	>	return newTestSuite(LinkedBlockingQueueTest.class,
35	>	new Unbounded().testSuite(),
36	>	new Bounded().testSuite());
37		}
38
39
#	Line 27 | Line 41 | public class LinkedBlockingQueueTest ext
41		* Create a queue of given size containing consecutive
42		* Integers 0 ... n.
43		*/
44	<	private LinkedBlockingQueue populatedQueue(int n) {
45	<	LinkedBlockingQueue q = new LinkedBlockingQueue(n);
44	>	private LinkedBlockingQueue<Integer> populatedQueue(int n) {
45	>	LinkedBlockingQueue<Integer> q =
46	>	new LinkedBlockingQueue<Integer>(n);
47		assertTrue(q.isEmpty());
48		for (int i = 0; i < n; i++)
49		assertTrue(q.offer(new Integer(i)));
#	Line 214 | Line 229 | public class LinkedBlockingQueueTest ext
229		shouldThrow();
230		} catch (NullPointerException success) {}
231		}
232	+
233		/**
234		* addAll of a collection with any null elements throws NPE after
235		* possibly adding some elements
#	Line 228 | Line 244 | public class LinkedBlockingQueueTest ext
244		shouldThrow();
245		} catch (NullPointerException success) {}
246		}
247	+
248		/**
249		* addAll throws ISE if not enough room
250		*/
#	Line 241 | Line 258 | public class LinkedBlockingQueueTest ext
258		shouldThrow();
259		} catch (IllegalStateException success) {}
260		}
261	+
262		/**
263		* Queue contains all elements, in traversal order, of successful addAll
264		*/
#	Line 259 | Line 277 | public class LinkedBlockingQueueTest ext
277		/**
278		* put(null) throws NPE
279		*/
280	<	public void testPutNull() throws InterruptedException {
280	>	public void testPutNull() throws InterruptedException {
281		try {
282		LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
283		q.put(null);
284		shouldThrow();
285		} catch (NullPointerException success) {}
286	<	}
286	>	}
287
288		/**
289		* all elements successfully put are contained
#	Line 364 | Line 382 | public class LinkedBlockingQueueTest ext
382		}
383
384		/**
367	–	* take blocks interruptibly when empty
368	–	*/
369	–	public void testTakeFromEmpty() throws InterruptedException {
370	–	final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
371	–	Thread t = new ThreadShouldThrow(InterruptedException.class) {
372	–	public void realRun() throws InterruptedException {
373	–	q.take();
374	–	}};
375	–
376	–	t.start();
377	–	Thread.sleep(SHORT_DELAY_MS);
378	–	t.interrupt();
379	–	t.join();
380	–	}
381	–
382	–	/**
385		* Take removes existing elements until empty, then blocks interruptibly
386		*/
387		public void testBlockingTake() throws InterruptedException {
#	Line 413 | Line 415 | public class LinkedBlockingQueueTest ext
415		}
416
417		/**
418	<	* timed pool with zero timeout succeeds when non-empty, else times out
418	>	* timed poll with zero timeout succeeds when non-empty, else times out
419		*/
420		public void testTimedPoll0() throws InterruptedException {
421		LinkedBlockingQueue q = populatedQueue(SIZE);
#	Line 424 | Line 426 | public class LinkedBlockingQueueTest ext
426		}
427
428		/**
429	<	* timed pool with nonzero timeout succeeds when non-empty, else times out
429	>	* timed poll with nonzero timeout succeeds when non-empty, else times out
430		*/
431		public void testTimedPoll() throws InterruptedException {
432		LinkedBlockingQueue q = populatedQueue(SIZE);
#	Line 439 | Line 441 | public class LinkedBlockingQueueTest ext
441		* returning timeout status
442		*/
443		public void testInterruptedTimedPoll() throws InterruptedException {
444	<	Thread t = new Thread(new CheckedRunnable() {
444	>	final BlockingQueue<Integer> q = populatedQueue(SIZE);
445	>	final CountDownLatch aboutToWait = new CountDownLatch(1);
446	>	Thread t = newStartedThread(new CheckedRunnable() {
447		public void realRun() throws InterruptedException {
444	–	LinkedBlockingQueue q = populatedQueue(SIZE);
448		for (int i = 0; i < SIZE; ++i) {
449	<	assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));
449	>	long t0 = System.nanoTime();
450	>	assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
451	>	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
452		}
453	+	long t0 = System.nanoTime();
454	+	aboutToWait.countDown();
455		try {
456	<	q.poll(SMALL_DELAY_MS, MILLISECONDS);
456	>	q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
457		shouldThrow();
458	<	} catch (InterruptedException success) {}
459	<	}});
460	<
454	<	t.start();
455	<	Thread.sleep(SHORT_DELAY_MS);
456	<	t.interrupt();
457	<	t.join();
458	<	}
459	<
460	<	/**
461	<	*  timed poll before a delayed offer fails; after offer succeeds;
462	<	*  on interruption throws
463	<	*/
464	<	public void testTimedPollWithOffer() throws InterruptedException {
465	<	final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
466	<	Thread t = new Thread(new CheckedRunnable() {
467	<	public void realRun() throws InterruptedException {
468	<	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
469	<	assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
470	<	try {
471	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
472	<	shouldThrow();
473	<	} catch (InterruptedException success) {}
458	>	} catch (InterruptedException success) {
459	>	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
460	>	}
461		}});
462
463	<	t.start();
464	<	Thread.sleep(SMALL_DELAY_MS);
478	<	assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
463	>	aboutToWait.await();
464	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
465		t.interrupt();
466	<	t.join();
466	>	awaitTermination(t, MEDIUM_DELAY_MS);
467	>	checkEmpty(q);
468		}
469
470		/**
#	Line 529 | Line 516 | public class LinkedBlockingQueueTest ext
516		public void testRemoveElement() {
517		LinkedBlockingQueue q = populatedQueue(SIZE);
518		for (int i = 1; i < SIZE; i+=2) {
519	<	assertTrue(q.remove(new Integer(i)));
519	>	assertTrue(q.contains(i));
520	>	assertTrue(q.remove(i));
521	>	assertFalse(q.contains(i));
522	>	assertTrue(q.contains(i-1));
523		}
524		for (int i = 0; i < SIZE; i+=2) {
525	<	assertTrue(q.remove(new Integer(i)));
526	<	assertFalse(q.remove(new Integer(i+1)));
525	>	assertTrue(q.contains(i));
526	>	assertTrue(q.remove(i));
527	>	assertFalse(q.contains(i));
528	>	assertFalse(q.remove(i+1));
529	>	assertFalse(q.contains(i+1));
530		}
531		assertTrue(q.isEmpty());
532		}
#	Line 629 | Line 622 | public class LinkedBlockingQueueTest ext
622		}
623
624		/**
625	<	* toArray contains all elements
625	>	* toArray contains all elements in FIFO order
626		*/
627	<	public void testToArray() throws InterruptedException {
627	>	public void testToArray() {
628		LinkedBlockingQueue q = populatedQueue(SIZE);
629		Object[] o = q.toArray();
630		for (int i = 0; i < o.length; i++)
631	<	assertEquals(o[i], q.take());
631	>	assertSame(o[i], q.poll());
632		}
633
634		/**
635	<	* toArray(a) contains all elements
635	>	* toArray(a) contains all elements in FIFO order
636		*/
637		public void testToArray2() throws InterruptedException {
638	<	LinkedBlockingQueue q = populatedQueue(SIZE);
638	>	LinkedBlockingQueue<Integer> q = populatedQueue(SIZE);
639		Integer[] ints = new Integer[SIZE];
640	<	ints = (Integer[])q.toArray(ints);
640	>	Integer[] array = q.toArray(ints);
641	>	assertSame(ints, array);
642		for (int i = 0; i < ints.length; i++)
643	<	assertEquals(ints[i], q.take());
643	>	assertSame(ints[i], q.poll());
644		}
645
646		/**
647	<	* toArray(null) throws NPE
647	>	* toArray(null) throws NullPointerException
648		*/
649	<	public void testToArray_BadArg() {
649	>	public void testToArray_NullArg() {
650		LinkedBlockingQueue q = populatedQueue(SIZE);
651		try {
652	<	Object o[] = q.toArray(null);
652	>	q.toArray(null);
653		shouldThrow();
654		} catch (NullPointerException success) {}
655		}
656
657		/**
658	<	* toArray with incompatible array type throws CCE
658	>	* toArray(incompatible array type) throws ArrayStoreException
659		*/
660		public void testToArray1_BadArg() {
661		LinkedBlockingQueue q = populatedQueue(SIZE);
662		try {
663	<	Object o[] = q.toArray(new String[10]);
663	>	q.toArray(new String[10]);
664		shouldThrow();
665		} catch (ArrayStoreException success) {}
666		}
#	Line 686 | Line 680 | public class LinkedBlockingQueueTest ext
680		/**
681		* iterator.remove removes current element
682		*/
683	<	public void testIteratorRemove () {
683	>	public void testIteratorRemove() {
684		final LinkedBlockingQueue q = new LinkedBlockingQueue(3);
685		q.add(two);
686		q.add(one);
#	Line 697 | Line 691 | public class LinkedBlockingQueueTest ext
691		it.remove();
692
693		it = q.iterator();
694	<	assertEquals(it.next(), one);
695	<	assertEquals(it.next(), three);
694	>	assertSame(it.next(), one);
695	>	assertSame(it.next(), three);
696		assertFalse(it.hasNext());
697		}
698
#	Line 722 | Line 716 | public class LinkedBlockingQueueTest ext
716		/**
717		* Modifications do not cause iterators to fail
718		*/
719	<	public void testWeaklyConsistentIteration () {
719	>	public void testWeaklyConsistentIteration() {
720		final LinkedBlockingQueue q = new LinkedBlockingQueue(3);
721		q.add(one);
722		q.add(two);
#	Line 901 | Line 895 | public class LinkedBlockingQueueTest ext
895		}
896
897		/**
898	<	* drainTo(c, n) empties first max {n, size} elements of queue into c
898	>	* drainTo(c, n) empties first min(n, size) elements of queue into c
899		*/
900		public void testDrainToN() {
901		LinkedBlockingQueue q = new LinkedBlockingQueue();
#	Line 910 | Line 904 | public class LinkedBlockingQueueTest ext
904		assertTrue(q.offer(new Integer(j)));
905		ArrayList l = new ArrayList();
906		q.drainTo(l, i);
907	<	int k = (i < SIZE)? i : SIZE;
907	>	int k = (i < SIZE) ? i : SIZE;
908		assertEquals(l.size(), k);
909		assertEquals(q.size(), SIZE-k);
910		for (int j = 0; j < k; ++j)

Diff Legend

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