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.8 by dl, Sun Feb 15 00:27:45 2004 UTC vs.
Revision 1.12 by jsr166, Mon Nov 16 05:30:08 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 82 | Line 82 | public class SynchronousQueueTest extend
82		assertEquals(0, q.remainingCapacity());
83		q.add(one);
84		shouldThrow();
85	<	} catch (IllegalStateException success){
86	<	}
85	>	} catch (IllegalStateException success) {
86	>	}
87		}
88
89		/**
#	Line 145 | Line 145 | public class SynchronousQueueTest extend
145		SynchronousQueue q = new SynchronousQueue();
146		q.put(null);
147		shouldThrow();
148	<	}
149	<	catch (NullPointerException success){
150	<	}
148	>	}
149	>	catch (NullPointerException success) {
150	>	}
151		catch (InterruptedException ie) {
152		unexpectedException();
153		}
#	Line 163 | Line 163 | public class SynchronousQueueTest extend
163		SynchronousQueue q = new SynchronousQueue();
164		q.put(zero);
165		threadShouldThrow();
166	<	} catch (InterruptedException ie){
167	<	}
166	>	} catch (InterruptedException ie) {
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 195 | Line 195 | public class SynchronousQueueTest extend
195		q.put(new Object());
196		++added;
197		threadShouldThrow();
198	<	} catch (InterruptedException e){
198	>	} catch (InterruptedException e) {
199		assertTrue(added >= 1);
200		}
201		}
#	Line 207 | Line 207 | public class SynchronousQueueTest extend
207		Thread.sleep(SHORT_DELAY_MS);
208		t.interrupt();
209		t.join();
210	<	} catch (Exception e){
210	>	} catch (Exception e) {
211		unexpectedException();
212		}
213		}
#	Line 224 | Line 224 | public class SynchronousQueueTest extend
224		threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
225		q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
226		threadShouldThrow();
227	<	} catch (InterruptedException success){}
227	>	} catch (InterruptedException success) {}
228		}
229		});
230	<
230	>
231		try {
232		t.start();
233		Thread.sleep(SMALL_DELAY_MS);
234		t.interrupt();
235		t.join();
236	<	} catch (Exception e){
236	>	} catch (Exception e) {
237		unexpectedException();
238		}
239		}
#	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 257 | Line 257 | public class SynchronousQueueTest extend
257		Thread.sleep(SHORT_DELAY_MS);
258		t.interrupt();
259		t.join();
260	<	} catch (Exception e){
260	>	} catch (Exception e) {
261		unexpectedException();
262		}
263		}
#	Line 273 | Line 273 | public class SynchronousQueueTest extend
273		SynchronousQueue q = new SynchronousQueue(true);
274		q.put(zero);
275		threadShouldThrow();
276	<	} catch (InterruptedException ie){
277	<	}
276	>	} catch (InterruptedException ie) {
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 305 | Line 305 | public class SynchronousQueueTest extend
305		q.put(new Object());
306		++added;
307		threadShouldThrow();
308	<	} catch (InterruptedException e){
308	>	} catch (InterruptedException e) {
309		assertTrue(added >= 1);
310		}
311		}
#	Line 317 | Line 317 | public class SynchronousQueueTest extend
317		Thread.sleep(SHORT_DELAY_MS);
318		t.interrupt();
319		t.join();
320	<	} catch (Exception e){
320	>	} catch (Exception e) {
321		unexpectedException();
322		}
323		}
#	Line 334 | Line 334 | public class SynchronousQueueTest extend
334		threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
335		q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
336		threadShouldThrow();
337	<	} catch (InterruptedException success){}
337	>	} catch (InterruptedException success) {}
338		}
339		});
340	<
340	>
341		try {
342		t.start();
343		Thread.sleep(SMALL_DELAY_MS);
344		t.interrupt();
345		t.join();
346	<	} catch (Exception e){
346	>	} catch (Exception e) {
347		unexpectedException();
348		}
349		}
#	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 367 | Line 367 | public class SynchronousQueueTest extend
367		Thread.sleep(SHORT_DELAY_MS);
368		t.interrupt();
369		t.join();
370	<	} catch (Exception e){
370	>	} catch (Exception e) {
371		unexpectedException();
372		}
373		}
#	Line 387 | Line 387 | public class SynchronousQueueTest extend
387		try {
388		SynchronousQueue q = new SynchronousQueue();
389		assertNull(q.poll(0, TimeUnit.MILLISECONDS));
390	<	} catch (InterruptedException e){
390	>	} catch (InterruptedException e) {
391		unexpectedException();
392	<	}
392	>	}
393		}
394
395		/**
#	Line 399 | Line 399 | public class SynchronousQueueTest extend
399		try {
400		SynchronousQueue q = new SynchronousQueue();
401		assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
402	<	} catch (InterruptedException e){
402	>	} catch (InterruptedException e) {
403		unexpectedException();
404	<	}
404	>	}
405		}
406
407		/**
#	Line 414 | Line 414 | public class SynchronousQueueTest extend
414		try {
415		SynchronousQueue q = new SynchronousQueue();
416		assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
417	<	} catch (InterruptedException success){
418	<	}
417	>	} catch (InterruptedException success) {
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 450 | Line 450 | public class SynchronousQueueTest extend
450		assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
451		t.interrupt();
452		t.join();
453	<	} catch (Exception e){
453	>	} catch (Exception e) {
454		unexpectedException();
455		}
456	<	}
456	>	}
457
458		/**
459		* Interrupted timed poll throws InterruptedException instead of
#	Line 465 | Line 465 | public class SynchronousQueueTest extend
465		try {
466		SynchronousQueue q = new SynchronousQueue(true);
467		assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
468	<	} catch (InterruptedException success){
469	<	}
468	>	} catch (InterruptedException success) {
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 501 | Line 501 | public class SynchronousQueueTest extend
501		assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
502		t.interrupt();
503		t.join();
504	<	} catch (Exception e){
504	>	} catch (Exception e) {
505		unexpectedException();
506		}
507	<	}
507	>	}
508
509
510		/**
#	Line 535 | Line 535 | public class SynchronousQueueTest extend
535		try {
536		q.remove();
537		shouldThrow();
538	<	} catch (NoSuchElementException success){
539	<	}
538	>	} catch (NoSuchElementException success) {
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 625 | Line 625 | public class SynchronousQueueTest extend
625		SynchronousQueue q = new SynchronousQueue();
626		Object o[] = q.toArray(null);
627		shouldThrow();
628	<	} catch(NullPointerException success){}
628	>	} catch (NullPointerException success) {}
629		}
630
631
#	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){
757	>	} catch (Exception e) {
758	>	e.printStackTrace();
759		unexpectedException();
760		}
761		}
762
763		/**
764		* drainTo(null) throws NPE
765	<	*/
765	>	*/
766		public void testDrainToNull() {
767		SynchronousQueue q = new SynchronousQueue();
768		try {
769		q.drainTo(null);
770		shouldThrow();
771	<	} catch(NullPointerException success) {
771	>	} catch (NullPointerException success) {
772		}
773		}
774
775		/**
776		* drainTo(this) throws IAE
777	<	*/
777	>	*/
778		public void testDrainToSelf() {
779		SynchronousQueue q = new SynchronousQueue();
780		try {
781		q.drainTo(q);
782		shouldThrow();
783	<	} catch(IllegalArgumentException success) {
783	>	} catch (IllegalArgumentException success) {
784		}
785		}
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 796 | 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 818 | Line 819 | public class SynchronousQueueTest extend
819		assertEquals(l.get(0), new Integer(1));
820		t.join();
821		assertTrue(l.size() <= 1);
822	<	} catch(Exception e){
822	>	} catch (Exception e) {
823		unexpectedException();
824		}
825		}
826
827		/**
828		* drainTo(null, n) throws NPE
829	<	*/
829	>	*/
830		public void testDrainToNullN() {
831		SynchronousQueue q = new SynchronousQueue();
832		try {
833		q.drainTo(null, 0);
834		shouldThrow();
835	<	} catch(NullPointerException success) {
835	>	} catch (NullPointerException success) {
836		}
837		}
838
839		/**
840		* drainTo(this, n) throws IAE
841	<	*/
841	>	*/
842		public void testDrainToSelfN() {
843		SynchronousQueue q = new SynchronousQueue();
844		try {
845		q.drainTo(q, 0);
846		shouldThrow();
847	<	} catch(IllegalArgumentException success) {
847	>	} catch (IllegalArgumentException success) {
848		}
849		}
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 865 | 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		}
#	Line 884 | Line 885 | public class SynchronousQueueTest extend
885		assertTrue(l.contains(two));
886		t1.join();
887		t2.join();
888	<	} catch(Exception e){
888	>	} catch (Exception e) {
889		unexpectedException();
890		}
891		}

Diff Legend

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