ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/CyclicBarrierTest.java

Comparing jsr166/src/test/tck/CyclicBarrierTest.java (file contents):
Revision 1.3 by dl, Sat Sep 20 18:20:07 2003 UTC vs.
Revision 1.13 by jsr166, Sat Nov 21 02:33:20 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.*;
10		import java.util.*;
11		import java.util.concurrent.*;
12	+	import java.util.concurrent.locks.*;
13	+	import java.util.concurrent.atomic.*;
14	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
15
16	<	public class CyclicBarrierTest extends JSR166TestCase{
16	>	public class CyclicBarrierTest extends JSR166TestCase {
17		public static void main(String[] args) {
18	<	junit.textui.TestRunner.run (suite());
18	>	junit.textui.TestRunner.run (suite());
19		}
20		public static Test suite() {
21	<	return new TestSuite(CyclicBarrierTest.class);
21	>	return new TestSuite(CyclicBarrierTest.class);
22		}
23
24		private volatile int countAction;
25		private class MyAction implements Runnable {
26		public void run() { ++countAction; }
27		}
28	<
28	>
29		/**
30	<	*
30	>	* Creating with negative parties throws IAE
31		*/
32		public void testConstructor1() {
33		try {
34		new CyclicBarrier(-1, (Runnable)null);
35		shouldThrow();
36	<	} catch(IllegalArgumentException e){}
36	>	} catch (IllegalArgumentException e) {}
37		}
38
39		/**
40	<	*
40	>	* Creating with negative parties and no action throws IAE
41		*/
42		public void testConstructor2() {
43		try {
44		new CyclicBarrier(-1);
45		shouldThrow();
46	<	} catch(IllegalArgumentException e){}
46	>	} catch (IllegalArgumentException e) {}
47		}
48
49		/**
50	<	*
50	>	* getParties returns the number of parties given in constructor
51		*/
52	<	public void testConstructor3() {
52	>	public void testGetParties() {
53		CyclicBarrier b = new CyclicBarrier(2);
54	<	assertEquals(2, b.getParties());
54	>	assertEquals(2, b.getParties());
55		assertEquals(0, b.getNumberWaiting());
56		}
57
58		/**
59	<	*
59	>	* A 1-party barrier triggers after single await
60		*/
61		public void testSingleParty() {
62		try {
#	Line 63 | Line 67 | public class CyclicBarrierTest extends J
67		b.await();
68		assertEquals(0, b.getNumberWaiting());
69		}
70	<	catch(Exception e) {
70	>	catch (Exception e) {
71		unexpectedException();
72		}
73		}
74	<
74	>
75		/**
76	<	*
76	>	* The supplied barrier action is run at barrier
77		*/
78		public void testBarrierAction() {
79		try {
#	Line 82 | Line 86 | public class CyclicBarrierTest extends J
86		assertEquals(0, b.getNumberWaiting());
87		assertEquals(countAction, 2);
88		}
89	<	catch(Exception e) {
89	>	catch (Exception e) {
90		unexpectedException();
91		}
92		}
93
90	–
94		/**
95	<	*
95	>	* A 2-party/thread barrier triggers after both threads invoke await
96		*/
97		public void testTwoParties() {
98		final CyclicBarrier b = new CyclicBarrier(2);
99	<	Thread t = new Thread(new Runnable() {
100	<	public void run() {
99	>	Thread t = new Thread(new Runnable() {
100	>	public void run() {
101		try {
102		b.await();
103		b.await();
104		b.await();
105		b.await();
106	<	} catch(Exception e){
106	>	} catch (Exception e) {
107		threadUnexpectedException();
108		}}});
109
#	Line 111 | Line 114 | public class CyclicBarrierTest extends J
114		b.await();
115		b.await();
116		t.join();
117	<	} catch(Exception e){
117	>	} catch (Exception e) {
118		unexpectedException();
119		}
120		}
121
122
123		/**
124	<	*
124	>	* An interruption in one party causes others waiting in await to
125	>	* throw BrokenBarrierException
126		*/
127		public void testAwait1_Interrupted_BrokenBarrier() {
128		final CyclicBarrier c = new CyclicBarrier(3);
#	Line 127 | Line 131 | public class CyclicBarrierTest extends J
131		try {
132		c.await();
133		threadShouldThrow();
134	<	} catch(InterruptedException success){}
135	<	catch(Exception b){
136	<	threadFail("should throw IE");
134	>	} catch (InterruptedException success) {}
135	>	catch (Exception b) {
136	>	threadUnexpectedException();
137		}
138		}
139		});
#	Line 137 | Line 141 | public class CyclicBarrierTest extends J
141		public void run() {
142		try {
143		c.await();
144	<	threadShouldThrow();
145	<	} catch(BrokenBarrierException success){
146	<	} catch(Exception i){
147	<	threadFail("should throw BBE");
144	>	threadShouldThrow();
145	>	} catch (BrokenBarrierException success) {
146	>	} catch (Exception i) {
147	>	threadUnexpectedException();
148		}
149		}
150		});
#	Line 149 | Line 153 | public class CyclicBarrierTest extends J
153		t2.start();
154		Thread.sleep(SHORT_DELAY_MS);
155		t1.interrupt();
156	<	t1.join();
156	>	t1.join();
157		t2.join();
158	<	} catch(InterruptedException e){
158	>	} catch (InterruptedException e) {
159		unexpectedException();
160		}
161		}
162
163		/**
164	<	*
164	>	* An interruption in one party causes others waiting in timed await to
165	>	* throw BrokenBarrierException
166		*/
167		public void testAwait2_Interrupted_BrokenBarrier() {
168	<	final CyclicBarrier c = new CyclicBarrier(3);
168	>	final CyclicBarrier c = new CyclicBarrier(3);
169		Thread t1 = new Thread(new Runnable() {
170		public void run() {
171		try {
172	<	c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
172	>	c.await(LONG_DELAY_MS, MILLISECONDS);
173		threadShouldThrow();
174	<	} catch(InterruptedException success){
175	<	} catch(Exception b){
176	<	threadFail("should throw IE");
174	>	} catch (InterruptedException success) {
175	>	} catch (Exception b) {
176	>	threadUnexpectedException();
177		}
178		}
179		});
180		Thread t2 = new Thread(new Runnable() {
181		public void run() {
182		try {
183	<	c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
184	<	threadShouldThrow();
185	<	} catch(BrokenBarrierException success){
186	<	} catch(Exception i){
187	<	threadFail("should throw BBE");
183	>	c.await(LONG_DELAY_MS, MILLISECONDS);
184	>	threadShouldThrow();
185	>	} catch (BrokenBarrierException success) {
186	>	} catch (Exception i) {
187	>	threadUnexpectedException();
188		}
189		}
190		});
#	Line 188 | Line 193 | public class CyclicBarrierTest extends J
193		t2.start();
194		Thread.sleep(SHORT_DELAY_MS);
195		t1.interrupt();
196	<	t1.join();
196	>	t1.join();
197		t2.join();
198	<	} catch(InterruptedException e){
198	>	} catch (InterruptedException e) {
199		unexpectedException();
200		}
201		}
202	<
202	>
203		/**
204	<	*
204	>	* A timeout in timed await throws TimeoutException
205		*/
206		public void testAwait3_TimeOutException() {
207		final CyclicBarrier c = new CyclicBarrier(2);
208		Thread t = new Thread(new Runnable() {
209		public void run() {
210		try {
211	<	c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
211	>	c.await(SHORT_DELAY_MS, MILLISECONDS);
212	>	threadShouldThrow();
213	>	} catch (TimeoutException success) {
214	>	} catch (Exception b) {
215	>	threadUnexpectedException();
216	>
217	>	}
218	>	}
219	>	});
220	>	try {
221	>	t.start();
222	>	t.join();
223	>	} catch (InterruptedException e) {
224	>	unexpectedException();
225	>	}
226	>	}
227	>
228	>	/**
229	>	* A timeout in one party causes others waiting in timed await to
230	>	* throw BrokenBarrierException
231	>	*/
232	>	public void testAwait4_Timeout_BrokenBarrier() {
233	>	final CyclicBarrier c = new CyclicBarrier(3);
234	>	Thread t1 = new Thread(new Runnable() {
235	>	public void run() {
236	>	try {
237	>	c.await(SHORT_DELAY_MS, MILLISECONDS);
238	>	threadShouldThrow();
239	>	} catch (TimeoutException success) {
240	>	} catch (Exception b) {
241	>	threadUnexpectedException();
242	>	}
243	>	}
244	>	});
245	>	Thread t2 = new Thread(new Runnable() {
246	>	public void run() {
247	>	try {
248	>	c.await(MEDIUM_DELAY_MS, MILLISECONDS);
249	>	threadShouldThrow();
250	>	} catch (BrokenBarrierException success) {
251	>	} catch (Exception i) {
252	>	threadUnexpectedException();
253	>	}
254	>	}
255	>	});
256	>	try {
257	>	t1.start();
258	>	t2.start();
259	>	t1.join();
260	>	t2.join();
261	>	} catch (InterruptedException e) {
262	>	unexpectedException();
263	>	}
264	>	}
265	>
266	>	/**
267	>	* A timeout in one party causes others waiting in await to
268	>	* throw BrokenBarrierException
269	>	*/
270	>	public void testAwait5_Timeout_BrokenBarrier() {
271	>	final CyclicBarrier c = new CyclicBarrier(3);
272	>	Thread t1 = new Thread(new Runnable() {
273	>	public void run() {
274	>	try {
275	>	c.await(SHORT_DELAY_MS, MILLISECONDS);
276	>	threadShouldThrow();
277	>	} catch (TimeoutException success) {
278	>	} catch (Exception b) {
279	>	threadUnexpectedException();
280	>	}
281	>	}
282	>	});
283	>	Thread t2 = new Thread(new Runnable() {
284	>	public void run() {
285	>	try {
286	>	c.await();
287	>	threadShouldThrow();
288	>	} catch (BrokenBarrierException success) {
289	>	} catch (Exception i) {
290	>	threadUnexpectedException();
291	>	}
292	>	}
293	>	});
294	>	try {
295	>	t1.start();
296	>	t2.start();
297	>	t1.join();
298	>	t2.join();
299	>	} catch (InterruptedException e) {
300	>	unexpectedException();
301	>	}
302	>	}
303	>
304	>	/**
305	>	* A reset of an active barrier causes waiting threads to throw
306	>	* BrokenBarrierException
307	>	*/
308	>	public void testReset_BrokenBarrier() {
309	>	final CyclicBarrier c = new CyclicBarrier(3);
310	>	Thread t1 = new Thread(new Runnable() {
311	>	public void run() {
312	>	try {
313	>	c.await();
314	>	threadShouldThrow();
315	>	} catch (BrokenBarrierException success) {}
316	>	catch (Exception b) {
317	>	threadUnexpectedException();
318	>	}
319	>	}
320	>	});
321	>	Thread t2 = new Thread(new Runnable() {
322	>	public void run() {
323	>	try {
324	>	c.await();
325		threadShouldThrow();
326	<	} catch(TimeoutException success){
327	<	} catch(Exception b){
328	<	threadFail("should throw TOE");
211	<
326	>	} catch (BrokenBarrierException success) {
327	>	} catch (Exception i) {
328	>	threadUnexpectedException();
329		}
330		}
331		});
332		try {
333	+	t1.start();
334	+	t2.start();
335	+	Thread.sleep(SHORT_DELAY_MS);
336	+	c.reset();
337	+	t1.join();
338	+	t2.join();
339	+	} catch (InterruptedException e) {
340	+	unexpectedException();
341	+	}
342	+	}
343	+
344	+	/**
345	+	* A reset before threads enter barrier does not throw
346	+	* BrokenBarrierException
347	+	*/
348	+	public void testReset_NoBrokenBarrier() {
349	+	final CyclicBarrier c = new CyclicBarrier(3);
350	+	Thread t1 = new Thread(new Runnable() {
351	+	public void run() {
352	+	try {
353	+	c.await();
354	+	} catch (Exception b) {
355	+	threadUnexpectedException();
356	+	}
357	+	}
358	+	});
359	+	Thread t2 = new Thread(new Runnable() {
360	+	public void run() {
361	+	try {
362	+	c.await();
363	+	} catch (Exception i) {
364	+	threadUnexpectedException();
365	+	}
366	+	}
367	+	});
368	+	try {
369	+	c.reset();
370	+	t1.start();
371	+	t2.start();
372	+	c.await();
373	+	t1.join();
374	+	t2.join();
375	+	} catch (Exception e) {
376	+	unexpectedException();
377	+	}
378	+	}
379	+
380	+	/**
381	+	* All threads block while a barrier is broken.
382	+	*/
383	+	public void testReset_Leakage() {
384	+	try {
385	+	final CyclicBarrier c = new CyclicBarrier(2);
386	+	final AtomicBoolean done = new AtomicBoolean();
387	+	Thread t = new Thread() {
388	+	public void run() {
389	+	while (!done.get()) {
390	+	try {
391	+	while (c.isBroken())
392	+	c.reset();
393	+
394	+	c.await();
395	+	threadFail("await should not return");
396	+	}
397	+	catch (BrokenBarrierException e) {
398	+	}
399	+	catch (InterruptedException ie) {
400	+	}
401	+	}
402	+	}
403	+	};
404	+
405		t.start();
406	<	t.join();
407	<	} catch(InterruptedException e){
406	>	for ( int i = 0; i < 4; i++) {
407	>	Thread.sleep(SHORT_DELAY_MS);
408	>	t.interrupt();
409	>	}
410	>	done.set(true);
411	>	t.interrupt();
412	>	}
413	>	catch (Exception ex) {
414	>	unexpectedException();
415	>	}
416	>	}
417	>
418	>	/**
419	>	* Reset of a non-broken barrier does not break barrier
420	>	*/
421	>	public void testResetWithoutBreakage() {
422	>	try {
423	>	final CyclicBarrier start = new CyclicBarrier(3);
424	>	final CyclicBarrier barrier = new CyclicBarrier(3);
425	>	for (int i = 0; i < 3; i++) {
426	>	Thread t1 = new Thread(new Runnable() {
427	>	public void run() {
428	>	try { start.await(); }
429	>	catch (Exception ie) {
430	>	threadFail("start barrier");
431	>	}
432	>	try { barrier.await(); }
433	>	catch (Throwable thrown) {
434	>	unexpectedException();
435	>	}}});
436	>
437	>	Thread t2 = new Thread(new Runnable() {
438	>	public void run() {
439	>	try { start.await(); }
440	>	catch (Exception ie) {
441	>	threadFail("start barrier");
442	>	}
443	>	try { barrier.await(); }
444	>	catch (Throwable thrown) {
445	>	unexpectedException();
446	>	}}});
447	>
448	>
449	>	t1.start();
450	>	t2.start();
451	>	try { start.await(); }
452	>	catch (Exception ie) { threadFail("start barrier"); }
453	>	barrier.await();
454	>	t1.join();
455	>	t2.join();
456	>	assertFalse(barrier.isBroken());
457	>	assertEquals(0, barrier.getNumberWaiting());
458	>	if (i == 1) barrier.reset();
459	>	assertFalse(barrier.isBroken());
460	>	assertEquals(0, barrier.getNumberWaiting());
461	>	}
462	>	}
463	>	catch (Exception ex) {
464	>	unexpectedException();
465	>	}
466	>	}
467	>
468	>	/**
469	>	* Reset of a barrier after interruption reinitializes it.
470	>	*/
471	>	public void testResetAfterInterrupt() {
472	>	try {
473	>	final CyclicBarrier start = new CyclicBarrier(3);
474	>	final CyclicBarrier barrier = new CyclicBarrier(3);
475	>	for (int i = 0; i < 2; i++) {
476	>	Thread t1 = new Thread(new Runnable() {
477	>	public void run() {
478	>	try { start.await(); }
479	>	catch (Exception ie) {
480	>	threadFail("start barrier");
481	>	}
482	>	try { barrier.await(); }
483	>	catch (InterruptedException ok) {}
484	>	catch (Throwable thrown) {
485	>	unexpectedException();
486	>	}}});
487	>
488	>	Thread t2 = new Thread(new Runnable() {
489	>	public void run() {
490	>	try { start.await(); }
491	>	catch (Exception ie) {
492	>	threadFail("start barrier");
493	>	}
494	>	try { barrier.await(); }
495	>	catch (BrokenBarrierException ok) {}
496	>	catch (Throwable thrown) {
497	>	unexpectedException();
498	>	}}});
499	>
500	>	t1.start();
501	>	t2.start();
502	>	try { start.await(); }
503	>	catch (Exception ie) { threadFail("start barrier"); }
504	>	t1.interrupt();
505	>	t1.join();
506	>	t2.join();
507	>	assertTrue(barrier.isBroken());
508	>	assertEquals(0, barrier.getNumberWaiting());
509	>	barrier.reset();
510	>	assertFalse(barrier.isBroken());
511	>	assertEquals(0, barrier.getNumberWaiting());
512	>	}
513	>	}
514	>	catch (Exception ex) {
515	>	unexpectedException();
516	>	}
517	>	}
518	>
519	>	/**
520	>	* Reset of a barrier after timeout reinitializes it.
521	>	*/
522	>	public void testResetAfterTimeout() {
523	>	try {
524	>	final CyclicBarrier start = new CyclicBarrier(3);
525	>	final CyclicBarrier barrier = new CyclicBarrier(3);
526	>	for (int i = 0; i < 2; i++) {
527	>	Thread t1 = new Thread(new Runnable() {
528	>	public void run() {
529	>	try { start.await(); }
530	>	catch (Exception ie) {
531	>	threadFail("start barrier");
532	>	}
533	>	try { barrier.await(MEDIUM_DELAY_MS, MILLISECONDS); }
534	>	catch (TimeoutException ok) {}
535	>	catch (Throwable thrown) {
536	>	unexpectedException();
537	>	}}});
538	>
539	>	Thread t2 = new Thread(new Runnable() {
540	>	public void run() {
541	>	try { start.await(); }
542	>	catch (Exception ie) {
543	>	threadFail("start barrier");
544	>	}
545	>	try { barrier.await(); }
546	>	catch (BrokenBarrierException ok) {}
547	>	catch (Throwable thrown) {
548	>	unexpectedException();
549	>	}}});
550	>
551	>	t1.start();
552	>	t2.start();
553	>	try { start.await(); }
554	>	catch (Exception ie) { threadFail("start barrier"); }
555	>	t1.join();
556	>	t2.join();
557	>	assertTrue(barrier.isBroken());
558	>	assertEquals(0, barrier.getNumberWaiting());
559	>	barrier.reset();
560	>	assertFalse(barrier.isBroken());
561	>	assertEquals(0, barrier.getNumberWaiting());
562	>	}
563	>	}
564	>	catch (Exception ex) {
565	>	unexpectedException();
566	>	}
567	>	}
568	>
569	>
570	>	/**
571	>	* Reset of a barrier after a failed command reinitializes it.
572	>	*/
573	>	public void testResetAfterCommandException() {
574	>	try {
575	>	final CyclicBarrier start = new CyclicBarrier(3);
576	>	final CyclicBarrier barrier =
577	>	new CyclicBarrier(3, new Runnable() {
578	>	public void run() {
579	>	throw new NullPointerException(); }});
580	>	for (int i = 0; i < 2; i++) {
581	>	Thread t1 = new Thread(new Runnable() {
582	>	public void run() {
583	>	try { start.await(); }
584	>	catch (Exception ie) {
585	>	threadFail("start barrier");
586	>	}
587	>	try { barrier.await(); }
588	>	catch (BrokenBarrierException ok) {}
589	>	catch (Throwable thrown) {
590	>	unexpectedException();
591	>	}}});
592	>
593	>	Thread t2 = new Thread(new Runnable() {
594	>	public void run() {
595	>	try { start.await(); }
596	>	catch (Exception ie) {
597	>	threadFail("start barrier");
598	>	}
599	>	try { barrier.await(); }
600	>	catch (BrokenBarrierException ok) {}
601	>	catch (Throwable thrown) {
602	>	unexpectedException();
603	>	}}});
604	>
605	>	t1.start();
606	>	t2.start();
607	>	try { start.await(); }
608	>	catch (Exception ie) { threadFail("start barrier"); }
609	>	while (barrier.getNumberWaiting() < 2) { Thread.yield(); }
610	>	try { barrier.await(); }
611	>	catch (Exception ok) { }
612	>	t1.join();
613	>	t2.join();
614	>	assertTrue(barrier.isBroken());
615	>	assertEquals(0, barrier.getNumberWaiting());
616	>	barrier.reset();
617	>	assertFalse(barrier.isBroken());
618	>	assertEquals(0, barrier.getNumberWaiting());
619	>	}
620	>	}
621	>	catch (Exception ex) {
622		unexpectedException();
623		}
624		}
222	–
625		}

Diff Legend

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