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.6 by dl, Sun Aug 2 12:31:24 2009 UTC vs.
Revision 1.7 by jsr166, Mon Aug 3 19:07:51 2009 UTC

#	Line 17 | Line 17 | import java.util.ConcurrentModificationE
17		import java.util.Iterator;
18		import java.util.NoSuchElementException;
19		import java.util.concurrent.*;
20	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
21		import junit.framework.Test;
22		import junit.framework.TestSuite;
23
#	Line 31 | Line 32 | public class LinkedTransferQueueTest ext
32		}
33
34		/**
35	<	* Constructor builds new queue with size being zero and empty being true
35	>	* Constructor builds new queue with size being zero and empty
36	>	* being true
37		*/
38		public void testConstructor1() {
39		assertEquals(0, new LinkedTransferQueue().size());
#	Line 39 | Line 41 | public class LinkedTransferQueueTest ext
41		}
42
43		/**
44	<	* Initializing constructor with null collection throws NullPointerException
44	>	* Initializing constructor with null collection throws
45	>	* NullPointerException
46		*/
47		public void testConstructor2() {
48		try {
#	Line 50 | Line 53 | public class LinkedTransferQueueTest ext
53		}
54
55		/**
56	<	* Initializing from Collection of null elements throws NullPointerException
56	>	* Initializing from Collection of null elements throws
57	>	* NullPointerException
58		*/
59		public void testConstructor3() {
60		try {
61		Integer[] ints = new Integer[SIZE];
62	<	LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
62	>	new LinkedTransferQueue(Arrays.asList(ints));
63		shouldThrow();
64		} catch (NullPointerException success) {
65		}
#	Line 71 | Line 75 | public class LinkedTransferQueueTest ext
75		for (int i = 0; i < SIZE - 1; ++i) {
76		ints[i] = i;
77		}
78	<	LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
78	>	new LinkedTransferQueue(Arrays.asList(ints));
79		shouldThrow();
80		} catch (NullPointerException success) {
81		}
#	Line 86 | Line 90 | public class LinkedTransferQueueTest ext
90		for (int i = 0; i < SIZE; ++i) {
91		ints[i] = i;
92		}
93	<	LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
93	>	LinkedTransferQueue q
94	>	= new LinkedTransferQueue(Arrays.asList(ints));
95		for (int i = 0; i < SIZE; ++i) {
96		assertEquals(ints[i], q.poll());
97		}
#	Line 173 | Line 178 | public class LinkedTransferQueueTest ext
178		}
179
180		/**
181	<	* addAll of a collection with any null elements throws NullPointerException after
182	<	* possibly adding some elements
181	>	* addAll of a collection with any null elements throws
182	>	* NullPointerException after possibly adding some elements
183		*/
184		public void testAddAll3() {
185		try {
#	Line 244 | Line 249 | public class LinkedTransferQueueTest ext
249		*/
250		public void testTakeFromEmpty() throws InterruptedException {
251		final LinkedTransferQueue q = new LinkedTransferQueue();
252	<	Thread t = new Thread(new Runnable() {
253	<	public void run() {
254	<	try {
250	<	q.take();
251	<	threadShouldThrow();
252	<	} catch (InterruptedException success) {
253	<	} catch (Throwable ex) {
254	<	threadUnexpectedException(ex);
255	<	}
252	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
253	>	void realRun() throws InterruptedException {
254	>	q.take();
255		}});
256		t.start();
257		Thread.sleep(SHORT_DELAY_MS);
#	Line 264 | Line 263 | public class LinkedTransferQueueTest ext
263		* Take removes existing elements until empty, then blocks interruptibly
264		*/
265		public void testBlockingTake() throws InterruptedException {
266	<	Thread t = new Thread(new Runnable() {
267	<	public void run() {
268	<	try {
269	<	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
270	<	for (int i = 0; i < SIZE; ++i) {
272	<	threadAssertEquals(i, (int) q.take());
273	<	}
274	<	q.take();
275	<	threadShouldThrow();
276	<	} catch (InterruptedException success) {
277	<	} catch (Throwable ex) {
278	<	threadUnexpectedException(ex);
266	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
267	>	void realRun() throws InterruptedException {
268	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
269	>	for (int i = 0; i < SIZE; ++i) {
270	>	threadAssertEquals(i, (int) q.take());
271		}
272	+	q.take();
273		}});
274		t.start();
275		Thread.sleep(SHORT_DELAY_MS);
#	Line 301 | Line 294 | public class LinkedTransferQueueTest ext
294		public void testTimedPoll0() throws InterruptedException {
295		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
296		for (int i = 0; i < SIZE; ++i) {
297	<	assertEquals(i, (int) q.poll(0, TimeUnit.MILLISECONDS));
297	>	assertEquals(i, (int) q.poll(0, MILLISECONDS));
298		}
299	<	assertNull(q.poll(0, TimeUnit.MILLISECONDS));
299	>	assertNull(q.poll(0, MILLISECONDS));
300		}
301
302		/**
#	Line 312 | Line 305 | public class LinkedTransferQueueTest ext
305		public void testTimedPoll() throws InterruptedException {
306		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
307		for (int i = 0; i < SIZE; ++i) {
308	<	assertEquals(i, (int) q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
308	>	assertEquals(i, (int) q.poll(SHORT_DELAY_MS, MILLISECONDS));
309		}
310	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
310	>	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
311		}
312
313		/**
#	Line 322 | Line 315 | public class LinkedTransferQueueTest ext
315		* returning timeout status
316		*/
317		public void testInterruptedTimedPoll() throws InterruptedException {
318	<	Thread t = new Thread(new Runnable() {
319	<	public void run() {
320	<	try {
321	<	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
322	<	for (int i = 0; i < SIZE; ++i) {
323	<	threadAssertEquals(i, (int) q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
331	<	}
332	<	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
333	<	} catch (InterruptedException success) {
334	<	} catch (Throwable ex) {
335	<	threadUnexpectedException(ex);
318	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
319	>	void realRun() throws InterruptedException {
320	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
321	>	for (int i = 0; i < SIZE; ++i) {
322	>	threadAssertEquals(i, (int) q.poll(SHORT_DELAY_MS,
323	>	MILLISECONDS));
324		}
325	+	q.poll(SHORT_DELAY_MS, MILLISECONDS);
326		}});
327		t.start();
328		Thread.sleep(SHORT_DELAY_MS);
#	Line 347 | Line 336 | public class LinkedTransferQueueTest ext
336		*/
337		public void testTimedPollWithOffer() throws InterruptedException {
338		final LinkedTransferQueue q = new LinkedTransferQueue();
339	<	Thread t = new Thread(new Runnable() {
340	<	public void run() {
341	<	try {
342	<	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
343	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
355	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
356	<	threadShouldThrow();
357	<	} catch (InterruptedException success) {
358	<	} catch (Throwable ex) {
359	<	threadUnexpectedException(ex);
360	<	}
339	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
340	>	void realRun() throws InterruptedException {
341	>	threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
342	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
343	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
344		}});
345		t.start();
346		Thread.sleep(SMALL_DELAY_MS);
347	<	assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
347	>	assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
348		t.interrupt();
349		t.join();
350		}
#	Line 482 | Line 465 | public class LinkedTransferQueueTest ext
465		}
466
467		/**
468	<	* retainAll(c) retains only those elements of c and reports true if changed
468	>	* retainAll(c) retains only those elements of c and reports true
469	>	* if changed
470		*/
471		public void testRetainAll() {
472		LinkedTransferQueue q = populatedQueue(SIZE);
#	Line 501 | Line 485 | public class LinkedTransferQueueTest ext
485		}
486
487		/**
488	<	* removeAll(c) removes only those elements of c and reports true if changed
488	>	* removeAll(c) removes only those elements of c and reports true
489	>	* if changed
490		*/
491		public void testRemoveAll() {
492		for (int i = 1; i < SIZE; ++i) {
#	Line 596 | Line 581 | public class LinkedTransferQueueTest ext
581		* iterator ordering is FIFO
582		*/
583		public void testIteratorOrdering() {
584	<	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
584	>	final LinkedTransferQueue<Integer> q
585	>	= new LinkedTransferQueue<Integer>();
586		assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
587		q.add(one);
588		q.add(two);
#	Line 643 | Line 629 | public class LinkedTransferQueueTest ext
629		q.add(one);
630		q.add(two);
631		ExecutorService executor = Executors.newFixedThreadPool(2);
632	<	executor.execute(new Runnable() {
633	<	public void run() {
634	<	try {
635	<	threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
636	<	} catch (Throwable ex) {
651	<	threadUnexpectedException(ex);
652	<	}
632	>
633	>	executor.execute(new CheckedRunnable() {
634	>	void realRun() {
635	>	threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS,
636	>	MILLISECONDS));
637		}});
638
639	<	executor.execute(new Runnable() {
640	<	public void run() {
641	<	try {
642	<	Thread.sleep(SMALL_DELAY_MS);
659	<	threadAssertEquals(one, q.take());
660	<	} catch (Throwable ex) {
661	<	threadUnexpectedException(ex);
662	<	}
639	>	executor.execute(new CheckedRunnable() {
640	>	void realRun() throws InterruptedException {
641	>	Thread.sleep(SMALL_DELAY_MS);
642	>	threadAssertEquals(one, q.take());
643		}});
644
645		joinPool(executor);
#	Line 671 | Line 651 | public class LinkedTransferQueueTest ext
651		public void testPollInExecutor() {
652		final LinkedTransferQueue q = new LinkedTransferQueue();
653		ExecutorService executor = Executors.newFixedThreadPool(2);
654	<	executor.execute(new Runnable() {
655	<	public void run() {
656	<	try {
657	<	threadAssertNull(q.poll());
658	<	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
659	<	threadAssertTrue(q.isEmpty());
660	<	} catch (Throwable  ex) {
681	<	threadUnexpectedException(ex);
682	<	}
654	>
655	>	executor.execute(new CheckedRunnable() {
656	>	void realRun() throws InterruptedException {
657	>	threadAssertNull(q.poll());
658	>	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS,
659	>	MILLISECONDS));
660	>	threadAssertTrue(q.isEmpty());
661		}});
662
663	<	executor.execute(new Runnable() {
664	<	public void run() {
665	<	try {
666	<	Thread.sleep(SMALL_DELAY_MS);
689	<	q.put(one);
690	<	} catch (Throwable ex) {
691	<	threadUnexpectedException(ex);
692	<	}
663	>	executor.execute(new CheckedRunnable() {
664	>	void realRun() throws InterruptedException {
665	>	Thread.sleep(SMALL_DELAY_MS);
666	>	q.put(one);
667		}});
668
669		joinPool(executor);
#	Line 702 | Line 676 | public class LinkedTransferQueueTest ext
676		LinkedTransferQueue q = populatedQueue(SIZE);
677
678		ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
679	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
679	>	ObjectOutputStream out
680	>	= new ObjectOutputStream(new BufferedOutputStream(bout));
681		out.writeObject(q);
682		out.close();
683
684	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
685	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
684	>	ByteArrayInputStream bin
685	>	= new ByteArrayInputStream(bout.toByteArray());
686	>	ObjectInputStream in
687	>	= new ObjectInputStream(new BufferedInputStream(bin));
688		LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
689
690		assertEquals(q.size(), r.size());
#	Line 771 | Line 748 | public class LinkedTransferQueueTest ext
748		*/
749		public void testDrainToWithActivePut() throws InterruptedException {
750		final LinkedTransferQueue q = populatedQueue(SIZE);
751	<	Thread t = new Thread(new Runnable() {
752	<	public void run() {
753	<	try {
777	<	q.put(SIZE + 1);
778	<	} catch (Throwable ex) {
779	<	threadUnexpectedException(ex);
780	<	}
751	>	Thread t = new Thread(new CheckedRunnable() {
752	>	void realRun() {
753	>	q.put(SIZE + 1);
754		}});
755		t.start();
756		ArrayList l = new ArrayList();
#	Line 842 | Line 815 | public class LinkedTransferQueueTest ext
815		public void testWaitingConsumer() throws InterruptedException {
816		final LinkedTransferQueue q = new LinkedTransferQueue();
817		final ConsumerObserver waiting = new ConsumerObserver();
818	<	new Thread(new Runnable() {
819	<	public void run() {
820	<	try {
821	<	threadAssertTrue(q.hasWaitingConsumer());
822	<	waiting.setWaitingConsumer(q.getWaitingConsumerCount());
850	<	threadAssertTrue(q.offer(new Object()));
851	<	} catch (Throwable ex) {
852	<	threadUnexpectedException(ex);
853	<	}
818	>	new Thread(new CheckedRunnable() {
819	>	void realRun() {
820	>	threadAssertTrue(q.hasWaitingConsumer());
821	>	waiting.setWaitingConsumer(q.getWaitingConsumerCount());
822	>	threadAssertTrue(q.offer(new Object()));
823		}}).start();
824	<	assertTrue(q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS) != null);
825	<	assertTrue(q.getWaitingConsumerCount() < waiting.getWaitingConsumers());
824	>	assertTrue(q.poll(LONG_DELAY_MS, MILLISECONDS) != null);
825	>	assertTrue(q.getWaitingConsumerCount()
826	>	< waiting.getWaitingConsumers());
827		}
828
829		/**
#	Line 873 | Line 843 | public class LinkedTransferQueueTest ext
843		* is returned by this associated poll.
844		*/
845		public void testTransfer2() throws InterruptedException {
846	<	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
846	>	final LinkedTransferQueue<Integer> q
847	>	= new LinkedTransferQueue<Integer>();
848
849	<	new Thread(new Runnable() {
850	<	public void run() {
851	<	try {
852	<	q.transfer(SIZE);
882	<	threadAssertTrue(q.isEmpty());
883	<	} catch (Throwable ex) {
884	<	threadUnexpectedException(ex);
885	<	}
849	>	new Thread(new CheckedRunnable() {
850	>	void realRun() throws InterruptedException {
851	>	q.transfer(SIZE);
852	>	threadAssertTrue(q.isEmpty());
853		}}).start();
854
855		Thread.sleep(SHORT_DELAY_MS);
#	Line 895 | Line 862 | public class LinkedTransferQueueTest ext
862		* transfer waits until a poll occurs, and then transfers in fifo order
863		*/
864		public void testTransfer3() throws InterruptedException {
865	<	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
865	>	final LinkedTransferQueue<Integer> q
866	>	= new LinkedTransferQueue<Integer>();
867
868	<	Thread first =
869	<	new Thread(new Runnable() {
870	<	public void run() {
871	<	try {
872	<	Integer i = SIZE + 1;
873	<	q.transfer(i);
874	<	threadAssertTrue(!q.contains(i));
907	<	threadAssertEquals(1, q.size());
908	<	} catch (Throwable ex) {
909	<	threadUnexpectedException(ex);
910	<	}
911	<	}});
868	>	Thread first = new Thread(new CheckedRunnable() {
869	>	void realRun() throws InterruptedException {
870	>	Integer i = SIZE + 1;
871	>	q.transfer(i);
872	>	threadAssertTrue(!q.contains(i));
873	>	threadAssertEquals(1, q.size());
874	>	}});
875		first.start();
876
877	<	Thread interruptedThread =
878	<	new Thread(new Runnable() {
879	<	public void run() {
880	<	try {
881	<	while (q.size() == 0)
882	<	Thread.yield();
920	<	q.transfer(SIZE);
921	<	threadShouldThrow();
922	<	} catch (InterruptedException success) {
923	<	} catch (Throwable ex) {
924	<	threadUnexpectedException(ex);
925	<	}
926	<	}});
877	>	Thread interruptedThread = new Thread(new CheckedInterruptedRunnable() {
878	>	void realRun() throws InterruptedException {
879	>	while (q.size() == 0)
880	>	Thread.yield();
881	>	q.transfer(SIZE);
882	>	}});
883		interruptedThread.start();
884
885		while (q.size() < 2)
#	Line 944 | Line 900 | public class LinkedTransferQueueTest ext
900		*/
901		public void testTransfer4() throws InterruptedException {
902		final LinkedTransferQueue q = new LinkedTransferQueue();
903	<	new Thread(new Runnable() {
904	<	public void run() {
905	<	try {
906	<	q.transfer(four);
907	<	threadAssertFalse(q.contains(four));
952	<	threadAssertEquals(three, q.poll());
953	<	} catch (Throwable ex) {
954	<	threadUnexpectedException(ex);
955	<	}
903	>	new Thread(new CheckedRunnable() {
904	>	void realRun() throws InterruptedException {
905	>	q.transfer(four);
906	>	threadAssertFalse(q.contains(four));
907	>	threadAssertEquals(three, q.poll());
908		}}).start();
909		Thread.sleep(MEDIUM_DELAY_MS);
910		assertTrue(q.offer(three));
#	Line 964 | Line 916 | public class LinkedTransferQueueTest ext
916		* is returned by this associated take.
917		*/
918		public void testTransfer5() throws InterruptedException {
919	<	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
919	>	final LinkedTransferQueue<Integer> q
920	>	= new LinkedTransferQueue<Integer>();
921
922	<	new Thread(new Runnable() {
923	<	public void run() {
924	<	try {
925	<	q.transfer(SIZE);
973	<	threadAssertTrue(q.isEmpty());
974	<	} catch (Throwable ex) {
975	<	threadUnexpectedException(ex);
976	<	}
922	>	new Thread(new CheckedRunnable() {
923	>	void realRun() throws InterruptedException {
924	>	q.transfer(SIZE);
925	>	threadAssertTrue(q.isEmpty());
926		}}).start();
927
928		Thread.sleep(SHORT_DELAY_MS);
#	Line 1012 | Line 961 | public class LinkedTransferQueueTest ext
961		public void testTryTransfer3() throws InterruptedException {
962		final Object hotPotato = new Object();
963		final LinkedTransferQueue q = new LinkedTransferQueue();
964	<	new Thread(new Runnable() {
965	<	public void run() {
966	<	try {
967	<	while (! q.hasWaitingConsumer())
968	<	Thread.yield();
969	<	threadAssertTrue(q.hasWaitingConsumer());
970	<	threadAssertTrue(q.isEmpty());
971	<	threadAssertTrue(q.size() == 0);
1023	<	threadAssertTrue(q.tryTransfer(hotPotato));
1024	<	} catch (Throwable ex) {
1025	<	threadUnexpectedException(ex);
1026	<	}
964	>	new Thread(new CheckedRunnable() {
965	>	void realRun() {
966	>	while (! q.hasWaitingConsumer())
967	>	Thread.yield();
968	>	threadAssertTrue(q.hasWaitingConsumer());
969	>	threadAssertTrue(q.isEmpty());
970	>	threadAssertTrue(q.size() == 0);
971	>	threadAssertTrue(q.tryTransfer(hotPotato));
972		}}).start();
973	<	assertTrue(q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS) == hotPotato);
973	>	assertTrue(q.poll(LONG_DELAY_MS, MILLISECONDS) == hotPotato);
974		assertTrue(q.isEmpty());
975		}
976
#	Line 1036 | Line 981 | public class LinkedTransferQueueTest ext
981		public void testTryTransfer4() throws InterruptedException {
982		final Object hotPotato = new Object();
983		final LinkedTransferQueue q = new LinkedTransferQueue();
984	<	new Thread(new Runnable() {
985	<	public void run() {
986	<	try {
987	<	while (! q.hasWaitingConsumer())
988	<	Thread.yield();
989	<	threadAssertTrue(q.hasWaitingConsumer());
990	<	threadAssertTrue(q.isEmpty());
991	<	threadAssertTrue(q.size() == 0);
1047	<	threadAssertTrue(q.tryTransfer(hotPotato));
1048	<	} catch (Throwable ex) {
1049	<	threadUnexpectedException(ex);
1050	<	}
984	>	new Thread(new CheckedRunnable() {
985	>	void realRun() {
986	>	while (! q.hasWaitingConsumer())
987	>	Thread.yield();
988	>	threadAssertTrue(q.hasWaitingConsumer());
989	>	threadAssertTrue(q.isEmpty());
990	>	threadAssertTrue(q.size() == 0);
991	>	threadAssertTrue(q.tryTransfer(hotPotato));
992		}}).start();
993		assertTrue(q.take() == hotPotato);
994		assertTrue(q.isEmpty());
#	Line 1059 | Line 1000 | public class LinkedTransferQueueTest ext
1000		*/
1001		public void testTryTransfer5() throws InterruptedException {
1002		final LinkedTransferQueue q = new LinkedTransferQueue();
1003	<	Thread toInterrupt = new Thread(new Runnable() {
1004	<	public void run() {
1005	<	try {
1065	<	q.tryTransfer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
1066	<	threadShouldThrow();
1067	<	} catch (InterruptedException success) {
1068	<	} catch (Throwable ex) {
1069	<	threadUnexpectedException(ex);
1070	<	}
1003	>	Thread toInterrupt = new Thread(new CheckedInterruptedRunnable() {
1004	>	void realRun() throws InterruptedException {
1005	>	q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1006		}});
1007		toInterrupt.start();
1008		Thread.sleep(SMALL_DELAY_MS);
#	Line 1079 | Line 1014 | public class LinkedTransferQueueTest ext
1014		*/
1015		public void testTryTransfer6() throws InterruptedException {
1016		final LinkedTransferQueue q = new LinkedTransferQueue();
1017	<	new Thread(new Runnable() {
1018	<	public void run() {
1019	<	try {
1020	<	threadAssertFalse(q.tryTransfer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1021	<	} catch (Throwable ex) {
1087	<	threadUnexpectedException(ex);
1088	<	}
1017	>	new Thread(new CheckedRunnable() {
1018	>	void realRun() throws InterruptedException {
1019	>	threadAssertFalse
1020	>	(q.tryTransfer(new Object(),
1021	>	SHORT_DELAY_MS, MILLISECONDS));
1022		}}).start();
1023		Thread.sleep(LONG_DELAY_MS);
1024		assertTrue(q.isEmpty());
#	Line 1098 | Line 1031 | public class LinkedTransferQueueTest ext
1031		public void testTryTransfer7() throws InterruptedException {
1032		final LinkedTransferQueue q = new LinkedTransferQueue();
1033		assertTrue(q.offer(four));
1034	<	new Thread(new Runnable() {
1035	<	public void run() {
1036	<	try {
1037	<	threadAssertTrue(q.tryTransfer(five, LONG_DELAY_MS, TimeUnit.MILLISECONDS));
1038	<	threadAssertTrue(q.isEmpty());
1106	<	} catch (Throwable ex) {
1107	<	threadUnexpectedException(ex);
1108	<	}
1034	>	new Thread(new CheckedRunnable() {
1035	>	void realRun() throws InterruptedException {
1036	>	threadAssertTrue(q.tryTransfer(five,
1037	>	LONG_DELAY_MS, MILLISECONDS));
1038	>	threadAssertTrue(q.isEmpty());
1039		}}).start();
1040		Thread.sleep(SHORT_DELAY_MS);
1041		assertEquals(2, q.size());
#	Line 1122 | Line 1052 | public class LinkedTransferQueueTest ext
1052		final LinkedTransferQueue q = new LinkedTransferQueue();
1053		assertTrue(q.offer(four));
1054		assertEquals(1, q.size());
1055	<	assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1055	>	assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, MILLISECONDS));
1056		assertEquals(1, q.size());
1057		assertEquals(four, q.poll());
1058		threadAssertTrue(q.isEmpty());

Diff Legend

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