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.20 by jsr166, Tue Dec 1 09:48:12 2009 UTC vs.
Revision 1.34 by jsr166, Sat May 21 06:24:33 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 14 | Line 14 | import java.io.*;
14
15		public class SynchronousQueueTest extends JSR166TestCase {
16
17	+	public static class Fair extends BlockingQueueTest {
18	+	protected BlockingQueue emptyCollection() {
19	+	return new SynchronousQueue(true);
20	+	}
21	+	}
22	+
23	+	public static class NonFair extends BlockingQueueTest {
24	+	protected BlockingQueue emptyCollection() {
25	+	return new SynchronousQueue(false);
26	+	}
27	+	}
28	+
29		public static void main(String[] args) {
30	<	junit.textui.TestRunner.run (suite());
30	>	junit.textui.TestRunner.run(suite());
31		}
32
33		public static Test suite() {
34	<	return new TestSuite(SynchronousQueueTest.class);
34	>	return newTestSuite(SynchronousQueueTest.class,
35	>	new Fair().testSuite(),
36	>	new NonFair().testSuite());
37		}
38
39		/**
40	<	* A SynchronousQueue is both empty and full
40	>	* Any SynchronousQueue is both empty and full
41		*/
42	<	public void testEmptyFull() {
29	<	SynchronousQueue q = new SynchronousQueue();
42	>	public void testEmptyFull(SynchronousQueue q) {
43		assertTrue(q.isEmpty());
44		assertEquals(0, q.size());
45		assertEquals(0, q.remainingCapacity());
#	Line 34 | Line 47 | public class SynchronousQueueTest extend
47		}
48
49		/**
50	+	* A non-fair SynchronousQueue is both empty and full
51	+	*/
52	+	public void testEmptyFull() {
53	+	testEmptyFull(new SynchronousQueue());
54	+	}
55	+
56	+	/**
57		* A fair SynchronousQueue is both empty and full
58		*/
59		public void testFairEmptyFull() {
60	<	SynchronousQueue q = new SynchronousQueue(true);
41	<	assertTrue(q.isEmpty());
42	<	assertEquals(0, q.size());
43	<	assertEquals(0, q.remainingCapacity());
44	<	assertFalse(q.offer(zero));
60	>	testEmptyFull(new SynchronousQueue(true));
61		}
62
63		/**
#	Line 119 | Line 135 | public class SynchronousQueueTest extend
135		shouldThrow();
136		} catch (NullPointerException success) {}
137		}
138	+
139		/**
140		* addAll throws ISE if no active taker
141		*/
#	Line 142 | Line 159 | public class SynchronousQueueTest extend
159		q.put(null);
160		shouldThrow();
161		} catch (NullPointerException success) {}
162	<	}
162	>	}
163
164		/**
165		* put blocks interruptibly if no active taker
#	Line 155 | Line 172 | public class SynchronousQueueTest extend
172		}});
173
174		t.start();
175	<	Thread.sleep(SHORT_DELAY_MS);
175	>	delay(SHORT_DELAY_MS);
176		t.interrupt();
177		t.join();
178		}
#	Line 174 | Line 191 | public class SynchronousQueueTest extend
191		++added;
192		}
193		} catch (InterruptedException success) {
194	<	assertTrue(added == 1);
194	>	assertEquals(1, added);
195		}
196		}});
197
198		t.start();
199	<	Thread.sleep(SHORT_DELAY_MS);
199	>	delay(SHORT_DELAY_MS);
200		assertEquals(0, q.take());
201	<	Thread.sleep(SHORT_DELAY_MS);
201	>	delay(SHORT_DELAY_MS);
202		t.interrupt();
203		t.join();
204		}
#	Line 189 | Line 206 | public class SynchronousQueueTest extend
206		/**
207		* timed offer times out if elements not taken
208		*/
209	<	public void testTimedOffer() throws InterruptedException {
210	<	final SynchronousQueue q = new SynchronousQueue();
211	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
212	<	public void realRun() throws InterruptedException {
213	<	assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS));
214	<	q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
209	>	public void testTimedOffer(final SynchronousQueue q)
210	>	throws InterruptedException {
211	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
212	>	Thread t = newStartedThread(new CheckedRunnable() {
213	>	public void realRun() throws InterruptedException {
214	>	long startTime = System.nanoTime();
215	>	assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
216	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
217	>	pleaseInterrupt.countDown();
218	>	try {
219	>	q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
220	>	shouldThrow();
221	>	} catch (InterruptedException success) {}
222		}});
223
224	<	t.start();
201	<	Thread.sleep(SMALL_DELAY_MS);
224	>	await(pleaseInterrupt);
225		t.interrupt();
226	<	t.join();
226	>	awaitTermination(t);
227		}
228
206	–
229		/**
230	<	* take blocks interruptibly when empty
230	>	* timed offer times out if elements not taken
231		*/
232	<	public void testTakeFromEmpty() throws InterruptedException {
233	<	final SynchronousQueue q = new SynchronousQueue();
212	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
213	<	public void realRun() throws InterruptedException {
214	<	q.take();
215	<	}});
216	<
217	<	t.start();
218	<	Thread.sleep(SHORT_DELAY_MS);
219	<	t.interrupt();
220	<	t.join();
232	>	public void testTimedOffer() throws InterruptedException {
233	>	testTimedOffer(new SynchronousQueue());
234		}
235
236	+	/**
237	+	* timed offer times out if elements not taken
238	+	*/
239	+	public void testFairTimedOffer() throws InterruptedException {
240	+	testTimedOffer(new SynchronousQueue(true));
241	+	}
242
243		/**
244		* put blocks interruptibly if no active taker
#	Line 232 | Line 251 | public class SynchronousQueueTest extend
251		}});
252
253		t.start();
254	<	Thread.sleep(SHORT_DELAY_MS);
254	>	delay(SHORT_DELAY_MS);
255		t.interrupt();
256		t.join();
257		}
#	Line 251 | Line 270 | public class SynchronousQueueTest extend
270		++added;
271		}
272		} catch (InterruptedException success) {
273	<	assertTrue(added == 1);
273	>	assertEquals(1, added);
274		}
275		}});
276
277		t.start();
278	<	Thread.sleep(SHORT_DELAY_MS);
278	>	delay(SHORT_DELAY_MS);
279		assertEquals(0, q.take());
280	<	Thread.sleep(SHORT_DELAY_MS);
280	>	delay(SHORT_DELAY_MS);
281		t.interrupt();
282		t.join();
283		}
284
285		/**
267	–	* timed offer times out if elements not taken
268	–	*/
269	–	public void testFairTimedOffer() throws InterruptedException {
270	–	final SynchronousQueue q = new SynchronousQueue(true);
271	–	Thread t = new Thread(new CheckedInterruptedRunnable() {
272	–	public void realRun() throws InterruptedException {
273	–	assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS));
274	–	q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
275	–	}});
276	–
277	–	t.start();
278	–	Thread.sleep(SMALL_DELAY_MS);
279	–	t.interrupt();
280	–	t.join();
281	–	}
282	–
283	–
284	–	/**
286		* take blocks interruptibly when empty
287		*/
288		public void testFairTakeFromEmpty() throws InterruptedException {
#	Line 292 | Line 293 | public class SynchronousQueueTest extend
293		}});
294
295		t.start();
296	<	Thread.sleep(SHORT_DELAY_MS);
296	>	delay(SHORT_DELAY_MS);
297		t.interrupt();
298		t.join();
299		}
300
301		/**
302	<	* poll fails unless active taker
302	>	* poll return null if no active putter
303		*/
304		public void testPoll() {
305		SynchronousQueue q = new SynchronousQueue();
#	Line 306 | Line 307 | public class SynchronousQueueTest extend
307		}
308
309		/**
310	<	* timed pool with zero timeout times out if no active taker
310	>	* timed poll with zero timeout times out if no active putter
311		*/
312		public void testTimedPoll0() throws InterruptedException {
313		SynchronousQueue q = new SynchronousQueue();
#	Line 314 | Line 315 | public class SynchronousQueueTest extend
315		}
316
317		/**
318	<	* timed pool with nonzero timeout times out if no active taker
318	>	* timed poll with nonzero timeout times out if no active putter
319		*/
320		public void testTimedPoll() throws InterruptedException {
321		SynchronousQueue q = new SynchronousQueue();
322	+	long t0 = System.nanoTime();
323		assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
324	+	assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
325		}
326
327		/**
328		* Interrupted timed poll throws InterruptedException instead of
329		* returning timeout status
330		*/
331	<	public void testInterruptedTimedPoll() throws InterruptedException {
332	<	final SynchronousQueue q = new SynchronousQueue();
333	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
331	>	public void testInterruptedTimedPoll(final SynchronousQueue q)
332	>	throws InterruptedException {
333	>	final CountDownLatch threadStarted = new CountDownLatch(1);
334	>	Thread t = newStartedThread(new CheckedRunnable() {
335		public void realRun() throws InterruptedException {
336	<	q.poll(SMALL_DELAY_MS, MILLISECONDS);
337	<	}});
334	<
335	<	t.start();
336	<	Thread.sleep(SHORT_DELAY_MS);
337	<	t.interrupt();
338	<	t.join();
339	<	}
340	<
341	<	/**
342	<	*  timed poll before a delayed offer fails; after offer succeeds;
343	<	*  on interruption throws
344	<	*/
345	<	public void testTimedPollWithOffer() throws InterruptedException {
346	<	final SynchronousQueue q = new SynchronousQueue();
347	<	Thread t = new Thread(new CheckedRunnable() {
348	<	public void realRun() throws InterruptedException {
349	<	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
350	<	assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
336	>	long t0 = System.nanoTime();
337	>	threadStarted.countDown();
338		try {
339		q.poll(LONG_DELAY_MS, MILLISECONDS);
340		shouldThrow();
341		} catch (InterruptedException success) {}
342	+	assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
343	+	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
344		}});
345
346	<	t.start();
347	<	Thread.sleep(SMALL_DELAY_MS);
359	<	assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
346	>	threadStarted.await();
347	>	delay(SHORT_DELAY_MS);
348		t.interrupt();
349	<	t.join();
349	>	awaitTermination(t, MEDIUM_DELAY_MS);
350		}
351
352		/**
353		* Interrupted timed poll throws InterruptedException instead of
354		* returning timeout status
355		*/
356	<	public void testFairInterruptedTimedPoll() throws InterruptedException {
357	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
358	<	public void realRun() throws InterruptedException {
371	<	SynchronousQueue q = new SynchronousQueue(true);
372	<	q.poll(SMALL_DELAY_MS, MILLISECONDS);
373	<	}});
356	>	public void testInterruptedTimedPoll() throws InterruptedException {
357	>	testInterruptedTimedPoll(new SynchronousQueue());
358	>	}
359
360	<	t.start();
361	<	Thread.sleep(SHORT_DELAY_MS);
362	<	t.interrupt();
363	<	t.join();
360	>	/**
361	>	* Interrupted timed poll throws InterruptedException instead of
362	>	* returning timeout status
363	>	*/
364	>	public void testFairInterruptedTimedPoll() throws InterruptedException {
365	>	testInterruptedTimedPoll(new SynchronousQueue(true));
366		}
367
368		/**
369	<	*  timed poll before a delayed offer fails; after offer succeeds;
370	<	*  on interruption throws
369	>	* timed poll before a delayed offer times out, returning null;
370	>	* after offer succeeds; on interruption throws
371		*/
372		public void testFairTimedPollWithOffer() throws InterruptedException {
373		final SynchronousQueue q = new SynchronousQueue(true);
374	<	Thread t = new Thread(new CheckedRunnable() {
374	>	final CountDownLatch pleaseOffer = new CountDownLatch(1);
375	>	Thread t = newStartedThread(new CheckedRunnable() {
376		public void realRun() throws InterruptedException {
377	+	long t0 = System.nanoTime();
378		assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
379	+	assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
380	+
381	+	pleaseOffer.countDown();
382	+	t0 = System.nanoTime();
383		assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
384	+	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
385	+
386	+	t0 = System.nanoTime();
387		try {
388		q.poll(LONG_DELAY_MS, MILLISECONDS);
389	<	threadShouldThrow();
389	>	shouldThrow();
390		} catch (InterruptedException success) {}
391	+	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
392		}});
393
394	<	t.start();
395	<	Thread.sleep(SMALL_DELAY_MS);
396	<	assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
394	>	assertTrue(pleaseOffer.await(MEDIUM_DELAY_MS, MILLISECONDS));
395	>	long t0 = System.nanoTime();
396	>	assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
397	>	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
398	>
399		t.interrupt();
400	<	t.join();
400	>	awaitTermination(t, MEDIUM_DELAY_MS);
401		}
402
404	–
403		/**
404	<	* peek returns null
404	>	* peek() returns null if no active putter
405		*/
406		public void testPeek() {
407		SynchronousQueue q = new SynchronousQueue();
#	Line 411 | Line 409 | public class SynchronousQueueTest extend
409		}
410
411		/**
412	<	* element throws NSEE
412	>	* element() throws NSEE if no active putter
413		*/
414		public void testElement() {
415		SynchronousQueue q = new SynchronousQueue();
#	Line 422 | Line 420 | public class SynchronousQueueTest extend
420		}
421
422		/**
423	<	* remove throws NSEE if no active taker
423	>	* remove() throws NSEE if no active putter
424		*/
425		public void testRemove() {
426		SynchronousQueue q = new SynchronousQueue();
#	Line 573 | Line 571 | public class SynchronousQueueTest extend
571
572		executor.execute(new CheckedRunnable() {
573		public void realRun() throws InterruptedException {
574	<	Thread.sleep(SMALL_DELAY_MS);
574	>	delay(SMALL_DELAY_MS);
575		assertSame(one, q.take());
576		}});
577
#	Line 595 | Line 593 | public class SynchronousQueueTest extend
593
594		executor.execute(new CheckedRunnable() {
595		public void realRun() throws InterruptedException {
596	<	Thread.sleep(SHORT_DELAY_MS);
596	>	delay(SHORT_DELAY_MS);
597		q.put(one);
598		}});
599
#	Line 665 | Line 663 | public class SynchronousQueueTest extend
663
664		t.start();
665		ArrayList l = new ArrayList();
666	<	Thread.sleep(SHORT_DELAY_MS);
666	>	delay(SHORT_DELAY_MS);
667		q.drainTo(l);
668		assertTrue(l.size() <= 1);
669		if (l.size() > 0)
#	Line 714 | Line 712 | public class SynchronousQueueTest extend
712		t1.start();
713		t2.start();
714		ArrayList l = new ArrayList();
715	<	Thread.sleep(SHORT_DELAY_MS);
715	>	delay(SHORT_DELAY_MS);
716		q.drainTo(l, 1);
717	<	assertTrue(l.size() == 1);
717	>	assertEquals(1, l.size());
718		q.drainTo(l, 1);
719	<	assertTrue(l.size() == 2);
719	>	assertEquals(2, l.size());
720		assertTrue(l.contains(one));
721		assertTrue(l.contains(two));
722		t1.join();

Diff Legend

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