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.5 by dl, Thu Sep 25 11:02:41 2003 UTC vs.
Revision 1.11 by jsr166, Mon Nov 16 04:57:10 2009 UTC

#	Line 1 | Line 1
1		/*
2	<	* Written by members of JCP JSR-166 Expert Group and released to the
3	<	* public domain. Use, modify, and redistribute this code in any way
4	<	* without acknowledgement. Other contributors include Andrew Wright,
5	<	* Jeffrey Hayes, Pat Fischer, Mike Judd.
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.
7		*/
8
9		import junit.framework.*;
#	Line 13 | 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 32 | Line 33 | public class SynchronousQueueTest extend
33		}
34
35		/**
36	+	* A fair SynchronousQueue is both empty and full
37	+	*/
38	+	public void testFairEmptyFull() {
39	+	SynchronousQueue q = new SynchronousQueue(true);
40	+	assertTrue(q.isEmpty());
41	+	assertEquals(0, q.size());
42	+	assertEquals(0, q.remainingCapacity());
43	+	assertFalse(q.offer(zero));
44	+	}
45	+
46	+	/**
47		* offer(null) throws NPE
48		*/
49		public void testOfferNull() {
#	Line 39 | 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	>	/**
58	>	* add(null) throws NPE
59	>	*/
60	>	public void testAddNull() {
61	>	try {
62	>	SynchronousQueue q = new SynchronousQueue();
63	>	q.add(null);
64	>	shouldThrow();
65	>	} catch (NullPointerException success) { }
66		}
67
68		/**
#	Line 60 | Line 83 | public class SynchronousQueueTest extend
83		q.add(one);
84		shouldThrow();
85		} catch (IllegalStateException success){
86	<	}
86	>	}
87		}
88
89		/**
#	Line 74 | Line 97 | public class SynchronousQueueTest extend
97		}
98		catch (NullPointerException success) {}
99		}
100	+
101	+	/**
102	+	* addAll(this) throws IAE
103	+	*/
104	+	public void testAddAllSelf() {
105	+	try {
106	+	SynchronousQueue q = new SynchronousQueue();
107	+	q.addAll(q);
108	+	shouldThrow();
109	+	}
110	+	catch (IllegalArgumentException success) {}
111	+	}
112	+
113		/**
114		* addAll of a collection with null elements throws NPE
115		*/
#	Line 109 | 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 128 | 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 142 | 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 191 | 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 213 | 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 {
256	>	t.start();
257	>	Thread.sleep(SHORT_DELAY_MS);
258	>	t.interrupt();
259	>	t.join();
260	>	} catch (Exception e){
261	>	unexpectedException();
262	>	}
263	>	}
264	>
265	>
266	>	/**
267	>	* put blocks interruptibly if no active taker
268	>	*/
269	>	public void testFairBlockingPut() {
270	>	Thread t = new Thread(new Runnable() {
271	>	public void run() {
272	>	try {
273	>	SynchronousQueue q = new SynchronousQueue(true);
274	>	q.put(zero);
275	>	threadShouldThrow();
276	>	} catch (InterruptedException ie){
277	>	}
278	>	}});
279	>	t.start();
280	>	try {
281	>	Thread.sleep(SHORT_DELAY_MS);
282	>	t.interrupt();
283	>	t.join();
284	>	}
285	>	catch (InterruptedException ie) {
286	>	unexpectedException();
287	>	}
288	>	}
289	>
290	>	/**
291	>	* put blocks waiting for take
292	>	*/
293	>	public void testFairPutWithTake() {
294	>	final SynchronousQueue q = new SynchronousQueue(true);
295	>	Thread t = new Thread(new Runnable() {
296	>	public void run() {
297	>	int added = 0;
298	>	try {
299	>	q.put(new Object());
300	>	++added;
301	>	q.put(new Object());
302	>	++added;
303	>	q.put(new Object());
304	>	++added;
305	>	q.put(new Object());
306	>	++added;
307	>	threadShouldThrow();
308	>	} catch (InterruptedException e){
309	>	assertTrue(added >= 1);
310	>	}
311	>	}
312	>	});
313	>	try {
314	>	t.start();
315	>	Thread.sleep(SHORT_DELAY_MS);
316	>	q.take();
317	>	Thread.sleep(SHORT_DELAY_MS);
318	>	t.interrupt();
319	>	t.join();
320	>	} catch (Exception e){
321	>	unexpectedException();
322	>	}
323	>	}
324	>
325	>	/**
326	>	* timed offer times out if elements not taken
327	>	*/
328	>	public void testFairTimedOffer() {
329	>	final SynchronousQueue q = new SynchronousQueue(true);
330	>	Thread t = new Thread(new Runnable() {
331	>	public void run() {
332	>	try {
333	>
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){}
338	>	}
339	>	});
340	>
341	>	try {
342	>	t.start();
343	>	Thread.sleep(SMALL_DELAY_MS);
344	>	t.interrupt();
345	>	t.join();
346	>	} catch (Exception e){
347	>	unexpectedException();
348	>	}
349	>	}
350	>
351	>
352	>	/**
353	>	* take blocks interruptibly when empty
354	>	*/
355	>	public void testFairTakeFromEmpty() {
356	>	final SynchronousQueue q = new SynchronousQueue(true);
357	>	Thread t = new Thread(new Runnable() {
358	>	public void run() {
359	>	try {
360	>	q.take();
361	>	threadShouldThrow();
362	>	} catch (InterruptedException success){ }
363		}
364		});
365		try {
#	Line 243 | 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 255 | 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 269 | 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 295 | 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 {
448	>	t.start();
449	>	Thread.sleep(SMALL_DELAY_MS);
450	>	assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
451	>	t.interrupt();
452	>	t.join();
453	>	} catch (Exception e){
454	>	unexpectedException();
455	>	}
456	>	}
457	>
458	>	/**
459	>	* Interrupted timed poll throws InterruptedException instead of
460	>	* returning timeout status
461	>	*/
462	>	public void testFairInterruptedTimedPoll() {
463	>	Thread t = new Thread(new Runnable() {
464	>	public void run() {
465	>	try {
466	>	SynchronousQueue q = new SynchronousQueue(true);
467	>	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
468	>	} catch (InterruptedException success){
469	>	}
470	>	}});
471	>	t.start();
472	>	try {
473	>	Thread.sleep(SHORT_DELAY_MS);
474	>	t.interrupt();
475	>	t.join();
476	>	}
477	>	catch (InterruptedException ie) {
478	>	unexpectedException();
479	>	}
480	>	}
481	>
482	>	/**
483	>	*  timed poll before a delayed offer fails; after offer succeeds;
484	>	*  on interruption throws
485	>	*/
486	>	public void testFairTimedPollWithOffer() {
487	>	final SynchronousQueue q = new SynchronousQueue(true);
488	>	Thread t = new Thread(new Runnable() {
489	>	public void run() {
490	>	try {
491	>	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
492	>	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
493	>	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
494	>	threadShouldThrow();
495	>	} catch (InterruptedException success) { }
496		}
497		});
498		try {
#	Line 307 | Line 504 | public class SynchronousQueueTest extend
504		} catch (Exception e){
505		unexpectedException();
506		}
507	<	}
507	>	}
508
509
510		/**
#	Line 339 | Line 536 | public class SynchronousQueueTest extend
536		q.remove();
537		shouldThrow();
538		} catch (NoSuchElementException success){
539	<	}
539	>	}
540		}
541
542		/**
#	Line 350 | 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 419 | 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	>	*/
623	>	public void testToArray_BadArg() {
624	>	try {
625	>	SynchronousQueue q = new SynchronousQueue();
626	>	Object o[] = q.toArray(null);
627	>	shouldThrow();
628	>	} catch (NullPointerException success){}
629	>	}
630	>
631	>
632		/**
633		* iterator does not traverse any elements
634		*/
#	Line 454 | 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 489 | Line 698 | public class SynchronousQueueTest extend
698		}
699		}
700		});
701	<
701	>
702		joinPool(executor);
703
704		}
#	Line 524 | Line 733 | public class SynchronousQueueTest extend
733		}
734		}
735		});
736	<
736	>
737		joinPool(executor);
738		}
739
#	Line 543 | 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	>	*/
766	>	public void testDrainToNull() {
767	>	SynchronousQueue q = new SynchronousQueue();
768	>	try {
769	>	q.drainTo(null);
770	>	shouldThrow();
771	>	} catch (NullPointerException success) {
772	>	}
773	>	}
774	>
775	>	/**
776	>	* drainTo(this) throws IAE
777	>	*/
778	>	public void testDrainToSelf() {
779	>	SynchronousQueue q = new SynchronousQueue();
780	>	try {
781	>	q.drainTo(q);
782	>	shouldThrow();
783	>	} catch (IllegalArgumentException success) {
784	>	}
785	>	}
786	>
787	>	/**
788	>	* drainTo(c) of empty queue doesn't transfer elements
789	>	*/
790	>	public void testDrainTo() {
791	>	SynchronousQueue q = new SynchronousQueue();
792	>	ArrayList l = new ArrayList();
793	>	q.drainTo(l);
794	>	assertEquals(q.size(), 0);
795	>	assertEquals(l.size(), 0);
796	>	}
797	>
798	>	/**
799	>	* drainTo empties queue, unblocking a waiting put.
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){
808	>	threadUnexpectedException();
809	>	}
810	>	}
811	>	});
812	>	try {
813	>	t.start();
814	>	ArrayList l = new ArrayList();
815	>	Thread.sleep(SHORT_DELAY_MS);
816	>	q.drainTo(l);
817	>	assertTrue(l.size() <= 1);
818	>	if (l.size() > 0)
819	>	assertEquals(l.get(0), new Integer(1));
820	>	t.join();
821	>	assertTrue(l.size() <= 1);
822	>	} catch (Exception e){
823		unexpectedException();
824		}
825		}
826
827	+	/**
828	+	* drainTo(null, n) throws NPE
829	+	*/
830	+	public void testDrainToNullN() {
831	+	SynchronousQueue q = new SynchronousQueue();
832	+	try {
833	+	q.drainTo(null, 0);
834	+	shouldThrow();
835	+	} catch (NullPointerException success) {
836	+	}
837	+	}
838	+
839	+	/**
840	+	* drainTo(this, n) throws IAE
841	+	*/
842	+	public void testDrainToSelfN() {
843	+	SynchronousQueue q = new SynchronousQueue();
844	+	try {
845	+	q.drainTo(q, 0);
846	+	shouldThrow();
847	+	} catch (IllegalArgumentException success) {
848	+	}
849	+	}
850	+
851	+	/**
852	+	* drainTo(c, n) empties up to n elements of queue into c
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){
861	+	threadUnexpectedException();
862	+	}
863	+	}
864	+	});
865	+	Thread t2 = new Thread(new Runnable() {
866	+	public void run() {
867	+	try {
868	+	q.put(two);
869	+	} catch (InterruptedException ie){
870	+	threadUnexpectedException();
871	+	}
872	+	}
873	+	});
874	+
875	+	try {
876	+	t1.start();
877	+	t2.start();
878	+	ArrayList l = new ArrayList();
879	+	Thread.sleep(SHORT_DELAY_MS);
880	+	q.drainTo(l, 1);
881	+	assertTrue(l.size() == 1);
882	+	q.drainTo(l, 1);
883	+	assertTrue(l.size() == 2);
884	+	assertTrue(l.contains(one));
885	+	assertTrue(l.contains(two));
886	+	t1.join();
887	+	t2.join();
888	+	} catch (Exception e){
889	+	unexpectedException();
890	+	}
891	+	}
892	+
893	+
894		}

Diff Legend

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