ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/SynchronousQueueTest.java

Comparing jsr166/src/test/tck/SynchronousQueueTest.java (file contents):
Revision 1.40 by jsr166, Thu Dec 8 19:05:42 2011 UTC vs.
Revision 1.68 by dl, Tue Jan 26 13:33:06 2021 UTC

#	Line 6 | Line 6
6		* Pat Fisher, Mike Judd.
7		*/
8
9	<	import junit.framework.*;
10	<	import java.util.Arrays;
9	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
10	>
11		import java.util.ArrayList;
12	+	import java.util.Arrays;
13		import java.util.Collection;
14		import java.util.Iterator;
15		import java.util.NoSuchElementException;
15	–	import java.util.Queue;
16		import java.util.concurrent.BlockingQueue;
17		import java.util.concurrent.CountDownLatch;
18		import java.util.concurrent.Executors;
19		import java.util.concurrent.ExecutorService;
20		import java.util.concurrent.SynchronousQueue;
21	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
21	>
22	>	import junit.framework.Test;
23
24		public class SynchronousQueueTest extends JSR166TestCase {
25
#	Line 35 | Line 36 | public class SynchronousQueueTest extend
36		}
37
38		public static void main(String[] args) {
39	<	junit.textui.TestRunner.run(suite());
39	>	main(suite(), args);
40		}
41
42		public static Test suite() {
#	Line 50 | Line 51 | public class SynchronousQueueTest extend
51		public void testEmptyFull()      { testEmptyFull(false); }
52		public void testEmptyFull_fair() { testEmptyFull(true); }
53		public void testEmptyFull(boolean fair) {
54	<	final SynchronousQueue q = new SynchronousQueue(fair);
54	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
55		assertTrue(q.isEmpty());
56	<	assertEquals(0, q.size());
57	<	assertEquals(0, q.remainingCapacity());
56	>	mustEqual(0, q.size());
57	>	mustEqual(0, q.remainingCapacity());
58		assertFalse(q.offer(zero));
59		}
60
#	Line 63 | Line 64 | public class SynchronousQueueTest extend
64		public void testOffer()      { testOffer(false); }
65		public void testOffer_fair() { testOffer(true); }
66		public void testOffer(boolean fair) {
67	<	SynchronousQueue q = new SynchronousQueue(fair);
67	>	SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
68		assertFalse(q.offer(one));
69		}
70
#	Line 73 | Line 74 | public class SynchronousQueueTest extend
74		public void testAdd()      { testAdd(false); }
75		public void testAdd_fair() { testAdd(true); }
76		public void testAdd(boolean fair) {
77	<	SynchronousQueue q = new SynchronousQueue(fair);
78	<	assertEquals(0, q.remainingCapacity());
77	>	SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
78	>	mustEqual(0, q.remainingCapacity());
79		try {
80		q.add(one);
81		shouldThrow();
#	Line 87 | Line 88 | public class SynchronousQueueTest extend
88		public void testAddAll_self()      { testAddAll_self(false); }
89		public void testAddAll_self_fair() { testAddAll_self(true); }
90		public void testAddAll_self(boolean fair) {
91	<	SynchronousQueue q = new SynchronousQueue(fair);
91	>	SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
92		try {
93		q.addAll(q);
94		shouldThrow();
95		} catch (IllegalArgumentException success) {}
96		}
97
98	<	/**
99	<	* addAll throws ISE if no active taker
98	>	/**S
99	>	* addAll throws IllegalStateException if no active taker
100		*/
101		public void testAddAll_ISE()      { testAddAll_ISE(false); }
102		public void testAddAll_ISE_fair() { testAddAll_ISE(true); }
103		public void testAddAll_ISE(boolean fair) {
104	<	SynchronousQueue q = new SynchronousQueue(fair);
105	<	Integer[] ints = new Integer[1];
106	<	for (int i = 0; i < ints.length; i++)
106	<	ints[i] = i;
107	<	Collection<Integer> coll = Arrays.asList(ints);
104	>	SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
105	>	Item[] items = seqItems(1);
106	>	Collection<Item> coll = Arrays.asList(items);
107		try {
108		q.addAll(coll);
109		shouldThrow();
#	Line 117 | Line 116 | public class SynchronousQueueTest extend
116		public void testBlockingPut()      { testBlockingPut(false); }
117		public void testBlockingPut_fair() { testBlockingPut(true); }
118		public void testBlockingPut(boolean fair) {
119	<	final SynchronousQueue q = new SynchronousQueue(fair);
119	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
120		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
121		Thread t = newStartedThread(new CheckedRunnable() {
122		public void realRun() throws InterruptedException {
123		Thread.currentThread().interrupt();
124		try {
125	<	q.put(99);
125	>	q.put(ninetynine);
126		shouldThrow();
127		} catch (InterruptedException success) {}
128		assertFalse(Thread.interrupted());
129
130		pleaseInterrupt.countDown();
131		try {
132	<	q.put(99);
132	>	q.put(ninetynine);
133		shouldThrow();
134		} catch (InterruptedException success) {}
135		assertFalse(Thread.interrupted());
136		}});
137
138		await(pleaseInterrupt);
139	<	assertThreadStaysAlive(t);
139	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
140		t.interrupt();
141		awaitTermination(t);
142	<	assertEquals(0, q.remainingCapacity());
142	>	mustEqual(0, q.remainingCapacity());
143		}
144
145		/**
#	Line 149 | Line 148 | public class SynchronousQueueTest extend
148		public void testPutWithTake()      { testPutWithTake(false); }
149		public void testPutWithTake_fair() { testPutWithTake(true); }
150		public void testPutWithTake(boolean fair) {
151	<	final SynchronousQueue q = new SynchronousQueue(fair);
151	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
152		final CountDownLatch pleaseTake = new CountDownLatch(1);
153		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
154		Thread t = newStartedThread(new CheckedRunnable() {
#	Line 157 | Line 156 | public class SynchronousQueueTest extend
156		pleaseTake.countDown();
157		q.put(one);
158
159	+	Thread.currentThread().interrupt();
160	+	try {
161	+	q.put(ninetynine);
162	+	shouldThrow();
163	+	} catch (InterruptedException success) {}
164	+	assertFalse(Thread.interrupted());
165	+
166		pleaseInterrupt.countDown();
167		try {
168	<	q.put(99);
168	>	q.put(ninetynine);
169		shouldThrow();
170		} catch (InterruptedException success) {}
171		assertFalse(Thread.interrupted());
172		}});
173
174		await(pleaseTake);
175	<	assertEquals(0, q.remainingCapacity());
175	>	mustEqual(0, q.remainingCapacity());
176		try { assertSame(one, q.take()); }
177		catch (InterruptedException e) { threadUnexpectedException(e); }
178
179		await(pleaseInterrupt);
180	<	assertThreadStaysAlive(t);
180	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
181		t.interrupt();
182		awaitTermination(t);
183	<	assertEquals(0, q.remainingCapacity());
183	>	mustEqual(0, q.remainingCapacity());
184		}
185
186		/**
187		* timed offer times out if elements not taken
188		*/
189	<	public void testTimedOffer()      { testTimedOffer(false); }
190	<	public void testTimedOffer_fair() { testTimedOffer(true); }
191	<	public void testTimedOffer(boolean fair) {
186	<	final SynchronousQueue q = new SynchronousQueue(fair);
189	>	public void testTimedOffer() {
190	>	final boolean fair = randomBoolean();
191	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
192		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
193		Thread t = newStartedThread(new CheckedRunnable() {
194		public void realRun() throws InterruptedException {
195		long startTime = System.nanoTime();
196	<	assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
196	>
197	>	assertFalse(q.offer(zero, timeoutMillis(), MILLISECONDS));
198		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
199	+
200	+	Thread.currentThread().interrupt();
201	+	try {
202	+	q.offer(one, randomTimeout(), randomTimeUnit());
203	+	shouldThrow();
204	+	} catch (InterruptedException success) {}
205	+	assertFalse(Thread.interrupted());
206	+
207		pleaseInterrupt.countDown();
208		try {
209	<	q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
209	>	q.offer(two, LONGER_DELAY_MS, MILLISECONDS);
210		shouldThrow();
211		} catch (InterruptedException success) {}
212	+	assertFalse(Thread.interrupted());
213		}});
214
215		await(pleaseInterrupt);
216	<	assertThreadStaysAlive(t);
216	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
217		t.interrupt();
218		awaitTermination(t);
219		}
#	Line 209 | Line 224 | public class SynchronousQueueTest extend
224		public void testPoll()      { testPoll(false); }
225		public void testPoll_fair() { testPoll(true); }
226		public void testPoll(boolean fair) {
227	<	final SynchronousQueue q = new SynchronousQueue(fair);
227	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
228		assertNull(q.poll());
229		}
230
#	Line 219 | Line 234 | public class SynchronousQueueTest extend
234		public void testTimedPoll0()      { testTimedPoll0(false); }
235		public void testTimedPoll0_fair() { testTimedPoll0(true); }
236		public void testTimedPoll0(boolean fair) {
237	<	final SynchronousQueue q = new SynchronousQueue(fair);
237	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
238		try { assertNull(q.poll(0, MILLISECONDS)); }
239		catch (InterruptedException e) { threadUnexpectedException(e); }
240		}
#	Line 227 | Line 242 | public class SynchronousQueueTest extend
242		/**
243		* timed poll with nonzero timeout times out if no active putter
244		*/
245	<	public void testTimedPoll()      { testTimedPoll(false); }
246	<	public void testTimedPoll_fair() { testTimedPoll(true); }
247	<	public void testTimedPoll(boolean fair) {
248	<	final SynchronousQueue q = new SynchronousQueue(fair);
234	<	long startTime = System.nanoTime();
245	>	public void testTimedPoll() {
246	>	final boolean fair = randomBoolean();
247	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
248	>	final long startTime = System.nanoTime();
249		try { assertNull(q.poll(timeoutMillis(), MILLISECONDS)); }
250		catch (InterruptedException e) { threadUnexpectedException(e); }
251		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
#	Line 241 | Line 255 | public class SynchronousQueueTest extend
255		* timed poll before a delayed offer times out, returning null;
256		* after offer succeeds; on interruption throws
257		*/
258	<	public void testTimedPollWithOffer()      { testTimedPollWithOffer(false); }
259	<	public void testTimedPollWithOffer_fair() { testTimedPollWithOffer(true); }
260	<	public void testTimedPollWithOffer(boolean fair) {
247	<	final SynchronousQueue q = new SynchronousQueue(fair);
258	>	public void testTimedPollWithOffer() {
259	>	final boolean fair = randomBoolean();
260	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
261		final CountDownLatch pleaseOffer = new CountDownLatch(1);
262		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
263		Thread t = newStartedThread(new CheckedRunnable() {
#	Line 256 | Line 269 | public class SynchronousQueueTest extend
269		pleaseOffer.countDown();
270		startTime = System.nanoTime();
271		assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
259	–	assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
272
273		Thread.currentThread().interrupt();
274		try {
275	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
275	>	q.poll(randomTimeout(), randomTimeUnit());
276		shouldThrow();
277		} catch (InterruptedException success) {}
278		assertFalse(Thread.interrupted());
#	Line 271 | Line 283 | public class SynchronousQueueTest extend
283		shouldThrow();
284		} catch (InterruptedException success) {}
285		assertFalse(Thread.interrupted());
286	+
287	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
288		}});
289
290		await(pleaseOffer);
291		long startTime = System.nanoTime();
292		try { assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS)); }
293		catch (InterruptedException e) { threadUnexpectedException(e); }
294	<	assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
294	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
295
296		await(pleaseInterrupt);
297	<	assertThreadStaysAlive(t);
297	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
298		t.interrupt();
299		awaitTermination(t);
300		}
#	Line 291 | Line 305 | public class SynchronousQueueTest extend
305		public void testPeek()      { testPeek(false); }
306		public void testPeek_fair() { testPeek(true); }
307		public void testPeek(boolean fair) {
308	<	final SynchronousQueue q = new SynchronousQueue(fair);
308	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
309		assertNull(q.peek());
310		}
311
#	Line 301 | Line 315 | public class SynchronousQueueTest extend
315		public void testElement()      { testElement(false); }
316		public void testElement_fair() { testElement(true); }
317		public void testElement(boolean fair) {
318	<	final SynchronousQueue q = new SynchronousQueue(fair);
318	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
319		try {
320		q.element();
321		shouldThrow();
#	Line 314 | Line 328 | public class SynchronousQueueTest extend
328		public void testRemove()      { testRemove(false); }
329		public void testRemove_fair() { testRemove(true); }
330		public void testRemove(boolean fair) {
331	<	final SynchronousQueue q = new SynchronousQueue(fair);
331	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
332		try {
333		q.remove();
334		shouldThrow();
#	Line 327 | Line 341 | public class SynchronousQueueTest extend
341		public void testContains()      { testContains(false); }
342		public void testContains_fair() { testContains(true); }
343		public void testContains(boolean fair) {
344	<	final SynchronousQueue q = new SynchronousQueue(fair);
344	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
345		assertFalse(q.contains(zero));
346		}
347
#	Line 337 | Line 351 | public class SynchronousQueueTest extend
351		public void testClear()      { testClear(false); }
352		public void testClear_fair() { testClear(true); }
353		public void testClear(boolean fair) {
354	<	final SynchronousQueue q = new SynchronousQueue(fair);
354	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
355		q.clear();
356		assertTrue(q.isEmpty());
357		}
#	Line 348 | Line 362 | public class SynchronousQueueTest extend
362		public void testContainsAll()      { testContainsAll(false); }
363		public void testContainsAll_fair() { testContainsAll(true); }
364		public void testContainsAll(boolean fair) {
365	<	final SynchronousQueue q = new SynchronousQueue(fair);
366	<	Integer[] empty = new Integer[0];
365	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
366	>	Item[] empty = new Item[0];
367		assertTrue(q.containsAll(Arrays.asList(empty)));
368	<	Integer[] ints = new Integer[1]; ints[0] = zero;
369	<	assertFalse(q.containsAll(Arrays.asList(ints)));
368	>	Item[] items = new Item[1]; items[0] = zero;
369	>	assertFalse(q.containsAll(Arrays.asList(items)));
370		}
371
372		/**
#	Line 361 | Line 375 | public class SynchronousQueueTest extend
375		public void testRetainAll()      { testRetainAll(false); }
376		public void testRetainAll_fair() { testRetainAll(true); }
377		public void testRetainAll(boolean fair) {
378	<	final SynchronousQueue q = new SynchronousQueue(fair);
379	<	Integer[] empty = new Integer[0];
378	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
379	>	Item[] empty = new Item[0];
380		assertFalse(q.retainAll(Arrays.asList(empty)));
381	<	Integer[] ints = new Integer[1]; ints[0] = zero;
382	<	assertFalse(q.retainAll(Arrays.asList(ints)));
381	>	Item[] items = new Item[1]; items[0] = zero;
382	>	assertFalse(q.retainAll(Arrays.asList(items)));
383		}
384
385		/**
#	Line 374 | Line 388 | public class SynchronousQueueTest extend
388		public void testRemoveAll()      { testRemoveAll(false); }
389		public void testRemoveAll_fair() { testRemoveAll(true); }
390		public void testRemoveAll(boolean fair) {
391	<	final SynchronousQueue q = new SynchronousQueue(fair);
392	<	Integer[] empty = new Integer[0];
391	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
392	>	Item[] empty = new Item[0];
393		assertFalse(q.removeAll(Arrays.asList(empty)));
394	<	Integer[] ints = new Integer[1]; ints[0] = zero;
395	<	assertFalse(q.containsAll(Arrays.asList(ints)));
394	>	Item[] items = new Item[1]; items[0] = zero;
395	>	assertFalse(q.containsAll(Arrays.asList(items)));
396		}
397
398		/**
#	Line 387 | Line 401 | public class SynchronousQueueTest extend
401		public void testToArray()      { testToArray(false); }
402		public void testToArray_fair() { testToArray(true); }
403		public void testToArray(boolean fair) {
404	<	final SynchronousQueue q = new SynchronousQueue(fair);
404	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
405		Object[] o = q.toArray();
406	<	assertEquals(0, o.length);
406	>	mustEqual(0, o.length);
407		}
408
409		/**
410	<	* toArray(Integer array) returns its argument with the first
410	>	* toArray(Item array) returns its argument with the first
411		* element (if present) nulled out
412		*/
413		public void testToArray2()      { testToArray2(false); }
414		public void testToArray2_fair() { testToArray2(true); }
415		public void testToArray2(boolean fair) {
416	<	final SynchronousQueue<Integer> q
417	<	= new SynchronousQueue<Integer>(fair);
404	<	Integer[] a;
416	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
417	>	Item[] a;
418
419	<	a = new Integer[0];
419	>	a = new Item[0];
420		assertSame(a, q.toArray(a));
421	<
422	<	a = new Integer[3];
423	<	Arrays.fill(a, 42);
421	>
422	>	a = new Item[3];
423	>	Arrays.fill(a, fortytwo);
424		assertSame(a, q.toArray(a));
425		assertNull(a[0]);
426		for (int i = 1; i < a.length; i++)
427	<	assertEquals(42, (int) a[i]);
427	>	mustEqual(42, a[i]);
428		}
429
430		/**
#	Line 420 | Line 433 | public class SynchronousQueueTest extend
433		public void testToArray_null()      { testToArray_null(false); }
434		public void testToArray_null_fair() { testToArray_null(true); }
435		public void testToArray_null(boolean fair) {
436	<	final SynchronousQueue q = new SynchronousQueue(fair);
436	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
437		try {
438	<	Object o[] = q.toArray(null);
438	>	Object[] unused = q.toArray((Object[])null);
439		shouldThrow();
440		} catch (NullPointerException success) {}
441		}
#	Line 433 | Line 446 | public class SynchronousQueueTest extend
446		public void testIterator()      { testIterator(false); }
447		public void testIterator_fair() { testIterator(true); }
448		public void testIterator(boolean fair) {
449	<	final SynchronousQueue q = new SynchronousQueue(fair);
437	<	Iterator it = q.iterator();
438	<	assertFalse(it.hasNext());
439	<	try {
440	<	Object x = it.next();
441	<	shouldThrow();
442	<	} catch (NoSuchElementException success) {}
449	>	assertIteratorExhausted(new SynchronousQueue<Item>(fair).iterator());
450		}
451
452		/**
453	<	* iterator remove throws ISE
453	>	* iterator remove throws IllegalStateException
454		*/
455		public void testIteratorRemove()      { testIteratorRemove(false); }
456		public void testIteratorRemove_fair() { testIteratorRemove(true); }
457		public void testIteratorRemove(boolean fair) {
458	<	final SynchronousQueue q = new SynchronousQueue(fair);
459	<	Iterator it = q.iterator();
458	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
459	>	Iterator<? extends Item> it = q.iterator();
460		try {
461		it.remove();
462		shouldThrow();
#	Line 462 | Line 469 | public class SynchronousQueueTest extend
469		public void testToString()      { testToString(false); }
470		public void testToString_fair() { testToString(true); }
471		public void testToString(boolean fair) {
472	<	final SynchronousQueue q = new SynchronousQueue(fair);
472	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
473		String s = q.toString();
474		assertNotNull(s);
475		}
#	Line 473 | Line 480 | public class SynchronousQueueTest extend
480		public void testOfferInExecutor()      { testOfferInExecutor(false); }
481		public void testOfferInExecutor_fair() { testOfferInExecutor(true); }
482		public void testOfferInExecutor(boolean fair) {
483	<	final SynchronousQueue q = new SynchronousQueue(fair);
477	<	ExecutorService executor = Executors.newFixedThreadPool(2);
483	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
484		final CheckedBarrier threadsStarted = new CheckedBarrier(2);
485	+	final ExecutorService executor = Executors.newFixedThreadPool(2);
486	+	try (PoolCleaner cleaner = cleaner(executor)) {
487
488	<	executor.execute(new CheckedRunnable() {
489	<	public void realRun() throws InterruptedException {
490	<	assertFalse(q.offer(one));
491	<	threadsStarted.await();
492	<	assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
493	<	assertEquals(0, q.remainingCapacity());
494	<	}});
495	<
496	<	executor.execute(new CheckedRunnable() {
497	<	public void realRun() throws InterruptedException {
498	<	threadsStarted.await();
499	<	assertSame(one, q.take());
500	<	}});
501	<
494	<	joinPool(executor);
488	>	executor.execute(new CheckedRunnable() {
489	>	public void realRun() throws InterruptedException {
490	>	assertFalse(q.offer(one));
491	>	threadsStarted.await();
492	>	assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
493	>	mustEqual(0, q.remainingCapacity());
494	>	}});
495	>
496	>	executor.execute(new CheckedRunnable() {
497	>	public void realRun() throws InterruptedException {
498	>	threadsStarted.await();
499	>	assertSame(one, q.take());
500	>	}});
501	>	}
502		}
503
504		/**
#	Line 500 | Line 507 | public class SynchronousQueueTest extend
507		public void testPollInExecutor()      { testPollInExecutor(false); }
508		public void testPollInExecutor_fair() { testPollInExecutor(true); }
509		public void testPollInExecutor(boolean fair) {
510	<	final SynchronousQueue q = new SynchronousQueue(fair);
510	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
511		final CheckedBarrier threadsStarted = new CheckedBarrier(2);
512	<	ExecutorService executor = Executors.newFixedThreadPool(2);
513	<	executor.execute(new CheckedRunnable() {
514	<	public void realRun() throws InterruptedException {
515	<	assertNull(q.poll());
516	<	threadsStarted.await();
517	<	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
518	<	assertTrue(q.isEmpty());
519	<	}});
520	<
521	<	executor.execute(new CheckedRunnable() {
522	<	public void realRun() throws InterruptedException {
523	<	threadsStarted.await();
524	<	q.put(one);
525	<	}});
526	<
527	<	joinPool(executor);
512	>	final ExecutorService executor = Executors.newFixedThreadPool(2);
513	>	try (PoolCleaner cleaner = cleaner(executor)) {
514	>	executor.execute(new CheckedRunnable() {
515	>	public void realRun() throws InterruptedException {
516	>	assertNull(q.poll());
517	>	threadsStarted.await();
518	>	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
519	>	assertTrue(q.isEmpty());
520	>	}});
521	>
522	>	executor.execute(new CheckedRunnable() {
523	>	public void realRun() throws InterruptedException {
524	>	threadsStarted.await();
525	>	q.put(one);
526	>	}});
527	>	}
528		}
529
530		/**
531	<	* a deserialized serialized queue is usable
531	>	* a deserialized/reserialized queue is usable
532		*/
533		public void testSerialization() {
534	<	final SynchronousQueue x = new SynchronousQueue();
535	<	final SynchronousQueue y = new SynchronousQueue(false);
536	<	final SynchronousQueue z = new SynchronousQueue(true);
534	>	final SynchronousQueue<Item> x = new SynchronousQueue<Item>();
535	>	final SynchronousQueue<Item> y = new SynchronousQueue<Item>(false);
536	>	final SynchronousQueue<Item> z = new SynchronousQueue<Item>(true);
537		assertSerialEquals(x, y);
538		assertNotSerialEquals(x, z);
539	<	SynchronousQueue[] qs = { x, y, z };
540	<	for (SynchronousQueue q : qs) {
541	<	SynchronousQueue clone = serialClone(q);
542	<	assert(q != clone);
539	>	SynchronousQueue[] rqs = { x, y, z };
540	>	@SuppressWarnings("unchecked")
541	>	SynchronousQueue<Item>[] qs = (SynchronousQueue<Item>[])rqs;
542	>	for (SynchronousQueue<Item> q : qs) {
543	>	SynchronousQueue<Item> clone = serialClone(q);
544	>	assertNotSame(q, clone);
545		assertSerialEquals(q, clone);
546		assertTrue(clone.isEmpty());
547	<	assertEquals(0, clone.size());
548	<	assertEquals(0, clone.remainingCapacity());
547	>	mustEqual(0, clone.size());
548	>	mustEqual(0, clone.remainingCapacity());
549		assertFalse(clone.offer(zero));
550		}
551		}
#	Line 547 | Line 556 | public class SynchronousQueueTest extend
556		public void testDrainTo()      { testDrainTo(false); }
557		public void testDrainTo_fair() { testDrainTo(true); }
558		public void testDrainTo(boolean fair) {
559	<	final SynchronousQueue q = new SynchronousQueue(fair);
560	<	ArrayList l = new ArrayList();
559	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
560	>	ArrayList<Item> l = new ArrayList<Item>();
561		q.drainTo(l);
562	<	assertEquals(0, q.size());
563	<	assertEquals(0, l.size());
562	>	mustEqual(0, q.size());
563	>	mustEqual(0, l.size());
564		}
565
566		/**
#	Line 560 | Line 569 | public class SynchronousQueueTest extend
569		public void testDrainToWithActivePut()      { testDrainToWithActivePut(false); }
570		public void testDrainToWithActivePut_fair() { testDrainToWithActivePut(true); }
571		public void testDrainToWithActivePut(boolean fair) {
572	<	final SynchronousQueue q = new SynchronousQueue(fair);
572	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
573		Thread t = newStartedThread(new CheckedRunnable() {
574		public void realRun() throws InterruptedException {
575		q.put(one);
576		}});
577
578	<	ArrayList l = new ArrayList();
578	>	ArrayList<Item> l = new ArrayList<Item>();
579		long startTime = System.nanoTime();
580		while (l.isEmpty()) {
581		q.drainTo(l);
#	Line 574 | Line 583 | public class SynchronousQueueTest extend
583		fail("timed out");
584		Thread.yield();
585		}
586	<	assertTrue(l.size() == 1);
586	>	mustEqual(1, l.size());
587		assertSame(one, l.get(0));
588		awaitTermination(t);
589		}
#	Line 583 | Line 592 | public class SynchronousQueueTest extend
592		* drainTo(c, n) empties up to n elements of queue into c
593		*/
594		public void testDrainToN() throws InterruptedException {
595	<	final SynchronousQueue q = new SynchronousQueue();
595	>	final SynchronousQueue<Item> q = new SynchronousQueue<Item>();
596		Thread t1 = newStartedThread(new CheckedRunnable() {
597		public void realRun() throws InterruptedException {
598		q.put(one);
#	Line 594 | Line 603 | public class SynchronousQueueTest extend
603		q.put(two);
604		}});
605
606	<	ArrayList l = new ArrayList();
607	<	delay(SHORT_DELAY_MS);
608	<	q.drainTo(l, 1);
609	<	assertEquals(1, l.size());
610	<	q.drainTo(l, 1);
611	<	assertEquals(2, l.size());
606	>	ArrayList<Item> l = new ArrayList<Item>();
607	>	int drained;
608	>	while ((drained = q.drainTo(l, 1)) == 0) Thread.yield();
609	>	mustEqual(1, drained);
610	>	mustEqual(1, l.size());
611	>	while ((drained = q.drainTo(l, 1)) == 0) Thread.yield();
612	>	mustEqual(1, drained);
613	>	mustEqual(2, l.size());
614		assertTrue(l.contains(one));
615		assertTrue(l.contains(two));
616		awaitTermination(t1);
617		awaitTermination(t2);
618		}
619
620	+	/**
621	+	* remove(null), contains(null) always return false
622	+	*/
623	+	public void testNeverContainsNull() {
624	+	Collection<?> q = new SynchronousQueue<Item>();
625	+	assertFalse(q.contains(null));
626	+	assertFalse(q.remove(null));
627	+	}
628	+
629		}

Diff Legend

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