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.9 by dl, Mon Aug 1 19:54:04 2005 UTC vs.
Revision 1.10 by jsr166, Mon Nov 2 20:28:32 2009 UTC

#	Line 2 | Line 2
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
5	<	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	<	* Pat Fisher, Mike Judd.
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9		import junit.framework.*;
#	Line 14 | Line 14 | import java.io.*;
14		public class SynchronousQueueTest extends JSR166TestCase {
15
16		public static void main(String[] args) {
17	<	junit.textui.TestRunner.run (suite());
17	>	junit.textui.TestRunner.run (suite());
18		}
19
20		public static Test suite() {
#	Line 51 | Line 51 | public class SynchronousQueueTest extend
51		SynchronousQueue q = new SynchronousQueue();
52		q.offer(null);
53		shouldThrow();
54	<	} catch (NullPointerException success) { }
54	>	} catch (NullPointerException success) { }
55		}
56
57		/**
#	Line 62 | Line 62 | public class SynchronousQueueTest extend
62		SynchronousQueue q = new SynchronousQueue();
63		q.add(null);
64		shouldThrow();
65	<	} catch (NullPointerException success) { }
65	>	} catch (NullPointerException success) { }
66		}
67
68		/**
#	Line 83 | Line 83 | public class SynchronousQueueTest extend
83		q.add(one);
84		shouldThrow();
85		} catch (IllegalStateException success){
86	<	}
86	>	}
87		}
88
89		/**
#	Line 145 | Line 145 | public class SynchronousQueueTest extend
145		SynchronousQueue q = new SynchronousQueue();
146		q.put(null);
147		shouldThrow();
148	<	}
148	>	}
149		catch (NullPointerException success){
150	<	}
150	>	}
151		catch (InterruptedException ie) {
152		unexpectedException();
153		}
#	Line 164 | Line 164 | public class SynchronousQueueTest extend
164		q.put(zero);
165		threadShouldThrow();
166		} catch (InterruptedException ie){
167	<	}
167	>	}
168		}});
169		t.start();
170	<	try {
171	<	Thread.sleep(SHORT_DELAY_MS);
170	>	try {
171	>	Thread.sleep(SHORT_DELAY_MS);
172		t.interrupt();
173		t.join();
174		}
#	Line 178 | Line 178 | public class SynchronousQueueTest extend
178		}
179
180		/**
181	<	* put blocks waiting for take
181	>	* put blocks waiting for take
182		*/
183		public void testPutWithTake() {
184		final SynchronousQueue q = new SynchronousQueue();
#	Line 227 | Line 227 | public class SynchronousQueueTest extend
227		} catch (InterruptedException success){}
228		}
229		});
230	<
230	>
231		try {
232		t.start();
233		Thread.sleep(SMALL_DELAY_MS);
#	Line 249 | Line 249 | public class SynchronousQueueTest extend
249		try {
250		q.take();
251		threadShouldThrow();
252	<	} catch (InterruptedException success){ }
252	>	} catch (InterruptedException success){ }
253		}
254		});
255		try {
#	Line 274 | Line 274 | public class SynchronousQueueTest extend
274		q.put(zero);
275		threadShouldThrow();
276		} catch (InterruptedException ie){
277	<	}
277	>	}
278		}});
279		t.start();
280	<	try {
281	<	Thread.sleep(SHORT_DELAY_MS);
280	>	try {
281	>	Thread.sleep(SHORT_DELAY_MS);
282		t.interrupt();
283		t.join();
284		}
#	Line 288 | Line 288 | public class SynchronousQueueTest extend
288		}
289
290		/**
291	<	* put blocks waiting for take
291	>	* put blocks waiting for take
292		*/
293		public void testFairPutWithTake() {
294		final SynchronousQueue q = new SynchronousQueue(true);
#	Line 337 | Line 337 | public class SynchronousQueueTest extend
337		} catch (InterruptedException success){}
338		}
339		});
340	<
340	>
341		try {
342		t.start();
343		Thread.sleep(SMALL_DELAY_MS);
#	Line 359 | Line 359 | public class SynchronousQueueTest extend
359		try {
360		q.take();
361		threadShouldThrow();
362	<	} catch (InterruptedException success){ }
362	>	} catch (InterruptedException success){ }
363		}
364		});
365		try {
#	Line 389 | Line 389 | public class SynchronousQueueTest extend
389		assertNull(q.poll(0, TimeUnit.MILLISECONDS));
390		} catch (InterruptedException e){
391		unexpectedException();
392	<	}
392	>	}
393		}
394
395		/**
#	Line 401 | Line 401 | public class SynchronousQueueTest extend
401		assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
402		} catch (InterruptedException e){
403		unexpectedException();
404	<	}
404	>	}
405		}
406
407		/**
#	Line 415 | Line 415 | public class SynchronousQueueTest extend
415		SynchronousQueue q = new SynchronousQueue();
416		assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
417		} catch (InterruptedException success){
418	<	}
418	>	}
419		}});
420		t.start();
421	<	try {
422	<	Thread.sleep(SHORT_DELAY_MS);
421	>	try {
422	>	Thread.sleep(SHORT_DELAY_MS);
423		t.interrupt();
424		t.join();
425		}
#	Line 441 | Line 441 | public class SynchronousQueueTest extend
441		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
442		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
443		threadShouldThrow();
444	<	} catch (InterruptedException success) { }
444	>	} catch (InterruptedException success) { }
445		}
446		});
447		try {
#	Line 453 | Line 453 | public class SynchronousQueueTest extend
453		} catch (Exception e){
454		unexpectedException();
455		}
456	<	}
456	>	}
457
458		/**
459		* Interrupted timed poll throws InterruptedException instead of
#	Line 466 | Line 466 | public class SynchronousQueueTest extend
466		SynchronousQueue q = new SynchronousQueue(true);
467		assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
468		} catch (InterruptedException success){
469	<	}
469	>	}
470		}});
471		t.start();
472	<	try {
473	<	Thread.sleep(SHORT_DELAY_MS);
472	>	try {
473	>	Thread.sleep(SHORT_DELAY_MS);
474		t.interrupt();
475		t.join();
476		}
#	Line 492 | Line 492 | public class SynchronousQueueTest extend
492		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
493		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
494		threadShouldThrow();
495	<	} catch (InterruptedException success) { }
495	>	} catch (InterruptedException success) { }
496		}
497		});
498		try {
#	Line 504 | Line 504 | public class SynchronousQueueTest extend
504		} catch (Exception e){
505		unexpectedException();
506		}
507	<	}
507	>	}
508
509
510		/**
#	Line 536 | Line 536 | public class SynchronousQueueTest extend
536		q.remove();
537		shouldThrow();
538		} catch (NoSuchElementException success){
539	<	}
539	>	}
540		}
541
542		/**
#	Line 547 | Line 547 | public class SynchronousQueueTest extend
547		assertFalse(q.remove(zero));
548		assertTrue(q.isEmpty());
549		}
550	<
550	>
551		/**
552		* contains returns false
553		*/
#	Line 616 | Line 616 | public class SynchronousQueueTest extend
616		Integer[] ints = new Integer[1];
617		assertNull(ints[0]);
618		}
619	<
619	>
620		/**
621		* toArray(null) throws NPE
622		*/
#	Line 663 | Line 663 | public class SynchronousQueueTest extend
663		SynchronousQueue q = new SynchronousQueue();
664		String s = q.toString();
665		assertNotNull(s);
666	<	}
666	>	}
667
668
669		/**
#	Line 698 | Line 698 | public class SynchronousQueueTest extend
698		}
699		}
700		});
701	<
701	>
702		joinPool(executor);
703
704		}
#	Line 733 | Line 733 | public class SynchronousQueueTest extend
733		}
734		}
735		});
736	<
736	>
737		joinPool(executor);
738		}
739
#	Line 752 | Line 752 | public class SynchronousQueueTest extend
752		ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
753		SynchronousQueue r = (SynchronousQueue)in.readObject();
754		assertEquals(q.size(), r.size());
755	<	while (!q.isEmpty())
755	>	while (!q.isEmpty())
756		assertEquals(q.remove(), r.remove());
757		} catch(Exception e){
758		e.printStackTrace();
#	Line 762 | Line 762 | public class SynchronousQueueTest extend
762
763		/**
764		* drainTo(null) throws NPE
765	<	*/
765	>	*/
766		public void testDrainToNull() {
767		SynchronousQueue q = new SynchronousQueue();
768		try {
#	Line 774 | Line 774 | public class SynchronousQueueTest extend
774
775		/**
776		* drainTo(this) throws IAE
777	<	*/
777	>	*/
778		public void testDrainToSelf() {
779		SynchronousQueue q = new SynchronousQueue();
780		try {
#	Line 786 | Line 786 | public class SynchronousQueueTest extend
786
787		/**
788		* drainTo(c) of empty queue doesn't transfer elements
789	<	*/
789	>	*/
790		public void testDrainTo() {
791		SynchronousQueue q = new SynchronousQueue();
792		ArrayList l = new ArrayList();
#	Line 797 | Line 797 | public class SynchronousQueueTest extend
797
798		/**
799		* drainTo empties queue, unblocking a waiting put.
800	<	*/
800	>	*/
801		public void testDrainToWithActivePut() {
802		final SynchronousQueue q = new SynchronousQueue();
803		Thread t = new Thread(new Runnable() {
804		public void run() {
805		try {
806		q.put(new Integer(1));
807	<	} catch (InterruptedException ie){
807	>	} catch (InterruptedException ie){
808		threadUnexpectedException();
809		}
810		}
#	Line 826 | Line 826 | public class SynchronousQueueTest extend
826
827		/**
828		* drainTo(null, n) throws NPE
829	<	*/
829	>	*/
830		public void testDrainToNullN() {
831		SynchronousQueue q = new SynchronousQueue();
832		try {
#	Line 838 | Line 838 | public class SynchronousQueueTest extend
838
839		/**
840		* drainTo(this, n) throws IAE
841	<	*/
841	>	*/
842		public void testDrainToSelfN() {
843		SynchronousQueue q = new SynchronousQueue();
844		try {
#	Line 850 | Line 850 | public class SynchronousQueueTest extend
850
851		/**
852		* drainTo(c, n) empties up to n elements of queue into c
853	<	*/
853	>	*/
854		public void testDrainToN() {
855		final SynchronousQueue q = new SynchronousQueue();
856		Thread t1 = new Thread(new Runnable() {
857		public void run() {
858		try {
859		q.put(one);
860	<	} catch (InterruptedException ie){
860	>	} catch (InterruptedException ie){
861		threadUnexpectedException();
862		}
863		}
#	Line 866 | Line 866 | public class SynchronousQueueTest extend
866		public void run() {
867		try {
868		q.put(two);
869	<	} catch (InterruptedException ie){
869	>	} catch (InterruptedException ie){
870		threadUnexpectedException();
871		}
872		}

Diff Legend

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