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.26 by jsr166, Sat Oct 9 19:30:35 2010 UTC vs.
Revision 1.36 by jsr166, Sat May 28 13:40:20 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 37 | Line 37 | public class SynchronousQueueTest extend
37		}
38
39		/**
40	<	* A SynchronousQueue is both empty and full
40	>	* Any SynchronousQueue is both empty and full
41		*/
42	<	public void testEmptyFull() {
43	<	SynchronousQueue q = new SynchronousQueue();
42	>	public void testEmptyFull()      { testEmptyFull(false); }
43	>	public void testEmptyFull_fair() { testEmptyFull(true); }
44	>	public void testEmptyFull(boolean fair) {
45	>	final SynchronousQueue q = new SynchronousQueue(fair);
46		assertTrue(q.isEmpty());
47		assertEquals(0, q.size());
48		assertEquals(0, q.remainingCapacity());
#	Line 48 | Line 50 | public class SynchronousQueueTest extend
50		}
51
52		/**
53	<	* A fair SynchronousQueue is both empty and full
53	>	* offer(null) throws NullPointerException
54		*/
55	<	public void testFairEmptyFull() {
56	<	SynchronousQueue q = new SynchronousQueue(true);
57	<	assertTrue(q.isEmpty());
58	<	assertEquals(0, q.size());
57	<	assertEquals(0, q.remainingCapacity());
58	<	assertFalse(q.offer(zero));
59	<	}
60	<
61	<	/**
62	<	* offer(null) throws NPE
63	<	*/
64	<	public void testOfferNull() {
55	>	public void testOfferNull()      { testOfferNull(false); }
56	>	public void testOfferNull_fair() { testOfferNull(true); }
57	>	public void testOfferNull(boolean fair) {
58	>	SynchronousQueue q = new SynchronousQueue(fair);
59		try {
66	–	SynchronousQueue q = new SynchronousQueue();
60		q.offer(null);
61		shouldThrow();
62		} catch (NullPointerException success) {}
63		}
64
65		/**
66	<	* add(null) throws NPE
66	>	* add(null) throws NullPointerException
67		*/
68	<	public void testAddNull() {
68	>	public void testAddNull()      { testAddNull(false); }
69	>	public void testAddNull_fair() { testAddNull(true); }
70	>	public void testAddNull(boolean fair) {
71	>	SynchronousQueue q = new SynchronousQueue(fair);
72		try {
77	–	SynchronousQueue q = new SynchronousQueue();
73		q.add(null);
74		shouldThrow();
75		} catch (NullPointerException success) {}
#	Line 83 | Line 78 | public class SynchronousQueueTest extend
78		/**
79		* offer fails if no active taker
80		*/
81	<	public void testOffer() {
82	<	SynchronousQueue q = new SynchronousQueue();
81	>	public void testOffer()      { testOffer(false); }
82	>	public void testOffer_fair() { testOffer(true); }
83	>	public void testOffer(boolean fair) {
84	>	SynchronousQueue q = new SynchronousQueue(fair);
85		assertFalse(q.offer(one));
86		}
87
88		/**
89	<	* add throws ISE if no active taker
89	>	* add throws IllegalStateException if no active taker
90		*/
91	<	public void testAdd() {
91	>	public void testAdd()      { testAdd(false); }
92	>	public void testAdd_fair() { testAdd(true); }
93	>	public void testAdd(boolean fair) {
94	>	SynchronousQueue q = new SynchronousQueue(fair);
95	>	assertEquals(0, q.remainingCapacity());
96		try {
96	–	SynchronousQueue q = new SynchronousQueue();
97	–	assertEquals(0, q.remainingCapacity());
97		q.add(one);
98		shouldThrow();
99		} catch (IllegalStateException success) {}
100		}
101
102		/**
103	<	* addAll(null) throws NPE
103	>	* addAll(null) throws NullPointerException
104		*/
105	<	public void testAddAll1() {
105	>	public void testAddAll_null()      { testAddAll_null(false); }
106	>	public void testAddAll_null_fair() { testAddAll_null(true); }
107	>	public void testAddAll_null(boolean fair) {
108	>	SynchronousQueue q = new SynchronousQueue(fair);
109		try {
108	–	SynchronousQueue q = new SynchronousQueue();
110		q.addAll(null);
111		shouldThrow();
112		} catch (NullPointerException success) {}
113		}
114
115		/**
116	<	* addAll(this) throws IAE
116	>	* addAll(this) throws IllegalArgumentException
117		*/
118	<	public void testAddAllSelf() {
118	>	public void testAddAll_self()      { testAddAll_self(false); }
119	>	public void testAddAll_self_fair() { testAddAll_self(true); }
120	>	public void testAddAll_self(boolean fair) {
121	>	SynchronousQueue q = new SynchronousQueue(fair);
122		try {
119	–	SynchronousQueue q = new SynchronousQueue();
123		q.addAll(q);
124		shouldThrow();
125		} catch (IllegalArgumentException success) {}
126		}
127
128		/**
129	<	* addAll of a collection with null elements throws NPE
129	>	* addAll of a collection with null elements throws NullPointerException
130		*/
131	<	public void testAddAll2() {
131	>	public void testAddAll_null2()      { testAddAll_null2(false); }
132	>	public void testAddAll_null2_fair() { testAddAll_null2(true); }
133	>	public void testAddAll_null2(boolean fair) {
134	>	SynchronousQueue q = new SynchronousQueue(fair);
135	>	Collection<Integer> ints = Arrays.asList(new Integer[1]);
136		try {
137	<	SynchronousQueue q = new SynchronousQueue();
131	<	Integer[] ints = new Integer[1];
132	<	q.addAll(Arrays.asList(ints));
137	>	q.addAll(ints);
138		shouldThrow();
139		} catch (NullPointerException success) {}
140		}
#	Line 137 | Line 142 | public class SynchronousQueueTest extend
142		/**
143		* addAll throws ISE if no active taker
144		*/
145	<	public void testAddAll4() {
145	>	public void testAddAll_ISE()      { testAddAll_ISE(false); }
146	>	public void testAddAll_ISE_fair() { testAddAll_ISE(true); }
147	>	public void testAddAll_ISE(boolean fair) {
148	>	SynchronousQueue q = new SynchronousQueue(fair);
149	>	Integer[] ints = new Integer[1];
150	>	for (int i = 0; i < ints.length; i++)
151	>	ints[i] = i;
152	>	Collection<Integer> coll = Arrays.asList(ints);
153		try {
154	<	SynchronousQueue q = new SynchronousQueue();
143	<	Integer[] ints = new Integer[1];
144	<	for (int i = 0; i < 1; ++i)
145	<	ints[i] = new Integer(i);
146	<	q.addAll(Arrays.asList(ints));
154	>	q.addAll(coll);
155		shouldThrow();
156		} catch (IllegalStateException success) {}
157		}
#	Line 157 | Line 165 | public class SynchronousQueueTest extend
165		q.put(null);
166		shouldThrow();
167		} catch (NullPointerException success) {}
168	<	}
168	>	}
169
170		/**
171		* put blocks interruptibly if no active taker
172		*/
173	<	public void testBlockingPut() throws InterruptedException {
174	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
173	>	public void testBlockingPut()      { testBlockingPut(false); }
174	>	public void testBlockingPut_fair() { testBlockingPut(true); }
175	>	public void testBlockingPut(boolean fair) {
176	>	final SynchronousQueue q = new SynchronousQueue(fair);
177	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
178	>	Thread t = newStartedThread(new CheckedRunnable() {
179		public void realRun() throws InterruptedException {
180	<	SynchronousQueue q = new SynchronousQueue();
169	<	q.put(zero);
170	<	}});
171	<
172	<	t.start();
173	<	Thread.sleep(SHORT_DELAY_MS);
174	<	t.interrupt();
175	<	t.join();
176	<	}
177	<
178	<	/**
179	<	* put blocks waiting for take
180	<	*/
181	<	public void testPutWithTake() throws InterruptedException {
182	<	final SynchronousQueue q = new SynchronousQueue();
183	<	Thread t = new Thread(new CheckedRunnable() {
184	<	public void realRun() throws InterruptedException {
185	<	int added = 0;
180	>	Thread.currentThread().interrupt();
181		try {
182	<	while (true) {
183	<	q.put(added);
184	<	++added;
185	<	}
191	<	} catch (InterruptedException success) {
192	<	assertEquals(1, added);
193	<	}
194	<	}});
195	<
196	<	t.start();
197	<	Thread.sleep(SHORT_DELAY_MS);
198	<	assertEquals(0, q.take());
199	<	Thread.sleep(SHORT_DELAY_MS);
200	<	t.interrupt();
201	<	t.join();
202	<	}
203	<
204	<	/**
205	<	* timed offer times out if elements not taken
206	<	*/
207	<	public void testTimedOffer() throws InterruptedException {
208	<	final SynchronousQueue q = new SynchronousQueue();
209	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
210	<	public void realRun() throws InterruptedException {
211	<	assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS));
212	<	q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
213	<	}});
214	<
215	<	t.start();
216	<	Thread.sleep(SMALL_DELAY_MS);
217	<	t.interrupt();
218	<	t.join();
219	<	}
220	<
182	>	q.put(99);
183	>	shouldThrow();
184	>	} catch (InterruptedException success) {}
185	>	assertFalse(Thread.interrupted());
186
187	<	/**
188	<	* take blocks interruptibly when empty
189	<	*/
190	<	public void testTakeFromEmpty() throws InterruptedException {
191	<	final SynchronousQueue q = new SynchronousQueue();
192	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
228	<	public void realRun() throws InterruptedException {
229	<	q.take();
187	>	pleaseInterrupt.countDown();
188	>	try {
189	>	q.put(99);
190	>	shouldThrow();
191	>	} catch (InterruptedException success) {}
192	>	assertFalse(Thread.interrupted());
193		}});
194
195	<	t.start();
196	<	Thread.sleep(SHORT_DELAY_MS);
195	>	await(pleaseInterrupt);
196	>	assertThreadStaysAlive(t);
197		t.interrupt();
198	<	t.join();
198	>	awaitTermination(t);
199	>	assertEquals(0, q.remainingCapacity());
200		}
201
238	–
202		/**
203	<	* put blocks interruptibly if no active taker
203	>	* put blocks interruptibly waiting for take
204		*/
205	<	public void testFairBlockingPut() throws InterruptedException {
206	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
205	>	public void testPutWithTake()      { testPutWithTake(false); }
206	>	public void testPutWithTake_fair() { testPutWithTake(true); }
207	>	public void testPutWithTake(boolean fair) {
208	>	final SynchronousQueue q = new SynchronousQueue(fair);
209	>	final CountDownLatch pleaseTake = new CountDownLatch(1);
210	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
211	>	Thread t = newStartedThread(new CheckedRunnable() {
212		public void realRun() throws InterruptedException {
213	<	SynchronousQueue q = new SynchronousQueue(true);
214	<	q.put(zero);
247	<	}});
248	<
249	<	t.start();
250	<	Thread.sleep(SHORT_DELAY_MS);
251	<	t.interrupt();
252	<	t.join();
253	<	}
213	>	pleaseTake.countDown();
214	>	q.put(one);
215
216	<	/**
256	<	* put blocks waiting for take
257	<	*/
258	<	public void testFairPutWithTake() throws InterruptedException {
259	<	final SynchronousQueue q = new SynchronousQueue(true);
260	<	Thread t = new Thread(new CheckedRunnable() {
261	<	public void realRun() throws InterruptedException {
262	<	int added = 0;
216	>	pleaseInterrupt.countDown();
217		try {
218	<	while (true) {
219	<	q.put(added);
220	<	++added;
221	<	}
268	<	} catch (InterruptedException success) {
269	<	assertEquals(1, added);
270	<	}
218	>	q.put(99);
219	>	shouldThrow();
220	>	} catch (InterruptedException success) {}
221	>	assertFalse(Thread.interrupted());
222		}});
223
224	<	t.start();
225	<	Thread.sleep(SHORT_DELAY_MS);
226	<	assertEquals(0, q.take());
227	<	Thread.sleep(SHORT_DELAY_MS);
277	<	t.interrupt();
278	<	t.join();
279	<	}
280	<
281	<	/**
282	<	* timed offer times out if elements not taken
283	<	*/
284	<	public void testFairTimedOffer() throws InterruptedException {
285	<	final SynchronousQueue q = new SynchronousQueue(true);
286	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
287	<	public void realRun() throws InterruptedException {
288	<	assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS));
289	<	q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
290	<	}});
224	>	await(pleaseTake);
225	>	assertEquals(q.remainingCapacity(), 0);
226	>	try { assertSame(one, q.take()); }
227	>	catch (InterruptedException e) { threadUnexpectedException(e); }
228
229	<	t.start();
230	<	Thread.sleep(SMALL_DELAY_MS);
229	>	await(pleaseInterrupt);
230	>	assertThreadStaysAlive(t);
231		t.interrupt();
232	<	t.join();
232	>	awaitTermination(t);
233	>	assertEquals(q.remainingCapacity(), 0);
234		}
235
298	–
236		/**
237	<	* take blocks interruptibly when empty
237	>	* timed offer times out if elements not taken
238		*/
239	<	public void testFairTakeFromEmpty() throws InterruptedException {
240	<	final SynchronousQueue q = new SynchronousQueue(true);
241	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
242	<	public void realRun() throws InterruptedException {
243	<	q.take();
239	>	public void testTimedOffer()      { testTimedOffer(false); }
240	>	public void testTimedOffer_fair() { testTimedOffer(true); }
241	>	public void testTimedOffer(boolean fair) {
242	>	final SynchronousQueue q = new SynchronousQueue(fair);
243	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
244	>	Thread t = newStartedThread(new CheckedRunnable() {
245	>	public void realRun() throws InterruptedException {
246	>	long startTime = System.nanoTime();
247	>	assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
248	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
249	>	pleaseInterrupt.countDown();
250	>	try {
251	>	q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
252	>	shouldThrow();
253	>	} catch (InterruptedException success) {}
254		}});
255
256	<	t.start();
257	<	Thread.sleep(SHORT_DELAY_MS);
256	>	await(pleaseInterrupt);
257	>	assertThreadStaysAlive(t);
258		t.interrupt();
259	<	t.join();
259	>	awaitTermination(t);
260		}
261
262		/**
263	<	* poll fails unless active taker
263	>	* poll return null if no active putter
264		*/
265	<	public void testPoll() {
266	<	SynchronousQueue q = new SynchronousQueue();
265	>	public void testPoll()      { testPoll(false); }
266	>	public void testPoll_fair() { testPoll(true); }
267	>	public void testPoll(boolean fair) {
268	>	final SynchronousQueue q = new SynchronousQueue(fair);
269		assertNull(q.poll());
270		}
271
272		/**
273	<	* timed pool with zero timeout times out if no active taker
273	>	* timed poll with zero timeout times out if no active putter
274		*/
275	<	public void testTimedPoll0() throws InterruptedException {
276	<	SynchronousQueue q = new SynchronousQueue();
277	<	assertNull(q.poll(0, MILLISECONDS));
275	>	public void testTimedPoll0()      { testTimedPoll0(false); }
276	>	public void testTimedPoll0_fair() { testTimedPoll0(true); }
277	>	public void testTimedPoll0(boolean fair) {
278	>	final SynchronousQueue q = new SynchronousQueue(fair);
279	>	try { assertNull(q.poll(0, MILLISECONDS)); }
280	>	catch (InterruptedException e) { threadUnexpectedException(e); }
281		}
282
283		/**
284	<	* timed pool with nonzero timeout times out if no active taker
284	>	* timed poll with nonzero timeout times out if no active putter
285		*/
286	<	public void testTimedPoll() throws InterruptedException {
287	<	SynchronousQueue q = new SynchronousQueue();
288	<	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
286	>	public void testTimedPoll()      { testTimedPoll(false); }
287	>	public void testTimedPoll_fair() { testTimedPoll(true); }
288	>	public void testTimedPoll(boolean fair) {
289	>	final SynchronousQueue q = new SynchronousQueue(fair);
290	>	long startTime = System.nanoTime();
291	>	try { assertNull(q.poll(timeoutMillis(), MILLISECONDS)); }
292	>	catch (InterruptedException e) { threadUnexpectedException(e); }
293	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
294		}
295
296		/**
297	<	* Interrupted timed poll throws InterruptedException instead of
298	<	* returning timeout status
297	>	* timed poll before a delayed offer times out, returning null;
298	>	* after offer succeeds; on interruption throws
299		*/
300	<	public void testInterruptedTimedPoll() throws InterruptedException {
301	<	final SynchronousQueue q = new SynchronousQueue();
302	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
300	>	public void testTimedPollWithOffer()      { testTimedPollWithOffer(false); }
301	>	public void testTimedPollWithOffer_fair() { testTimedPollWithOffer(true); }
302	>	public void testTimedPollWithOffer(boolean fair) {
303	>	final SynchronousQueue q = new SynchronousQueue(fair);
304	>	final CountDownLatch pleaseOffer = new CountDownLatch(1);
305	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
306	>	Thread t = newStartedThread(new CheckedRunnable() {
307		public void realRun() throws InterruptedException {
308	<	q.poll(SMALL_DELAY_MS, MILLISECONDS);
309	<	}});
308	>	long startTime = System.nanoTime();
309	>	assertNull(q.poll(timeoutMillis(), MILLISECONDS));
310	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
311
312	<	t.start();
313	<	Thread.sleep(SHORT_DELAY_MS);
314	<	t.interrupt();
315	<	t.join();
354	<	}
312	>	pleaseOffer.countDown();
313	>	startTime = System.nanoTime();
314	>	assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
315	>	assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
316
317	<	/**
318	<	* Interrupted timed poll throws InterruptedException instead of
319	<	* returning timeout status
320	<	*/
321	<	public void testFairInterruptedTimedPoll() throws InterruptedException {
322	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
362	<	public void realRun() throws InterruptedException {
363	<	SynchronousQueue q = new SynchronousQueue(true);
364	<	q.poll(SMALL_DELAY_MS, MILLISECONDS);
365	<	}});
366	<
367	<	t.start();
368	<	Thread.sleep(SHORT_DELAY_MS);
369	<	t.interrupt();
370	<	t.join();
371	<	}
317	>	Thread.currentThread().interrupt();
318	>	try {
319	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
320	>	shouldThrow();
321	>	} catch (InterruptedException success) {}
322	>	assertFalse(Thread.interrupted());
323
324	<	/**
374	<	* timed poll before a delayed offer fails; after offer succeeds;
375	<	* on interruption throws
376	<	*/
377	<	public void testFairTimedPollWithOffer() throws InterruptedException {
378	<	final SynchronousQueue q = new SynchronousQueue(true);
379	<	Thread t = new Thread(new CheckedRunnable() {
380	<	public void realRun() throws InterruptedException {
324	>	pleaseInterrupt.countDown();
325		try {
382	–	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
383	–	assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
326		q.poll(LONG_DELAY_MS, MILLISECONDS);
327	<	threadShouldThrow();
327	>	shouldThrow();
328		} catch (InterruptedException success) {}
329	+	assertFalse(Thread.interrupted());
330		}});
331
332	<	t.start();
333	<	Thread.sleep(SMALL_DELAY_MS);
334	<	assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
332	>	await(pleaseOffer);
333	>	long startTime = System.nanoTime();
334	>	try { assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS)); }
335	>	catch (InterruptedException e) { threadUnexpectedException(e); }
336	>	assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
337	>
338	>	await(pleaseInterrupt);
339	>	assertThreadStaysAlive(t);
340		t.interrupt();
341	<	t.join();
341	>	awaitTermination(t);
342		}
343
396	–
344		/**
345	<	* peek returns null
345	>	* peek() returns null if no active putter
346		*/
347	<	public void testPeek() {
348	<	SynchronousQueue q = new SynchronousQueue();
347	>	public void testPeek()      { testPeek(false); }
348	>	public void testPeek_fair() { testPeek(true); }
349	>	public void testPeek(boolean fair) {
350	>	final SynchronousQueue q = new SynchronousQueue(fair);
351		assertNull(q.peek());
352		}
353
354		/**
355	<	* element throws NSEE
355	>	* element() throws NoSuchElementException if no active putter
356		*/
357	<	public void testElement() {
358	<	SynchronousQueue q = new SynchronousQueue();
357	>	public void testElement()      { testElement(false); }
358	>	public void testElement_fair() { testElement(true); }
359	>	public void testElement(boolean fair) {
360	>	final SynchronousQueue q = new SynchronousQueue(fair);
361		try {
362		q.element();
363		shouldThrow();
#	Line 414 | Line 365 | public class SynchronousQueueTest extend
365		}
366
367		/**
368	<	* remove throws NSEE if no active taker
368	>	* remove() throws NoSuchElementException if no active putter
369		*/
370	<	public void testRemove() {
371	<	SynchronousQueue q = new SynchronousQueue();
370	>	public void testRemove()      { testRemove(false); }
371	>	public void testRemove_fair() { testRemove(true); }
372	>	public void testRemove(boolean fair) {
373	>	final SynchronousQueue q = new SynchronousQueue(fair);
374		try {
375		q.remove();
376		shouldThrow();
#	Line 427 | Line 380 | public class SynchronousQueueTest extend
380		/**
381		* remove(x) returns false
382		*/
383	<	public void testRemoveElement() {
384	<	SynchronousQueue q = new SynchronousQueue();
383	>	public void testRemoveElement()      { testRemoveElement(false); }
384	>	public void testRemoveElement_fair() { testRemoveElement(true); }
385	>	public void testRemoveElement(boolean fair) {
386	>	final SynchronousQueue q = new SynchronousQueue(fair);
387		assertFalse(q.remove(zero));
388		assertTrue(q.isEmpty());
389		}
#	Line 436 | Line 391 | public class SynchronousQueueTest extend
391		/**
392		* contains returns false
393		*/
394	<	public void testContains() {
395	<	SynchronousQueue q = new SynchronousQueue();
394	>	public void testContains()      { testContains(false); }
395	>	public void testContains_fair() { testContains(true); }
396	>	public void testContains(boolean fair) {
397	>	final SynchronousQueue q = new SynchronousQueue(fair);
398		assertFalse(q.contains(zero));
399		}
400
401		/**
402		* clear ensures isEmpty
403		*/
404	<	public void testClear() {
405	<	SynchronousQueue q = new SynchronousQueue();
404	>	public void testClear()      { testClear(false); }
405	>	public void testClear_fair() { testClear(true); }
406	>	public void testClear(boolean fair) {
407	>	final SynchronousQueue q = new SynchronousQueue(fair);
408		q.clear();
409		assertTrue(q.isEmpty());
410		}
#	Line 453 | Line 412 | public class SynchronousQueueTest extend
412		/**
413		* containsAll returns false unless empty
414		*/
415	<	public void testContainsAll() {
416	<	SynchronousQueue q = new SynchronousQueue();
415	>	public void testContainsAll()      { testContainsAll(false); }
416	>	public void testContainsAll_fair() { testContainsAll(true); }
417	>	public void testContainsAll(boolean fair) {
418	>	final SynchronousQueue q = new SynchronousQueue(fair);
419		Integer[] empty = new Integer[0];
420		assertTrue(q.containsAll(Arrays.asList(empty)));
421		Integer[] ints = new Integer[1]; ints[0] = zero;
#	Line 464 | Line 425 | public class SynchronousQueueTest extend
425		/**
426		* retainAll returns false
427		*/
428	<	public void testRetainAll() {
429	<	SynchronousQueue q = new SynchronousQueue();
428	>	public void testRetainAll()      { testRetainAll(false); }
429	>	public void testRetainAll_fair() { testRetainAll(true); }
430	>	public void testRetainAll(boolean fair) {
431	>	final SynchronousQueue q = new SynchronousQueue(fair);
432		Integer[] empty = new Integer[0];
433		assertFalse(q.retainAll(Arrays.asList(empty)));
434		Integer[] ints = new Integer[1]; ints[0] = zero;
#	Line 475 | Line 438 | public class SynchronousQueueTest extend
438		/**
439		* removeAll returns false
440		*/
441	<	public void testRemoveAll() {
442	<	SynchronousQueue q = new SynchronousQueue();
441	>	public void testRemoveAll()      { testRemoveAll(false); }
442	>	public void testRemoveAll_fair() { testRemoveAll(true); }
443	>	public void testRemoveAll(boolean fair) {
444	>	final SynchronousQueue q = new SynchronousQueue(fair);
445		Integer[] empty = new Integer[0];
446		assertFalse(q.removeAll(Arrays.asList(empty)));
447		Integer[] ints = new Integer[1]; ints[0] = zero;
448		assertFalse(q.containsAll(Arrays.asList(ints)));
449		}
450
486	–
451		/**
452		* toArray is empty
453		*/
454	<	public void testToArray() {
455	<	SynchronousQueue q = new SynchronousQueue();
454	>	public void testToArray()      { testToArray(false); }
455	>	public void testToArray_fair() { testToArray(true); }
456	>	public void testToArray(boolean fair) {
457	>	final SynchronousQueue q = new SynchronousQueue(fair);
458		Object[] o = q.toArray();
459		assertEquals(o.length, 0);
460		}
#	Line 496 | Line 462 | public class SynchronousQueueTest extend
462		/**
463		* toArray(a) is nulled at position 0
464		*/
465	<	public void testToArray2() {
466	<	SynchronousQueue q = new SynchronousQueue();
465	>	public void testToArray2()      { testToArray2(false); }
466	>	public void testToArray2_fair() { testToArray2(true); }
467	>	public void testToArray2(boolean fair) {
468	>	final SynchronousQueue q = new SynchronousQueue(fair);
469		Integer[] ints = new Integer[1];
470		assertNull(ints[0]);
471		}
#	Line 505 | Line 473 | public class SynchronousQueueTest extend
473		/**
474		* toArray(null) throws NPE
475		*/
476	<	public void testToArray_BadArg() {
477	<	SynchronousQueue q = new SynchronousQueue();
476	>	public void testToArray_null()      { testToArray_null(false); }
477	>	public void testToArray_null_fair() { testToArray_null(true); }
478	>	public void testToArray_null(boolean fair) {
479	>	final SynchronousQueue q = new SynchronousQueue(fair);
480		try {
481		Object o[] = q.toArray(null);
482		shouldThrow();
483		} catch (NullPointerException success) {}
484		}
485
516	–
486		/**
487		* iterator does not traverse any elements
488		*/
489	<	public void testIterator() {
490	<	SynchronousQueue q = new SynchronousQueue();
489	>	public void testIterator()      { testIterator(false); }
490	>	public void testIterator_fair() { testIterator(true); }
491	>	public void testIterator(boolean fair) {
492	>	final SynchronousQueue q = new SynchronousQueue(fair);
493		Iterator it = q.iterator();
494		assertFalse(it.hasNext());
495		try {
#	Line 530 | Line 501 | public class SynchronousQueueTest extend
501		/**
502		* iterator remove throws ISE
503		*/
504	<	public void testIteratorRemove() {
505	<	SynchronousQueue q = new SynchronousQueue();
504	>	public void testIteratorRemove()      { testIteratorRemove(false); }
505	>	public void testIteratorRemove_fair() { testIteratorRemove(true); }
506	>	public void testIteratorRemove(boolean fair) {
507	>	final SynchronousQueue q = new SynchronousQueue(fair);
508		Iterator it = q.iterator();
509		try {
510		it.remove();
#	Line 542 | Line 515 | public class SynchronousQueueTest extend
515		/**
516		* toString returns a non-null string
517		*/
518	<	public void testToString() {
519	<	SynchronousQueue q = new SynchronousQueue();
518	>	public void testToString()      { testToString(false); }
519	>	public void testToString_fair() { testToString(true); }
520	>	public void testToString(boolean fair) {
521	>	final SynchronousQueue q = new SynchronousQueue(fair);
522		String s = q.toString();
523		assertNotNull(s);
524		}
525
551	–
526		/**
527		* offer transfers elements across Executor tasks
528		*/
529	<	public void testOfferInExecutor() {
530	<	final SynchronousQueue q = new SynchronousQueue();
529	>	public void testOfferInExecutor()      { testOfferInExecutor(false); }
530	>	public void testOfferInExecutor_fair() { testOfferInExecutor(true); }
531	>	public void testOfferInExecutor(boolean fair) {
532	>	final SynchronousQueue q = new SynchronousQueue(fair);
533		ExecutorService executor = Executors.newFixedThreadPool(2);
534	+	final CheckedBarrier threadsStarted = new CheckedBarrier(2);
535
536		executor.execute(new CheckedRunnable() {
537		public void realRun() throws InterruptedException {
538		assertFalse(q.offer(one));
539	<	assertTrue(q.offer(one, MEDIUM_DELAY_MS, MILLISECONDS));
539	>	threadsStarted.await();
540	>	assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
541		assertEquals(0, q.remainingCapacity());
542		}});
543
544		executor.execute(new CheckedRunnable() {
545		public void realRun() throws InterruptedException {
546	<	Thread.sleep(SMALL_DELAY_MS);
546	>	threadsStarted.await();
547		assertSame(one, q.take());
548		}});
549
#	Line 573 | Line 551 | public class SynchronousQueueTest extend
551		}
552
553		/**
554	<	* poll retrieves elements across Executor threads
554	>	* timed poll retrieves elements across Executor threads
555		*/
556	<	public void testPollInExecutor() {
557	<	final SynchronousQueue q = new SynchronousQueue();
556	>	public void testPollInExecutor()      { testPollInExecutor(false); }
557	>	public void testPollInExecutor_fair() { testPollInExecutor(true); }
558	>	public void testPollInExecutor(boolean fair) {
559	>	final SynchronousQueue q = new SynchronousQueue(fair);
560	>	final CheckedBarrier threadsStarted = new CheckedBarrier(2);
561		ExecutorService executor = Executors.newFixedThreadPool(2);
562		executor.execute(new CheckedRunnable() {
563		public void realRun() throws InterruptedException {
564		assertNull(q.poll());
565	<	assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
565	>	threadsStarted.await();
566	>	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
567		assertTrue(q.isEmpty());
568		}});
569
570		executor.execute(new CheckedRunnable() {
571		public void realRun() throws InterruptedException {
572	<	Thread.sleep(SHORT_DELAY_MS);
572	>	threadsStarted.await();
573		q.put(one);
574		}});
575
#	Line 597 | Line 579 | public class SynchronousQueueTest extend
579		/**
580		* a deserialized serialized queue is usable
581		*/
582	<	public void testSerialization() throws Exception {
583	<	SynchronousQueue q = new SynchronousQueue();
584	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
585	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
586	<	out.writeObject(q);
587	<	out.close();
606	<
607	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
608	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
609	<	SynchronousQueue r = (SynchronousQueue)in.readObject();
582	>	public void testSerialization()      { testSerialization(false); }
583	>	public void testSerialization_fair() { testSerialization(true); }
584	>	public void testSerialization(boolean fair) {
585	>	final SynchronousQueue q = new SynchronousQueue(fair);
586	>	final SynchronousQueue r = serialClone(q);
587	>	assertTrue(q != r);
588		assertEquals(q.size(), r.size());
589		while (!q.isEmpty())
590		assertEquals(q.remove(), r.remove());
#	Line 615 | Line 593 | public class SynchronousQueueTest extend
593		/**
594		* drainTo(null) throws NPE
595		*/
596	<	public void testDrainToNull() {
597	<	SynchronousQueue q = new SynchronousQueue();
596	>	public void testDrainToNull()      { testDrainToNull(false); }
597	>	public void testDrainToNull_fair() { testDrainToNull(true); }
598	>	public void testDrainToNull(boolean fair) {
599	>	final SynchronousQueue q = new SynchronousQueue(fair);
600		try {
601		q.drainTo(null);
602		shouldThrow();
#	Line 626 | Line 606 | public class SynchronousQueueTest extend
606		/**
607		* drainTo(this) throws IAE
608		*/
609	<	public void testDrainToSelf() {
610	<	SynchronousQueue q = new SynchronousQueue();
609	>	public void testDrainToSelf()      { testDrainToSelf(false); }
610	>	public void testDrainToSelf_fair() { testDrainToSelf(true); }
611	>	public void testDrainToSelf(boolean fair) {
612	>	final SynchronousQueue q = new SynchronousQueue(fair);
613		try {
614		q.drainTo(q);
615		shouldThrow();
#	Line 637 | Line 619 | public class SynchronousQueueTest extend
619		/**
620		* drainTo(c) of empty queue doesn't transfer elements
621		*/
622	<	public void testDrainTo() {
623	<	SynchronousQueue q = new SynchronousQueue();
622	>	public void testDrainTo()      { testDrainTo(false); }
623	>	public void testDrainTo_fair() { testDrainTo(true); }
624	>	public void testDrainTo(boolean fair) {
625	>	final SynchronousQueue q = new SynchronousQueue(fair);
626		ArrayList l = new ArrayList();
627		q.drainTo(l);
628		assertEquals(q.size(), 0);
#	Line 648 | Line 632 | public class SynchronousQueueTest extend
632		/**
633		* drainTo empties queue, unblocking a waiting put.
634		*/
635	<	public void testDrainToWithActivePut() throws InterruptedException {
636	<	final SynchronousQueue q = new SynchronousQueue();
637	<	Thread t = new Thread(new CheckedRunnable() {
635	>	public void testDrainToWithActivePut()      { testDrainToWithActivePut(false); }
636	>	public void testDrainToWithActivePut_fair() { testDrainToWithActivePut(true); }
637	>	public void testDrainToWithActivePut(boolean fair) {
638	>	final SynchronousQueue q = new SynchronousQueue(fair);
639	>	Thread t = newStartedThread(new CheckedRunnable() {
640		public void realRun() throws InterruptedException {
641	<	q.put(new Integer(1));
641	>	q.put(one);
642		}});
643
658	–	t.start();
644		ArrayList l = new ArrayList();
645	<	Thread.sleep(SHORT_DELAY_MS);
646	<	q.drainTo(l);
647	<	assertTrue(l.size() <= 1);
648	<	if (l.size() > 0)
649	<	assertEquals(l.get(0), new Integer(1));
650	<	t.join();
651	<	assertTrue(l.size() <= 1);
645	>	long startTime = System.nanoTime();
646	>	while (l.isEmpty()) {
647	>	q.drainTo(l);
648	>	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
649	>	fail("timed out");
650	>	Thread.yield();
651	>	}
652	>	assertTrue(l.size() == 1);
653	>	assertSame(one, l.get(0));
654	>	awaitTermination(t);
655		}
656
657		/**
658	<	* drainTo(null, n) throws NPE
658	>	* drainTo(null, n) throws NullPointerException
659		*/
660	<	public void testDrainToNullN() {
661	<	SynchronousQueue q = new SynchronousQueue();
660	>	public void testDrainToNullN()      { testDrainToNullN(false); }
661	>	public void testDrainToNullN_fair() { testDrainToNullN(true); }
662	>	public void testDrainToNullN(boolean fair) {
663	>	final SynchronousQueue q = new SynchronousQueue(fair);
664		try {
665		q.drainTo(null, 0);
666		shouldThrow();
#	Line 678 | Line 668 | public class SynchronousQueueTest extend
668		}
669
670		/**
671	<	* drainTo(this, n) throws IAE
671	>	* drainTo(this, n) throws IllegalArgumentException
672		*/
673	<	public void testDrainToSelfN() {
674	<	SynchronousQueue q = new SynchronousQueue();
673	>	public void testDrainToSelfN()      { testDrainToSelfN(false); }
674	>	public void testDrainToSelfN_fair() { testDrainToSelfN(true); }
675	>	public void testDrainToSelfN(boolean fair) {
676	>	final SynchronousQueue q = new SynchronousQueue(fair);
677		try {
678		q.drainTo(q, 0);
679		shouldThrow();
#	Line 693 | Line 685 | public class SynchronousQueueTest extend
685		*/
686		public void testDrainToN() throws InterruptedException {
687		final SynchronousQueue q = new SynchronousQueue();
688	<	Thread t1 = new Thread(new CheckedRunnable() {
688	>	Thread t1 = newStartedThread(new CheckedRunnable() {
689		public void realRun() throws InterruptedException {
690		q.put(one);
691		}});
692
693	<	Thread t2 = new Thread(new CheckedRunnable() {
693	>	Thread t2 = newStartedThread(new CheckedRunnable() {
694		public void realRun() throws InterruptedException {
695		q.put(two);
696		}});
697
706	–	t1.start();
707	–	t2.start();
698		ArrayList l = new ArrayList();
699	<	Thread.sleep(SHORT_DELAY_MS);
699	>	delay(SHORT_DELAY_MS);
700		q.drainTo(l, 1);
701		assertEquals(1, l.size());
702		q.drainTo(l, 1);
703		assertEquals(2, l.size());
704		assertTrue(l.contains(one));
705		assertTrue(l.contains(two));
706	<	t1.join();
707	<	t2.join();
706	>	awaitTermination(t1);
707	>	awaitTermination(t2);
708		}
709
710		}

Diff Legend

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