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.50 by jsr166, Sat Nov 26 05:19:17 2011 UTC vs.
Revision 1.64 by jsr166, Tue Oct 6 00:03:55 2015 UTC

#	Line 5 | Line 5
5		* Other contributors include John Vint
6		*/
7
8	<	import junit.framework.*;
9	<	import java.util.Arrays;
8	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
9	>
10		import java.util.ArrayList;
11	+	import java.util.Arrays;
12		import java.util.Collection;
13		import java.util.Iterator;
14		import java.util.List;
#	Line 18 | Line 19 | import java.util.concurrent.CountDownLat
19		import java.util.concurrent.Executors;
20		import java.util.concurrent.ExecutorService;
21		import java.util.concurrent.LinkedTransferQueue;
22	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
23	<	import static java.util.concurrent.TimeUnit.NANOSECONDS;
22	>
23	>	import junit.framework.Test;
24
25		@SuppressWarnings({"unchecked", "rawtypes"})
26		public class LinkedTransferQueueTest extends JSR166TestCase {
27	+	static class Implementation implements CollectionImplementation {
28	+	public Class<?> klazz() { return LinkedTransferQueue.class; }
29	+	public Collection emptyCollection() { return new LinkedTransferQueue(); }
30	+	public Object makeElement(int i) { return i; }
31	+	public boolean isConcurrent() { return true; }
32	+	public boolean permitsNulls() { return false; }
33	+	}
34
35		public static class Generic extends BlockingQueueTest {
36		protected BlockingQueue emptyCollection() {
#	Line 31 | Line 39 | public class LinkedTransferQueueTest ext
39		}
40
41		public static void main(String[] args) {
42	<	junit.textui.TestRunner.run(suite());
42	>	main(suite(), args);
43		}
44
45		public static Test suite() {
46		return newTestSuite(LinkedTransferQueueTest.class,
47	<	new Generic().testSuite());
47	>	new Generic().testSuite(),
48	>	CollectionTest.testSuite(new Implementation()));
49		}
50
51		/**
#	Line 77 | Line 86 | public class LinkedTransferQueueTest ext
86		*/
87		public void testConstructor4() {
88		Integer[] ints = new Integer[SIZE];
89	<	for (int i = 0; i < SIZE-1; ++i)
89	>	for (int i = 0; i < SIZE - 1; ++i)
90		ints[i] = i;
91		Collection<Integer> elements = Arrays.asList(ints);
92		try {
#	Line 114 | Line 123 | public class LinkedTransferQueueTest ext
123		* remainingCapacity() always returns Integer.MAX_VALUE
124		*/
125		public void testRemainingCapacity() {
126	<	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
126	>	BlockingQueue q = populatedQueue(SIZE);
127		for (int i = 0; i < SIZE; ++i) {
128		assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
129		assertEquals(SIZE - i, q.size());
130	<	q.remove();
130	>	assertEquals(i, q.remove());
131		}
132		for (int i = 0; i < SIZE; ++i) {
133		assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
134		assertEquals(i, q.size());
135	<	q.add(i);
135	>	assertTrue(q.add(i));
136		}
137		}
138
#	Line 131 | Line 140 | public class LinkedTransferQueueTest ext
140		* addAll(this) throws IllegalArgumentException
141		*/
142		public void testAddAllSelf() {
143	+	LinkedTransferQueue q = populatedQueue(SIZE);
144		try {
135	–	LinkedTransferQueue q = populatedQueue(SIZE);
145		q.addAll(q);
146		shouldThrow();
147		} catch (IllegalArgumentException success) {}
#	Line 143 | Line 152 | public class LinkedTransferQueueTest ext
152		* NullPointerException after possibly adding some elements
153		*/
154		public void testAddAll3() {
155	+	LinkedTransferQueue q = new LinkedTransferQueue();
156	+	Integer[] ints = new Integer[SIZE];
157	+	for (int i = 0; i < SIZE - 1; ++i)
158	+	ints[i] = i;
159		try {
147	–	LinkedTransferQueue q = new LinkedTransferQueue();
148	–	Integer[] ints = new Integer[SIZE];
149	–	for (int i = 0; i < SIZE - 1; ++i) {
150	–	ints[i] = i;
151	–	}
160		q.addAll(Arrays.asList(ints));
161		shouldThrow();
162		} catch (NullPointerException success) {}
#	Line 177 | Line 185 | public class LinkedTransferQueueTest ext
185		public void testPut() {
186		LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
187		for (int i = 0; i < SIZE; ++i) {
188	<	assertEquals(q.size(), i);
188	>	assertEquals(i, q.size());
189		q.put(i);
190		assertTrue(q.contains(i));
191		}
#	Line 275 | Line 283 | public class LinkedTransferQueueTest ext
283		final CountDownLatch aboutToWait = new CountDownLatch(1);
284		Thread t = newStartedThread(new CheckedRunnable() {
285		public void realRun() throws InterruptedException {
286	+	long startTime = System.nanoTime();
287		for (int i = 0; i < SIZE; ++i) {
279	–	long t0 = System.nanoTime();
288		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
281	–	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
289		}
283	–	long t0 = System.nanoTime();
290		aboutToWait.countDown();
291		try {
292	<	q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
292	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
293		shouldThrow();
294		} catch (InterruptedException success) {
295	<	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
295	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
296		}
297		}});
298
299		aboutToWait.await();
300	<	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
300	>	waitForThreadToEnterWaitState(t, LONG_DELAY_MS);
301		t.interrupt();
302	<	awaitTermination(t, MEDIUM_DELAY_MS);
302	>	awaitTermination(t);
303		checkEmpty(q);
304		}
305
#	Line 499 | Line 505 | public class LinkedTransferQueueTest ext
505		public void testIterator() throws InterruptedException {
506		LinkedTransferQueue q = populatedQueue(SIZE);
507		Iterator it = q.iterator();
508	<	int i = 0;
509	<	while (it.hasNext()) {
510	<	assertEquals(it.next(), i++);
511	<	}
508	>	int i;
509	>	for (i = 0; it.hasNext(); i++)
510	>	assertTrue(q.contains(it.next()));
511	>	assertEquals(i, SIZE);
512	>	assertIteratorExhausted(it);
513	>
514	>	it = q.iterator();
515	>	for (i = 0; it.hasNext(); i++)
516	>	assertEquals(it.next(), q.take());
517		assertEquals(i, SIZE);
518	+	assertIteratorExhausted(it);
519	+	}
520	+
521	+	/**
522	+	* iterator of empty collection has no elements
523	+	*/
524	+	public void testEmptyIterator() {
525	+	assertIteratorExhausted(new LinkedTransferQueue().iterator());
526		}
527
528		/**
#	Line 575 | Line 594 | public class LinkedTransferQueueTest ext
594		public void testOfferInExecutor() {
595		final LinkedTransferQueue q = new LinkedTransferQueue();
596		final CheckedBarrier threadsStarted = new CheckedBarrier(2);
597	<	ExecutorService executor = Executors.newFixedThreadPool(2);
597	>	final ExecutorService executor = Executors.newFixedThreadPool(2);
598	>	try (PoolCleaner cleaner = cleaner(executor)) {
599
600	<	executor.execute(new CheckedRunnable() {
601	<	public void realRun() throws InterruptedException {
602	<	threadsStarted.await();
603	<	assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
604	<	}});
585	<
586	<	executor.execute(new CheckedRunnable() {
587	<	public void realRun() throws InterruptedException {
588	<	threadsStarted.await();
589	<	assertSame(one, q.take());
590	<	checkEmpty(q);
591	<	}});
600	>	executor.execute(new CheckedRunnable() {
601	>	public void realRun() throws InterruptedException {
602	>	threadsStarted.await();
603	>	assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
604	>	}});
605
606	<	joinPool(executor);
606	>	executor.execute(new CheckedRunnable() {
607	>	public void realRun() throws InterruptedException {
608	>	threadsStarted.await();
609	>	assertSame(one, q.take());
610	>	checkEmpty(q);
611	>	}});
612	>	}
613		}
614
615		/**
#	Line 599 | Line 618 | public class LinkedTransferQueueTest ext
618		public void testPollInExecutor() {
619		final LinkedTransferQueue q = new LinkedTransferQueue();
620		final CheckedBarrier threadsStarted = new CheckedBarrier(2);
621	<	ExecutorService executor = Executors.newFixedThreadPool(2);
622	<
604	<	executor.execute(new CheckedRunnable() {
605	<	public void realRun() throws InterruptedException {
606	<	assertNull(q.poll());
607	<	threadsStarted.await();
608	<	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
609	<	checkEmpty(q);
610	<	}});
621	>	final ExecutorService executor = Executors.newFixedThreadPool(2);
622	>	try (PoolCleaner cleaner = cleaner(executor)) {
623
624	<	executor.execute(new CheckedRunnable() {
625	<	public void realRun() throws InterruptedException {
626	<	threadsStarted.await();
627	<	q.put(one);
628	<	}});
624	>	executor.execute(new CheckedRunnable() {
625	>	public void realRun() throws InterruptedException {
626	>	assertNull(q.poll());
627	>	threadsStarted.await();
628	>	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
629	>	checkEmpty(q);
630	>	}});
631
632	<	joinPool(executor);
632	>	executor.execute(new CheckedRunnable() {
633	>	public void realRun() throws InterruptedException {
634	>	threadsStarted.await();
635	>	q.put(one);
636	>	}});
637	>	}
638		}
639
640		/**
#	Line 625 | Line 644 | public class LinkedTransferQueueTest ext
644		Queue x = populatedQueue(SIZE);
645		Queue y = serialClone(x);
646
647	<	assertTrue(x != y);
647	>	assertNotSame(y, x);
648		assertEquals(x.size(), y.size());
649		assertEquals(x.toString(), y.toString());
650		assertTrue(Arrays.equals(x.toArray(), y.toArray()));
#	Line 646 | Line 665 | public class LinkedTransferQueueTest ext
665		assertEquals(0, q.size());
666		assertEquals(SIZE, l.size());
667		for (int i = 0; i < SIZE; ++i) {
668	<	assertEquals(l.get(i), i);
668	>	assertEquals(i, l.get(i));
669		}
670		q.add(zero);
671		q.add(one);
#	Line 658 | Line 677 | public class LinkedTransferQueueTest ext
677		assertEquals(0, q.size());
678		assertEquals(2, l.size());
679		for (int i = 0; i < 2; ++i) {
680	<	assertEquals(l.get(i), i);
680	>	assertEquals(i, l.get(i));
681		}
682		}
683
#	Line 674 | Line 693 | public class LinkedTransferQueueTest ext
693		ArrayList l = new ArrayList();
694		q.drainTo(l);
695		assertTrue(l.size() >= SIZE);
696	<	for (int i = 0; i < SIZE; ++i) {
697	<	assertEquals(l.get(i), i);
679	<	}
696	>	for (int i = 0; i < SIZE; ++i)
697	>	assertEquals(i, l.get(i));
698		awaitTermination(t, MEDIUM_DELAY_MS);
699		assertTrue(q.size() + l.size() >= SIZE);
700		}
#	Line 693 | Line 711 | public class LinkedTransferQueueTest ext
711		ArrayList l = new ArrayList();
712		q.drainTo(l, i);
713		int k = (i < SIZE) ? i : SIZE;
714	<	assertEquals(l.size(), k);
715	<	assertEquals(q.size(), SIZE - k);
716	<	for (int j = 0; j < k; ++j) {
717	<	assertEquals(l.get(j), j);
718	<	}
701	<	while (q.poll() != null)
702	<	;
714	>	assertEquals(k, l.size());
715	>	assertEquals(SIZE - k, q.size());
716	>	for (int j = 0; j < k; ++j)
717	>	assertEquals(j, l.get(j));
718	>	do {} while (q.poll() != null);
719		}
720		}
721
#	Line 851 | Line 867 | public class LinkedTransferQueueTest ext
867		* tryTransfer(null) throws NullPointerException
868		*/
869		public void testTryTransfer1() {
870	+	final LinkedTransferQueue q = new LinkedTransferQueue();
871		try {
855	–	final LinkedTransferQueue q = new LinkedTransferQueue();
872		q.tryTransfer(null);
873		shouldThrow();
874		} catch (NullPointerException success) {}
#	Line 1015 | Line 1031 | public class LinkedTransferQueueTest ext
1031		assertFalse(q.isEmpty());
1032		return q;
1033		}
1034	+
1035	+	/**
1036	+	* remove(null), contains(null) always return false
1037	+	*/
1038	+	public void testNeverContainsNull() {
1039	+	Collection<?>[] qs = {
1040	+	new LinkedTransferQueue<Object>(),
1041	+	populatedQueue(2),
1042	+	};
1043	+
1044	+	for (Collection<?> q : qs) {
1045	+	assertFalse(q.contains(null));
1046	+	assertFalse(q.remove(null));
1047	+	}
1048	+	}
1049		}

Diff Legend

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