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.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 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(SynchronousQueue q) {
43		assertTrue(q.isEmpty());
44		assertEquals(0, q.size());
45		assertEquals(0, q.remainingCapacity());
#	Line 48 | 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);
55	<	assertTrue(q.isEmpty());
56	<	assertEquals(0, q.size());
57	<	assertEquals(0, q.remainingCapacity());
58	<	assertFalse(q.offer(zero));
60	>	testEmptyFull(new SynchronousQueue(true));
61		}
62
63		/**
#	Line 157 | 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 170 | 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 194 | Line 196 | public class SynchronousQueueTest extend
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 204 | 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();
216	<	Thread.sleep(SMALL_DELAY_MS);
224	>	await(pleaseInterrupt);
225		t.interrupt();
226	<	t.join();
226	>	awaitTermination(t);
227		}
228
221	–
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();
227	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
228	<	public void realRun() throws InterruptedException {
229	<	q.take();
230	<	}});
231	<
232	<	t.start();
233	<	Thread.sleep(SHORT_DELAY_MS);
234	<	t.interrupt();
235	<	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 247 | 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 271 | Line 275 | public class SynchronousQueueTest extend
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);
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	<	}});
291	<
292	<	t.start();
293	<	Thread.sleep(SMALL_DELAY_MS);
280	>	delay(SHORT_DELAY_MS);
281		t.interrupt();
282		t.join();
283		}
284
298	–
285		/**
286		* take blocks interruptibly when empty
287		*/
#	Line 307 | 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 321 | 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 329 | 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);
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(SHORT_DELAY_MS);
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 {
363	<	SynchronousQueue q = new SynchronousQueue(true);
364	<	q.poll(SMALL_DELAY_MS, MILLISECONDS);
365	<	}});
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 {
382	–	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
383	–	assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
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
396	–
403		/**
404	<	* peek returns null
404	>	* peek() returns null if no active putter
405		*/
406		public void testPeek() {
407		SynchronousQueue q = new SynchronousQueue();
#	Line 403 | 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 414 | 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 565 | 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 587 | 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 657 | 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 706 | 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		assertEquals(1, l.size());
718		q.drainTo(l, 1);

Diff Legend

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