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.37 by jsr166, Thu Oct 28 22:20:47 2010 UTC vs.
Revision 1.46 by jsr166, Sat May 21 06:24:33 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 41 | Line 41 | public class ArrayBlockingQueueTest exte
41		* Create a queue of given size containing consecutive
42		* Integers 0 ... n.
43		*/
44	<	private ArrayBlockingQueue populatedQueue(int n) {
45	<	ArrayBlockingQueue q = new ArrayBlockingQueue(n);
44	>	private ArrayBlockingQueue<Integer> populatedQueue(int n) {
45	>	ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(n);
46		assertTrue(q.isEmpty());
47		for (int i = 0; i < n; i++)
48		assertTrue(q.offer(new Integer(i)));
#	Line 294 | Line 294 | public class ArrayBlockingQueueTest exte
294		q.put(null);
295		shouldThrow();
296		} catch (NullPointerException success) {}
297	<	}
297	>	}
298
299		/**
300		* all elements successfully put are contained
#	Line 327 | Line 327 | public class ArrayBlockingQueueTest exte
327		}});
328
329		t.start();
330	<	Thread.sleep(SHORT_DELAY_MS);
330	>	delay(SHORT_DELAY_MS);
331		t.interrupt();
332		t.join();
333		assertEquals(SIZE, q.size());
#	Line 351 | Line 351 | public class ArrayBlockingQueueTest exte
351		}});
352
353		t.start();
354	<	Thread.sleep(SHORT_DELAY_MS);
354	>	delay(SHORT_DELAY_MS);
355		assertEquals(q.remainingCapacity(), 0);
356		assertEquals(0, q.take());
357	<	Thread.sleep(SHORT_DELAY_MS);
357	>	delay(SHORT_DELAY_MS);
358		t.interrupt();
359		t.join();
360		assertEquals(q.remainingCapacity(), 0);
#	Line 365 | Line 365 | public class ArrayBlockingQueueTest exte
365		*/
366		public void testTimedOffer() throws InterruptedException {
367		final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
368	<	Thread t = new Thread(new CheckedRunnable() {
368	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
369	>	Thread t = newStartedThread(new CheckedRunnable() {
370		public void realRun() throws InterruptedException {
371		q.put(new Object());
372		q.put(new Object());
373	<	assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, MILLISECONDS));
373	>	long startTime = System.nanoTime();
374	>	assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
375	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
376	>	pleaseInterrupt.countDown();
377		try {
378	<	q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
378	>	q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
379		shouldThrow();
380		} catch (InterruptedException success) {}
381		}});
382
383	<	t.start();
380	<	Thread.sleep(SHORT_DELAY_MS);
383	>	await(pleaseInterrupt);
384		t.interrupt();
385	<	t.join();
385	>	awaitTermination(t);
386		}
387
388		/**
#	Line 409 | Line 412 | public class ArrayBlockingQueueTest exte
412		}});
413
414		t.start();
415	<	Thread.sleep(SHORT_DELAY_MS);
415	>	delay(SHORT_DELAY_MS);
416		t.interrupt();
417		t.join();
418		}
#	Line 453 | Line 456 | public class ArrayBlockingQueueTest exte
456		* returning timeout status
457		*/
458		public void testInterruptedTimedPoll() throws InterruptedException {
459	<	Thread t = new Thread(new CheckedRunnable() {
459	>	final BlockingQueue<Integer> q = populatedQueue(SIZE);
460	>	final CountDownLatch aboutToWait = new CountDownLatch(1);
461	>	Thread t = newStartedThread(new CheckedRunnable() {
462		public void realRun() throws InterruptedException {
458	–	ArrayBlockingQueue q = populatedQueue(SIZE);
463		for (int i = 0; i < SIZE; ++i) {
464	<	assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));;
464	>	long t0 = System.nanoTime();
465	>	assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
466	>	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
467		}
468	+	long t0 = System.nanoTime();
469	+	aboutToWait.countDown();
470		try {
471	<	q.poll(SMALL_DELAY_MS, MILLISECONDS);
471	>	q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
472		shouldThrow();
473	<	} catch (InterruptedException success) {}
473	>	} catch (InterruptedException success) {
474	>	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
475	>	}
476		}});
477
478	<	t.start();
479	<	Thread.sleep(SHORT_DELAY_MS);
478	>	aboutToWait.await();
479	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
480		t.interrupt();
481	<	t.join();
481	>	awaitTermination(t, MEDIUM_DELAY_MS);
482	>	checkEmpty(q);
483		}
484
485		/**
#	Line 607 | Line 618 | public class ArrayBlockingQueueTest exte
618		}
619
620		/**
621	<	* toArray contains all elements
621	>	* toArray contains all elements in FIFO order
622		*/
623	<	public void testToArray() throws InterruptedException {
623	>	public void testToArray() {
624		ArrayBlockingQueue q = populatedQueue(SIZE);
625		Object[] o = q.toArray();
626		for (int i = 0; i < o.length; i++)
627	<	assertEquals(o[i], q.take());
627	>	assertSame(o[i], q.poll());
628		}
629
630		/**
631	<	* toArray(a) contains all elements
631	>	* toArray(a) contains all elements in FIFO order
632		*/
633	<	public void testToArray2() throws InterruptedException {
634	<	ArrayBlockingQueue q = populatedQueue(SIZE);
633	>	public void testToArray2() {
634	>	ArrayBlockingQueue<Integer> q = populatedQueue(SIZE);
635		Integer[] ints = new Integer[SIZE];
636	<	ints = (Integer[])q.toArray(ints);
636	>	Integer[] array = q.toArray(ints);
637	>	assertSame(ints, array);
638		for (int i = 0; i < ints.length; i++)
639	<	assertEquals(ints[i], q.take());
639	>	assertSame(ints[i], q.poll());
640		}
641
642		/**
643	<	* toArray(null) throws NPE
643	>	* toArray(null) throws NullPointerException
644		*/
645	<	public void testToArray_BadArg() {
645	>	public void testToArray_NullArg() {
646		ArrayBlockingQueue q = populatedQueue(SIZE);
647		try {
648	<	Object o[] = q.toArray(null);
648	>	q.toArray(null);
649		shouldThrow();
650		} catch (NullPointerException success) {}
651		}
652
653		/**
654	<	* toArray with incompatible array type throws CCE
654	>	* toArray(incompatible array type) throws ArrayStoreException
655		*/
656		public void testToArray1_BadArg() {
657		ArrayBlockingQueue q = populatedQueue(SIZE);
658		try {
659	<	Object o[] = q.toArray(new String[10]);
659	>	q.toArray(new String[10]);
660		shouldThrow();
661		} catch (ArrayStoreException success) {}
662		}
#	Line 743 | Line 755 | public class ArrayBlockingQueueTest exte
755
756		executor.execute(new CheckedRunnable() {
757		public void realRun() throws InterruptedException {
758	<	Thread.sleep(SMALL_DELAY_MS);
758	>	delay(SMALL_DELAY_MS);
759		assertSame(one, q.take());
760		}});
761
#	Line 765 | Line 777 | public class ArrayBlockingQueueTest exte
777
778		executor.execute(new CheckedRunnable() {
779		public void realRun() throws InterruptedException {
780	<	Thread.sleep(SMALL_DELAY_MS);
780	>	delay(SMALL_DELAY_MS);
781		q.put(one);
782		}});
783

Diff Legend

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