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.25 by jsr166, Wed Oct 6 07:49:22 2010 UTC vs.
Revision 1.46 by jsr166, Fri May 27 20:07:24 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 John Vint
6		*/
7
#	Line 18 | Line 18 | import java.util.List;
18		import java.util.NoSuchElementException;
19		import java.util.concurrent.*;
20		import static java.util.concurrent.TimeUnit.MILLISECONDS;
21	+	import static java.util.concurrent.TimeUnit.NANOSECONDS;
22		import junit.framework.Test;
23		import junit.framework.TestSuite;
24
#	Line 39 | Line 40 | public class LinkedTransferQueueTest ext
40		new Generic().testSuite());
41		}
42
42	–	void checkEmpty(LinkedTransferQueue q) throws InterruptedException {
43	–	assertTrue(q.isEmpty());
44	–	assertEquals(0, q.size());
45	–	assertNull(q.peek());
46	–	assertNull(q.poll());
47	–	assertNull(q.poll(0, MILLISECONDS));
48	–	assertEquals(q.toString(), "[]");
49	–	assertTrue(Arrays.equals(q.toArray(), new Object[0]));
50	–	assertFalse(q.iterator().hasNext());
51	–	try {
52	–	q.element();
53	–	shouldThrow();
54	–	} catch (NoSuchElementException success) {}
55	–	try {
56	–	q.iterator().next();
57	–	shouldThrow();
58	–	} catch (NoSuchElementException success) {}
59	–	try {
60	–	q.remove();
61	–	shouldThrow();
62	–	} catch (NoSuchElementException success) {}
63	–	}
64	–
43		/**
44		* Constructor builds new queue with size being zero and empty
45		* being true
#	Line 273 | Line 251 | public class LinkedTransferQueueTest ext
251		}
252
253		/**
254	<	* take blocks interruptibly when empty
277	<	*/
278	<	public void testTakeFromEmpty() throws InterruptedException {
279	<	final LinkedTransferQueue q = new LinkedTransferQueue();
280	<	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
281	<	public void realRun() throws InterruptedException {
282	<	q.take();
283	<	}});
284	<	Thread.sleep(SHORT_DELAY_MS);
285	<	t.interrupt();
286	<	t.join();
287	<	}
288	<
289	<	/**
290	<	* Take removes existing elements until empty, then blocks interruptibly
254	>	* take removes existing elements until empty, then blocks interruptibly
255		*/
256		public void testBlockingTake() throws InterruptedException {
257	<	final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
258	<	Thread t = new Thread(new CheckedRunnable() {
257	>	final BlockingQueue q = populatedQueue(SIZE);
258	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
259	>	Thread t = newStartedThread(new CheckedRunnable() {
260		public void realRun() throws InterruptedException {
261		for (int i = 0; i < SIZE; ++i) {
262	<	assertEquals(i, (int) q.take());
262	>	assertEquals(i, q.take());
263		}
264	+
265	+	Thread.currentThread().interrupt();
266	+	try {
267	+	q.take();
268	+	shouldThrow();
269	+	} catch (InterruptedException success) {}
270	+	assertFalse(Thread.interrupted());
271	+
272	+	pleaseInterrupt.countDown();
273		try {
274		q.take();
275		shouldThrow();
276		} catch (InterruptedException success) {}
277	+	assertFalse(Thread.interrupted());
278		}});
279
280	<	t.start();
281	<	Thread.sleep(SHORT_DELAY_MS);
280	>	await(pleaseInterrupt);
281	>	assertThreadStaysAlive(t);
282		t.interrupt();
283	<	t.join();
309	<	checkEmpty(q);
283	>	awaitTermination(t);
284		}
285
286		/**
#	Line 322 | Line 296 | public class LinkedTransferQueueTest ext
296		}
297
298		/**
299	<	* timed pool with zero timeout succeeds when non-empty, else times out
299	>	* timed poll with zero timeout succeeds when non-empty, else times out
300		*/
301		public void testTimedPoll0() throws InterruptedException {
302		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
#	Line 334 | Line 308 | public class LinkedTransferQueueTest ext
308		}
309
310		/**
311	<	* timed pool with nonzero timeout succeeds when non-empty, else times out
311	>	* timed poll with nonzero timeout succeeds when non-empty, else times out
312		*/
313		public void testTimedPoll() throws InterruptedException {
314		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
315		for (int i = 0; i < SIZE; ++i) {
316	<	long t0 = System.nanoTime();
316	>	long startTime = System.nanoTime();
317		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
318	<	long millisElapsed = (System.nanoTime() - t0)/(1024 * 1024);
345	<	assertTrue(millisElapsed < SMALL_DELAY_MS);
318	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
319		}
320	<	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
320	>	long startTime = System.nanoTime();
321	>	assertNull(q.poll(timeoutMillis(), MILLISECONDS));
322	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
323		checkEmpty(q);
324		}
325
#	Line 353 | Line 328 | public class LinkedTransferQueueTest ext
328		* returning timeout status
329		*/
330		public void testInterruptedTimedPoll() throws InterruptedException {
331	<	final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
331	>	final BlockingQueue<Integer> q = populatedQueue(SIZE);
332	>	final CountDownLatch aboutToWait = new CountDownLatch(1);
333		Thread t = newStartedThread(new CheckedRunnable() {
334		public void realRun() throws InterruptedException {
335		for (int i = 0; i < SIZE; ++i) {
336		long t0 = System.nanoTime();
337		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
338	<	long millisElapsed = (System.nanoTime() - t0)/(1024 * 1024);
363	<	assertTrue(millisElapsed < SMALL_DELAY_MS);
338	>	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
339		}
340	+	long t0 = System.nanoTime();
341	+	aboutToWait.countDown();
342		try {
343	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
343	>	q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
344		shouldThrow();
345	<	} catch (InterruptedException success) {}
345	>	} catch (InterruptedException success) {
346	>	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
347	>	}
348		}});
349
350	<	Thread.sleep(SMALL_DELAY_MS);
350	>	aboutToWait.await();
351	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
352		t.interrupt();
353	<	t.join();
353	>	awaitTermination(t, MEDIUM_DELAY_MS);
354	>	checkEmpty(q);
355	>	}
356	>
357	>	/**
358	>	* timed poll after thread interrupted throws InterruptedException
359	>	* instead of returning timeout status
360	>	*/
361	>	public void testTimedPollAfterInterrupt() throws InterruptedException {
362	>	final BlockingQueue<Integer> q = populatedQueue(SIZE);
363	>	Thread t = newStartedThread(new CheckedRunnable() {
364	>	public void realRun() throws InterruptedException {
365	>	Thread.currentThread().interrupt();
366	>	for (int i = 0; i < SIZE; ++i) {
367	>	long t0 = System.nanoTime();
368	>	assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
369	>	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
370	>	}
371	>	try {
372	>	q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
373	>	shouldThrow();
374	>	} catch (InterruptedException success) {}
375	>	}});
376	>
377	>	awaitTermination(t, MEDIUM_DELAY_MS);
378		checkEmpty(q);
379		}
380
#	Line 425 | Line 429 | public class LinkedTransferQueueTest ext
429		*/
430		public void testRemoveElement() throws InterruptedException {
431		LinkedTransferQueue q = populatedQueue(SIZE);
432	<	for (int i = 1; i < SIZE; i += 2) {
432	>	for (int i = 1; i < SIZE; i+=2) {
433	>	assertTrue(q.contains(i));
434		assertTrue(q.remove(i));
435	+	assertFalse(q.contains(i));
436	+	assertTrue(q.contains(i-1));
437		}
438	<	for (int i = 0; i < SIZE; i += 2) {
438	>	for (int i = 0; i < SIZE; i+=2) {
439	>	assertTrue(q.contains(i));
440		assertTrue(q.remove(i));
441	<	assertFalse(q.remove(i + 1));
441	>	assertFalse(q.contains(i));
442	>	assertFalse(q.remove(i+1));
443	>	assertFalse(q.contains(i+1));
444		}
445		checkEmpty(q);
446		}
#	Line 527 | Line 537 | public class LinkedTransferQueueTest ext
537		}
538
539		/**
540	<	* toArray() contains all elements
540	>	* toArray() contains all elements in FIFO order
541		*/
542	<	public void testToArray() throws InterruptedException {
542	>	public void testToArray() {
543		LinkedTransferQueue q = populatedQueue(SIZE);
544		Object[] o = q.toArray();
545		for (int i = 0; i < o.length; i++) {
546	<	assertEquals(o[i], q.take());
546	>	assertSame(o[i], q.poll());
547		}
548		}
549
550		/**
551	<	* toArray(a) contains all elements
551	>	* toArray(a) contains all elements in FIFO order
552		*/
553	<	public void testToArray2() throws InterruptedException {
553	>	public void testToArray2() {
554		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
555		Integer[] ints = new Integer[SIZE];
556	<	ints = q.toArray(ints);
556	>	Integer[] array = q.toArray(ints);
557	>	assertSame(ints, array);
558		for (int i = 0; i < ints.length; i++) {
559	<	assertEquals(ints[i], q.take());
559	>	assertSame(ints[i], q.poll());
560		}
561		}
562
563		/**
564		* toArray(null) throws NullPointerException
565		*/
566	<	public void testToArray_BadArg() {
566	>	public void testToArray_NullArg() {
567		LinkedTransferQueue q = populatedQueue(SIZE);
568		try {
569	<	Object o[] = q.toArray(null);
569	>	q.toArray(null);
570		shouldThrow();
571		} catch (NullPointerException success) {}
572		}
573
574		/**
575	<	* toArray(incompatible array type) throws CCE
575	>	* toArray(incompatible array type) throws ArrayStoreException
576		*/
577		public void testToArray1_BadArg() {
578		LinkedTransferQueue q = populatedQueue(SIZE);
579		try {
580	<	Object o[] = q.toArray(new String[10]);
580	>	q.toArray(new String[10]);
581		shouldThrow();
582		} catch (ArrayStoreException success) {}
583		}
#	Line 643 | Line 654 | public class LinkedTransferQueueTest ext
654		LinkedTransferQueue q = populatedQueue(SIZE);
655		String s = q.toString();
656		for (int i = 0; i < SIZE; ++i) {
657	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
657	>	assertTrue(s.contains(String.valueOf(i)));
658		}
659		}
660
#	Line 652 | Line 663 | public class LinkedTransferQueueTest ext
663		*/
664		public void testOfferInExecutor() {
665		final LinkedTransferQueue q = new LinkedTransferQueue();
666	<	q.add(one);
656	<	q.add(two);
666	>	final CheckedBarrier threadsStarted = new CheckedBarrier(2);
667		ExecutorService executor = Executors.newFixedThreadPool(2);
668
669		executor.execute(new CheckedRunnable() {
670	<	public void realRun() {
671	<	assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
670	>	public void realRun() throws InterruptedException {
671	>	threadsStarted.await();
672	>	assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
673		}});
674
675		executor.execute(new CheckedRunnable() {
676		public void realRun() throws InterruptedException {
677	<	Thread.sleep(SMALL_DELAY_MS);
677	>	threadsStarted.await();
678		assertSame(one, q.take());
679	+	checkEmpty(q);
680		}});
681
682		joinPool(executor);
#	Line 675 | Line 687 | public class LinkedTransferQueueTest ext
687		*/
688		public void testPollInExecutor() {
689		final LinkedTransferQueue q = new LinkedTransferQueue();
690	+	final CheckedBarrier threadsStarted = new CheckedBarrier(2);
691		ExecutorService executor = Executors.newFixedThreadPool(2);
692
693		executor.execute(new CheckedRunnable() {
694		public void realRun() throws InterruptedException {
695		assertNull(q.poll());
696	<	assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
697	<	assertTrue(q.isEmpty());
696	>	threadsStarted.await();
697	>	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
698	>	checkEmpty(q);
699		}});
700
701		executor.execute(new CheckedRunnable() {
702		public void realRun() throws InterruptedException {
703	<	Thread.sleep(SMALL_DELAY_MS);
703	>	threadsStarted.await();
704		q.put(one);
705		}});
706
#	Line 712 | Line 726 | public class LinkedTransferQueueTest ext
726		LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
727
728		assertEquals(q.size(), r.size());
729	+	assertEquals(q.toString(), r.toString());
730	+	assertTrue(Arrays.equals(q.toArray(), r.toArray()));
731		while (!q.isEmpty()) {
732		assertEquals(q.remove(), r.remove());
733		}
#	Line 780 | Line 796 | public class LinkedTransferQueueTest ext
796		for (int i = 0; i < SIZE; ++i) {
797		assertEquals(l.get(i), i);
798		}
799	<	t.join();
799	>	awaitTermination(t, MEDIUM_DELAY_MS);
800		assertTrue(q.size() + l.size() >= SIZE);
801		}
802
#	Line 807 | Line 823 | public class LinkedTransferQueueTest ext
823		}
824
825		/**
826	<	* drainTo(c, n) empties first max {n, size} elements of queue into c
826	>	* drainTo(c, n) empties first min(n, size) elements of queue into c
827		*/
828		public void testDrainToN() {
829		LinkedTransferQueue q = new LinkedTransferQueue();
#	Line 836 | Line 852 | public class LinkedTransferQueueTest ext
852		final LinkedTransferQueue q = new LinkedTransferQueue();
853		assertEquals(q.getWaitingConsumerCount(), 0);
854		assertFalse(q.hasWaitingConsumer());
855	+	final CountDownLatch threadStarted = new CountDownLatch(1);
856
857		Thread t = newStartedThread(new CheckedRunnable() {
858		public void realRun() throws InterruptedException {
859	<	Thread.sleep(SMALL_DELAY_MS);
860	<	assertTrue(q.hasWaitingConsumer());
844	<	assertEquals(q.getWaitingConsumerCount(), 1);
845	<	assertTrue(q.offer(one));
846	<	assertFalse(q.hasWaitingConsumer());
859	>	threadStarted.countDown();
860	>	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
861		assertEquals(q.getWaitingConsumerCount(), 0);
862	+	assertFalse(q.hasWaitingConsumer());
863		}});
864
865	<	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
865	>	threadStarted.await();
866	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
867	>	assertEquals(q.getWaitingConsumerCount(), 1);
868	>	assertTrue(q.hasWaitingConsumer());
869	>
870	>	assertTrue(q.offer(one));
871		assertEquals(q.getWaitingConsumerCount(), 0);
872		assertFalse(q.hasWaitingConsumer());
873	<	t.join();
873	>
874	>	awaitTermination(t, MEDIUM_DELAY_MS);
875		}
876
877		/**
#	Line 871 | Line 892 | public class LinkedTransferQueueTest ext
892		public void testTransfer2() throws InterruptedException {
893		final LinkedTransferQueue<Integer> q
894		= new LinkedTransferQueue<Integer>();
895	+	final CountDownLatch threadStarted = new CountDownLatch(1);
896
897		Thread t = newStartedThread(new CheckedRunnable() {
898		public void realRun() throws InterruptedException {
899	<	q.transfer(SIZE);
900	<	assertTrue(q.isEmpty());
899	>	threadStarted.countDown();
900	>	q.transfer(five);
901	>	checkEmpty(q);
902		}});
903
904	<	Thread.sleep(SHORT_DELAY_MS);
904	>	threadStarted.await();
905	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
906		assertEquals(1, q.size());
907	<	assertEquals(SIZE, (int) q.poll());
908	<	assertTrue(q.isEmpty());
909	<	t.join();
907	>	assertSame(five, q.poll());
908	>	checkEmpty(q);
909	>	awaitTermination(t, MEDIUM_DELAY_MS);
910		}
911
912		/**
#	Line 894 | Line 918 | public class LinkedTransferQueueTest ext
918
919		Thread first = newStartedThread(new CheckedRunnable() {
920		public void realRun() throws InterruptedException {
921	<	Integer i = SIZE + 1;
922	<	q.transfer(i);
899	<	assertTrue(!q.contains(i));
921	>	q.transfer(four);
922	>	assertTrue(!q.contains(four));
923		assertEquals(1, q.size());
924		}});
925
926		Thread interruptedThread = newStartedThread(
927		new CheckedInterruptedRunnable() {
928		public void realRun() throws InterruptedException {
929	<	while (q.size() == 0)
929	>	while (q.isEmpty())
930		Thread.yield();
931	<	q.transfer(SIZE);
931	>	q.transfer(five);
932		}});
933
934		while (q.size() < 2)
935		Thread.yield();
936		assertEquals(2, q.size());
937	<	assertEquals(SIZE + 1, (int) q.poll());
937	>	assertSame(four, q.poll());
938		first.join();
939		assertEquals(1, q.size());
940		interruptedThread.interrupt();
941		interruptedThread.join();
942	<	assertEquals(0, q.size());
920	<	assertTrue(q.isEmpty());
942	>	checkEmpty(q);
943		}
944
945		/**
#	Line 934 | Line 956 | public class LinkedTransferQueueTest ext
956		assertSame(three, q.poll());
957		}});
958
959	<	Thread.sleep(SHORT_DELAY_MS);
959	>	while (q.isEmpty())
960	>	Thread.yield();
961	>	assertFalse(q.isEmpty());
962	>	assertEquals(1, q.size());
963		assertTrue(q.offer(three));
964		assertSame(four, q.poll());
965	<	t.join();
965	>	awaitTermination(t, MEDIUM_DELAY_MS);
966		}
967
968		/**
#	Line 950 | Line 975 | public class LinkedTransferQueueTest ext
975
976		Thread t = newStartedThread(new CheckedRunnable() {
977		public void realRun() throws InterruptedException {
978	<	q.transfer(SIZE);
978	>	q.transfer(four);
979		checkEmpty(q);
980		}});
981
982	<	Thread.sleep(SHORT_DELAY_MS);
983	<	assertEquals(SIZE, (int) q.take());
982	>	while (q.isEmpty())
983	>	Thread.yield();
984	>	assertFalse(q.isEmpty());
985	>	assertEquals(1, q.size());
986	>	assertSame(four, q.take());
987		checkEmpty(q);
988	<	t.join();
988	>	awaitTermination(t, MEDIUM_DELAY_MS);
989		}
990
991		/**
#	Line 995 | Line 1023 | public class LinkedTransferQueueTest ext
1023		while (! q.hasWaitingConsumer())
1024		Thread.yield();
1025		assertTrue(q.hasWaitingConsumer());
1026	<	assertTrue(q.isEmpty());
999	<	assertEquals(q.size(), 0);
1026	>	checkEmpty(q);
1027		assertTrue(q.tryTransfer(hotPotato));
1028		}});
1029
1030		assertSame(hotPotato, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
1031		checkEmpty(q);
1032	<	t.join();
1032	>	awaitTermination(t, MEDIUM_DELAY_MS);
1033		}
1034
1035		/**
#	Line 1018 | Line 1045 | public class LinkedTransferQueueTest ext
1045		while (! q.hasWaitingConsumer())
1046		Thread.yield();
1047		assertTrue(q.hasWaitingConsumer());
1048	<	assertTrue(q.isEmpty());
1022	<	assertEquals(q.size(), 0);
1048	>	checkEmpty(q);
1049		assertTrue(q.tryTransfer(hotPotato));
1050		}});
1051
1052		assertSame(q.take(), hotPotato);
1053		checkEmpty(q);
1054	<	t.join();
1054	>	awaitTermination(t, MEDIUM_DELAY_MS);
1055		}
1056
1057		/**
1058	<	* tryTransfer waits the amount given if interrupted, and
1033	<	* throws interrupted exception
1058	>	* tryTransfer blocks interruptibly if no takers
1059		*/
1060		public void testTryTransfer5() throws InterruptedException {
1061		final LinkedTransferQueue q = new LinkedTransferQueue();
1062	+	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1063	+	assertTrue(q.isEmpty());
1064
1065	<	Thread toInterrupt = newStartedThread(new CheckedInterruptedRunnable() {
1065	>	Thread t = newStartedThread(new CheckedRunnable() {
1066		public void realRun() throws InterruptedException {
1067	<	q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1067	>	Thread.currentThread().interrupt();
1068	>	try {
1069	>	q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1070	>	shouldThrow();
1071	>	} catch (InterruptedException success) {}
1072	>	assertFalse(Thread.interrupted());
1073	>
1074	>	pleaseInterrupt.countDown();
1075	>	try {
1076	>	q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1077	>	shouldThrow();
1078	>	} catch (InterruptedException success) {}
1079	>	assertFalse(Thread.interrupted());
1080		}});
1081
1082	<	Thread.sleep(SMALL_DELAY_MS);
1083	<	toInterrupt.interrupt();
1084	<	toInterrupt.join();
1082	>	await(pleaseInterrupt);
1083	>	assertThreadStaysAlive(t);
1084	>	t.interrupt();
1085	>	awaitTermination(t);
1086	>	checkEmpty(q);
1087		}
1088
1089		/**
1090	<	* tryTransfer gives up after the timeout and return false
1090	>	* tryTransfer gives up after the timeout and returns false
1091		*/
1092		public void testTryTransfer6() throws InterruptedException {
1093		final LinkedTransferQueue q = new LinkedTransferQueue();
1094
1095		Thread t = newStartedThread(new CheckedRunnable() {
1096		public void realRun() throws InterruptedException {
1097	+	long t0 = System.nanoTime();
1098		assertFalse(q.tryTransfer(new Object(),
1099	<	SHORT_DELAY_MS, MILLISECONDS));
1099	>	timeoutMillis(), MILLISECONDS));
1100	>	assertTrue(millisElapsedSince(t0) >= timeoutMillis());
1101	>	checkEmpty(q);
1102		}});
1103
1104	<	Thread.sleep(SMALL_DELAY_MS);
1104	>	awaitTermination(t);
1105		checkEmpty(q);
1062	–	t.join();
1106		}
1107
1108		/**
#	Line 1073 | Line 1116 | public class LinkedTransferQueueTest ext
1116		Thread t = newStartedThread(new CheckedRunnable() {
1117		public void realRun() throws InterruptedException {
1118		assertTrue(q.tryTransfer(five, MEDIUM_DELAY_MS, MILLISECONDS));
1119	<	assertTrue(q.isEmpty());
1119	>	checkEmpty(q);
1120		}});
1121
1122	<	Thread.sleep(SHORT_DELAY_MS);
1122	>	while (q.size() != 2)
1123	>	Thread.yield();
1124		assertEquals(2, q.size());
1125		assertSame(four, q.poll());
1126		assertSame(five, q.poll());
1127		checkEmpty(q);
1128	<	t.join();
1128	>	awaitTermination(t, MEDIUM_DELAY_MS);
1129		}
1130
1131		/**
1132	<	* tryTransfer attempts to enqueue into the q and fails returning
1133	<	* false not enqueueing and the successive poll is null
1132	>	* tryTransfer attempts to enqueue into the queue and fails
1133	>	* returning false not enqueueing and the successive poll is null
1134		*/
1135		public void testTryTransfer8() throws InterruptedException {
1136		final LinkedTransferQueue q = new LinkedTransferQueue();
1137		assertTrue(q.offer(four));
1138		assertEquals(1, q.size());
1139	<	assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, MILLISECONDS));
1139	>	long t0 = System.nanoTime();
1140	>	assertFalse(q.tryTransfer(five, timeoutMillis(), MILLISECONDS));
1141	>	assertTrue(millisElapsedSince(t0) >= timeoutMillis());
1142		assertEquals(1, q.size());
1143		assertSame(four, q.poll());
1144		assertNull(q.poll());
#	Line 1101 | Line 1147 | public class LinkedTransferQueueTest ext
1147
1148		private LinkedTransferQueue<Integer> populatedQueue(int n) {
1149		LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1150	<	assertTrue(q.isEmpty());
1150	>	checkEmpty(q);
1151		for (int i = 0; i < n; i++) {
1152		assertEquals(i, q.size());
1153		assertTrue(q.offer(i));

Diff Legend

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