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.19 by jsr166, Sat Nov 21 19:11:53 2009 UTC vs.
Revision 1.35 by jsr166, Wed Nov 3 16:46:34 2010 UTC

#	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 214 | Line 228 | public class LinkedBlockingQueueTest ext
228		shouldThrow();
229		} catch (NullPointerException success) {}
230		}
231	+
232		/**
233		* addAll of a collection with any null elements throws NPE after
234		* possibly adding some elements
#	Line 228 | Line 243 | public class LinkedBlockingQueueTest ext
243		shouldThrow();
244		} catch (NullPointerException success) {}
245		}
246	+
247		/**
248		* addAll throws ISE if not enough room
249		*/
#	Line 241 | Line 257 | public class LinkedBlockingQueueTest ext
257		shouldThrow();
258		} catch (IllegalStateException success) {}
259		}
260	+
261		/**
262		* Queue contains all elements, in traversal order, of successful addAll
263		*/
#	Line 284 | Line 301 | public class LinkedBlockingQueueTest ext
301		* put blocks interruptibly if full
302		*/
303		public void testBlockingPut() throws InterruptedException {
304	+	final LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
305		Thread t = new Thread(new CheckedRunnable() {
306	<	public void realRun() {
307	<	int added = 0;
306	>	public void realRun() throws InterruptedException {
307	>	for (int i = 0; i < SIZE; ++i)
308	>	q.put(i);
309	>	assertEquals(SIZE, q.size());
310	>	assertEquals(0, q.remainingCapacity());
311		try {
312	<	LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
313	<	for (int i = 0; i < SIZE; ++i) {
314	<	q.put(new Integer(i));
294	<	++added;
295	<	}
296	<	q.put(new Integer(SIZE));
297	<	threadShouldThrow();
298	<	} catch (InterruptedException success) {
299	<	threadAssertEquals(added, SIZE);
300	<	}
312	>	q.put(99);
313	>	shouldThrow();
314	>	} catch (InterruptedException success) {}
315		}});
316
317		t.start();
318		Thread.sleep(SHORT_DELAY_MS);
319		t.interrupt();
320		t.join();
321	+	assertEquals(SIZE, q.size());
322	+	assertEquals(0, q.remainingCapacity());
323		}
324
325		/**
326		* put blocks waiting for take when full
327		*/
328		public void testPutWithTake() throws InterruptedException {
329	+	final int capacity = 2;
330		final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
331		Thread t = new Thread(new CheckedRunnable() {
332	<	public void realRun() {
333	<	int added = 0;
332	>	public void realRun() throws InterruptedException {
333	>	for (int i = 0; i < capacity + 1; i++)
334	>	q.put(i);
335		try {
336	<	q.put(new Object());
337	<	++added;
338	<	q.put(new Object());
321	<	++added;
322	<	q.put(new Object());
323	<	++added;
324	<	q.put(new Object());
325	<	++added;
326	<	threadShouldThrow();
327	<	} catch (InterruptedException success) {
328	<	threadAssertTrue(added >= 2);
329	<	}
336	>	q.put(99);
337	>	shouldThrow();
338	>	} catch (InterruptedException success) {}
339		}});
340
341		t.start();
342		Thread.sleep(SHORT_DELAY_MS);
343	<	q.take();
343	>	assertEquals(q.remainingCapacity(), 0);
344	>	assertEquals(0, q.take());
345	>	Thread.sleep(SHORT_DELAY_MS);
346		t.interrupt();
347		t.join();
348	+	assertEquals(q.remainingCapacity(), 0);
349		}
350
351		/**
#	Line 341 | Line 353 | public class LinkedBlockingQueueTest ext
353		*/
354		public void testTimedOffer() throws InterruptedException {
355		final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
356	<	Thread t = new ThreadShouldThrow(InterruptedException.class) {
356	>	Thread t = new Thread(new CheckedRunnable() {
357		public void realRun() throws InterruptedException {
358		q.put(new Object());
359		q.put(new Object());
360	<	threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS));
361	<	q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
362	<	}};
360	>	assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS));
361	>	try {
362	>	q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
363	>	shouldThrow();
364	>	} catch (InterruptedException success) {}
365	>	}});
366
367		t.start();
368		Thread.sleep(SMALL_DELAY_MS);
#	Line 361 | Line 376 | public class LinkedBlockingQueueTest ext
376		public void testTake() throws InterruptedException {
377		LinkedBlockingQueue q = populatedQueue(SIZE);
378		for (int i = 0; i < SIZE; ++i) {
379	<	assertEquals(i, ((Integer)q.take()).intValue());
379	>	assertEquals(i, q.take());
380		}
381		}
382
383		/**
369	–	* take blocks interruptibly when empty
370	–	*/
371	–	public void testTakeFromEmpty() throws InterruptedException {
372	–	final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
373	–	Thread t = new ThreadShouldThrow(InterruptedException.class) {
374	–	public void realRun() throws InterruptedException {
375	–	q.take();
376	–	}};
377	–
378	–	t.start();
379	–	Thread.sleep(SHORT_DELAY_MS);
380	–	t.interrupt();
381	–	t.join();
382	–	}
383	–
384	–	/**
384		* Take removes existing elements until empty, then blocks interruptibly
385		*/
386		public void testBlockingTake() throws InterruptedException {
387	<	Thread t = new ThreadShouldThrow(InterruptedException.class) {
387	>	final LinkedBlockingQueue q = populatedQueue(SIZE);
388	>	Thread t = new Thread(new CheckedRunnable() {
389		public void realRun() throws InterruptedException {
390	–	LinkedBlockingQueue q = populatedQueue(SIZE);
390		for (int i = 0; i < SIZE; ++i) {
391	<	assertEquals(i, ((Integer)q.take()).intValue());
391	>	assertEquals(i, q.take());
392		}
393	<	q.take();
394	<	}};
393	>	try {
394	>	q.take();
395	>	shouldThrow();
396	>	} catch (InterruptedException success) {}
397	>	}});
398
399		t.start();
400		Thread.sleep(SHORT_DELAY_MS);
#	Line 400 | Line 402 | public class LinkedBlockingQueueTest ext
402		t.join();
403		}
404
403	–
405		/**
406		* poll succeeds unless empty
407		*/
408		public void testPoll() {
409		LinkedBlockingQueue q = populatedQueue(SIZE);
410		for (int i = 0; i < SIZE; ++i) {
411	<	assertEquals(i, ((Integer)q.poll()).intValue());
411	>	assertEquals(i, q.poll());
412		}
413		assertNull(q.poll());
414		}
415
416		/**
417	<	* timed pool with zero timeout succeeds when non-empty, else times out
417	>	* timed poll with zero timeout succeeds when non-empty, else times out
418		*/
419		public void testTimedPoll0() throws InterruptedException {
420		LinkedBlockingQueue q = populatedQueue(SIZE);
421		for (int i = 0; i < SIZE; ++i) {
422	<	assertEquals(i, ((Integer)q.poll(0, MILLISECONDS)).intValue());
422	>	assertEquals(i, q.poll(0, MILLISECONDS));
423		}
424		assertNull(q.poll(0, MILLISECONDS));
425		}
426
427		/**
428	<	* timed pool with nonzero timeout succeeds when non-empty, else times out
428	>	* timed poll with nonzero timeout succeeds when non-empty, else times out
429		*/
430		public void testTimedPoll() throws InterruptedException {
431		LinkedBlockingQueue q = populatedQueue(SIZE);
432		for (int i = 0; i < SIZE; ++i) {
433	<	assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
433	>	assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));
434		}
435		assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
436		}
#	Line 443 | Line 444 | public class LinkedBlockingQueueTest ext
444		public void realRun() throws InterruptedException {
445		LinkedBlockingQueue q = populatedQueue(SIZE);
446		for (int i = 0; i < SIZE; ++i) {
447	<	assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
447	>	assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));
448		}
449		try {
450		q.poll(SMALL_DELAY_MS, MILLISECONDS);
#	Line 458 | Line 459 | public class LinkedBlockingQueueTest ext
459		}
460
461		/**
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 ThreadShouldThrow(InterruptedException.class) {
467	–	public void realRun() throws InterruptedException {
468	–	threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
469	–	q.poll(LONG_DELAY_MS, MILLISECONDS);
470	–	q.poll(LONG_DELAY_MS, MILLISECONDS);
471	–	}};
472	–
473	–	t.start();
474	–	Thread.sleep(SMALL_DELAY_MS);
475	–	assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
476	–	t.interrupt();
477	–	t.join();
478	–	}
479	–
480	–	/**
462		* peek returns next element, or null if empty
463		*/
464		public void testPeek() {
465		LinkedBlockingQueue q = populatedQueue(SIZE);
466		for (int i = 0; i < SIZE; ++i) {
467	<	assertEquals(i, ((Integer)q.peek()).intValue());
468	<	q.poll();
467	>	assertEquals(i, q.peek());
468	>	assertEquals(i, q.poll());
469		assertTrue(q.peek() == null ||
470	<	i != ((Integer)q.peek()).intValue());
470	>	!q.peek().equals(i));
471		}
472		assertNull(q.peek());
473		}
#	Line 497 | Line 478 | public class LinkedBlockingQueueTest ext
478		public void testElement() {
479		LinkedBlockingQueue q = populatedQueue(SIZE);
480		for (int i = 0; i < SIZE; ++i) {
481	<	assertEquals(i, ((Integer)q.element()).intValue());
482	<	q.poll();
481	>	assertEquals(i, q.element());
482	>	assertEquals(i, q.poll());
483		}
484		try {
485		q.element();
#	Line 512 | Line 493 | public class LinkedBlockingQueueTest ext
493		public void testRemove() {
494		LinkedBlockingQueue q = populatedQueue(SIZE);
495		for (int i = 0; i < SIZE; ++i) {
496	<	assertEquals(i, ((Integer)q.remove()).intValue());
496	>	assertEquals(i, q.remove());
497		}
498		try {
499		q.remove();
#	Line 647 | Line 628 | public class LinkedBlockingQueueTest ext
628		}
629
630		/**
631	<	* toArray(null) throws NPE
631	>	* toArray(null) throws NullPointerException
632		*/
633	<	public void testToArray_BadArg() {
633	>	public void testToArray_NullArg() {
634	>	LinkedBlockingQueue q = populatedQueue(SIZE);
635		try {
636	<	LinkedBlockingQueue q = populatedQueue(SIZE);
655	<	Object o[] = q.toArray(null);
636	>	q.toArray(null);
637		shouldThrow();
638		} catch (NullPointerException success) {}
639		}
640
641		/**
642	<	* toArray with incompatible array type throws CCE
642	>	* toArray(incompatible array type) throws ArrayStoreException
643		*/
644		public void testToArray1_BadArg() {
645	+	LinkedBlockingQueue q = populatedQueue(SIZE);
646		try {
647	<	LinkedBlockingQueue q = populatedQueue(SIZE);
666	<	Object o[] = q.toArray(new String[10] );
647	>	q.toArray(new String[10]);
648		shouldThrow();
649		} catch (ArrayStoreException success) {}
650		}
#	Line 683 | Line 664 | public class LinkedBlockingQueueTest ext
664		/**
665		* iterator.remove removes current element
666		*/
667	<	public void testIteratorRemove () {
667	>	public void testIteratorRemove() {
668		final LinkedBlockingQueue q = new LinkedBlockingQueue(3);
669		q.add(two);
670		q.add(one);
#	Line 694 | Line 675 | public class LinkedBlockingQueueTest ext
675		it.remove();
676
677		it = q.iterator();
678	<	assertEquals(it.next(), one);
679	<	assertEquals(it.next(), three);
678	>	assertSame(it.next(), one);
679	>	assertSame(it.next(), three);
680		assertFalse(it.hasNext());
681		}
682
#	Line 711 | Line 692 | public class LinkedBlockingQueueTest ext
692		assertEquals(0, q.remainingCapacity());
693		int k = 0;
694		for (Iterator it = q.iterator(); it.hasNext();) {
695	<	int i = ((Integer)(it.next())).intValue();
715	<	assertEquals(++k, i);
695	>	assertEquals(++k, it.next());
696		}
697		assertEquals(3, k);
698		}
#	Line 720 | Line 700 | public class LinkedBlockingQueueTest ext
700		/**
701		* Modifications do not cause iterators to fail
702		*/
703	<	public void testWeaklyConsistentIteration () {
703	>	public void testWeaklyConsistentIteration() {
704		final LinkedBlockingQueue q = new LinkedBlockingQueue(3);
705		q.add(one);
706		q.add(two);
#	Line 755 | Line 735 | public class LinkedBlockingQueueTest ext
735		ExecutorService executor = Executors.newFixedThreadPool(2);
736		executor.execute(new CheckedRunnable() {
737		public void realRun() throws InterruptedException {
738	<	threadAssertFalse(q.offer(three));
739	<	threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
740	<	threadAssertEquals(0, q.remainingCapacity());
738	>	assertFalse(q.offer(three));
739	>	assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
740	>	assertEquals(0, q.remainingCapacity());
741		}});
742
743		executor.execute(new CheckedRunnable() {
744		public void realRun() throws InterruptedException {
745		Thread.sleep(SMALL_DELAY_MS);
746	<	threadAssertEquals(one, q.take());
746	>	assertSame(one, q.take());
747		}});
748
749		joinPool(executor);
#	Line 777 | Line 757 | public class LinkedBlockingQueueTest ext
757		ExecutorService executor = Executors.newFixedThreadPool(2);
758		executor.execute(new CheckedRunnable() {
759		public void realRun() throws InterruptedException {
760	<	threadAssertNull(q.poll());
761	<	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
762	<	threadAssertTrue(q.isEmpty());
760	>	assertNull(q.poll());
761	>	assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
762	>	assertTrue(q.isEmpty());
763		}});
764
765		executor.execute(new CheckedRunnable() {
#	Line 899 | Line 879 | public class LinkedBlockingQueueTest ext
879		}
880
881		/**
882	<	* drainTo(c, n) empties first max {n, size} elements of queue into c
882	>	* drainTo(c, n) empties first min(n, size) elements of queue into c
883		*/
884		public void testDrainToN() {
885		LinkedBlockingQueue q = new LinkedBlockingQueue();
#	Line 908 | Line 888 | public class LinkedBlockingQueueTest ext
888		assertTrue(q.offer(new Integer(j)));
889		ArrayList l = new ArrayList();
890		q.drainTo(l, i);
891	<	int k = (i < SIZE)? i : SIZE;
891	>	int k = (i < SIZE) ? i : SIZE;
892		assertEquals(l.size(), k);
893		assertEquals(q.size(), SIZE-k);
894		for (int j = 0; j < k; ++j)

Diff Legend

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