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.5 by dl, Sun Oct 5 23:00:40 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		* Creating with negative parties throws IAE
31		*/
#	Line 29 | Line 33 | public class CyclicBarrierTest extends J
33		try {
34		new CyclicBarrier(-1, (Runnable)null);
35		shouldThrow();
36	<	} catch(IllegalArgumentException e){}
36	>	} catch (IllegalArgumentException e) {}
37		}
38
39		/**
#	Line 39 | Line 43 | public class CyclicBarrierTest extends J
43		try {
44		new CyclicBarrier(-1);
45		shouldThrow();
46	<	} catch(IllegalArgumentException e){}
46	>	} catch (IllegalArgumentException e) {}
47		}
48
49		/**
#	Line 47 | Line 51 | public class CyclicBarrierTest extends J
51		*/
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
#	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		* The supplied barrier action is run at barrier
77		*/
#	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		}
#	Line 92 | Line 96 | public class CyclicBarrierTest extends J
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 110 | 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		}
#	Line 127 | Line 131 | public class CyclicBarrierTest extends J
131		try {
132		c.await();
133		threadShouldThrow();
134	<	} catch(InterruptedException success){}
135	<	catch(Exception b){
134	>	} catch (InterruptedException success) {}
135	>	catch (Exception b) {
136		threadUnexpectedException();
137		}
138		}
#	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){
144	>	threadShouldThrow();
145	>	} catch (BrokenBarrierException success) {
146	>	} catch (Exception i) {
147		threadUnexpectedException();
148		}
149		}
#	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		}
#	Line 161 | Line 165 | public class CyclicBarrierTest extends J
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){
174	>	} catch (InterruptedException success) {
175	>	} catch (Exception b) {
176		threadUnexpectedException();
177		}
178		}
#	Line 176 | Line 180 | public class CyclicBarrierTest extends J
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){
183	>	c.await(LONG_DELAY_MS, MILLISECONDS);
184	>	threadShouldThrow();
185	>	} catch (BrokenBarrierException success) {
186	>	} catch (Exception i) {
187		threadUnexpectedException();
188		}
189		}
#	Line 189 | 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		* A timeout in timed await throws TimeoutException
205		*/
#	Line 204 | Line 208 | public class CyclicBarrierTest extends J
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){
213	>	} catch (TimeoutException success) {
214	>	} catch (Exception b) {
215		threadUnexpectedException();
216	<
216	>
217		}
218		}
219		});
220		try {
221		t.start();
222	<	t.join();
223	<	} catch(InterruptedException e){
222	>	t.join();
223	>	} catch (InterruptedException e) {
224		unexpectedException();
225		}
226		}
#	Line 226 | Line 230 | public class CyclicBarrierTest extends J
230		* throw BrokenBarrierException
231		*/
232		public void testAwait4_Timeout_BrokenBarrier() {
233	<	final CyclicBarrier c = new CyclicBarrier(3);
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, TimeUnit.MILLISECONDS);
237	>	c.await(SHORT_DELAY_MS, MILLISECONDS);
238		threadShouldThrow();
239	<	} catch(TimeoutException success){
240	<	} catch(Exception b){
239	>	} catch (TimeoutException success) {
240	>	} catch (Exception b) {
241		threadUnexpectedException();
242		}
243		}
#	Line 241 | Line 245 | public class CyclicBarrierTest extends J
245		Thread t2 = new Thread(new Runnable() {
246		public void run() {
247		try {
248	<	c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
249	<	threadShouldThrow();
250	<	} catch(BrokenBarrierException success){
251	<	} catch(Exception i){
248	>	c.await(MEDIUM_DELAY_MS, MILLISECONDS);
249	>	threadShouldThrow();
250	>	} catch (BrokenBarrierException success) {
251	>	} catch (Exception i) {
252		threadUnexpectedException();
253		}
254		}
#	Line 252 | Line 256 | public class CyclicBarrierTest extends J
256		try {
257		t1.start();
258		t2.start();
259	<	t1.join();
259	>	t1.join();
260		t2.join();
261	<	} catch(InterruptedException e){
261	>	} catch (InterruptedException e) {
262		unexpectedException();
263		}
264		}
#	Line 264 | Line 268 | public class CyclicBarrierTest extends J
268		* throw BrokenBarrierException
269		*/
270		public void testAwait5_Timeout_BrokenBarrier() {
271	<	final CyclicBarrier c = new CyclicBarrier(3);
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, TimeUnit.MILLISECONDS);
275	>	c.await(SHORT_DELAY_MS, MILLISECONDS);
276		threadShouldThrow();
277	<	} catch(TimeoutException success){
278	<	} catch(Exception b){
277	>	} catch (TimeoutException success) {
278	>	} catch (Exception b) {
279		threadUnexpectedException();
280		}
281		}
#	Line 280 | Line 284 | public class CyclicBarrierTest extends J
284		public void run() {
285		try {
286		c.await();
287	<	threadShouldThrow();
288	<	} catch(BrokenBarrierException success){
289	<	} catch(Exception i){
287	>	threadShouldThrow();
288	>	} catch (BrokenBarrierException success) {
289	>	} catch (Exception i) {
290		threadUnexpectedException();
291		}
292		}
#	Line 290 | Line 294 | public class CyclicBarrierTest extends J
294		try {
295		t1.start();
296		t2.start();
297	<	t1.join();
297	>	t1.join();
298		t2.join();
299	<	} catch(InterruptedException e){
299	>	} catch (InterruptedException e) {
300		unexpectedException();
301		}
302		}
303	<
303	>
304		/**
305		* A reset of an active barrier causes waiting threads to throw
306		* BrokenBarrierException
#	Line 308 | Line 312 | public class CyclicBarrierTest extends J
312		try {
313		c.await();
314		threadShouldThrow();
315	<	} catch(BrokenBarrierException success){}
316	<	catch(Exception b){
315	>	} catch (BrokenBarrierException success) {}
316	>	catch (Exception b) {
317		threadUnexpectedException();
318		}
319		}
#	Line 318 | Line 322 | public class CyclicBarrierTest extends J
322		public void run() {
323		try {
324		c.await();
325	<	threadShouldThrow();
326	<	} catch(BrokenBarrierException success){
327	<	} catch(Exception i){
325	>	threadShouldThrow();
326	>	} catch (BrokenBarrierException success) {
327	>	} catch (Exception i) {
328		threadUnexpectedException();
329		}
330		}
#	Line 330 | Line 334 | public class CyclicBarrierTest extends J
334		t2.start();
335		Thread.sleep(SHORT_DELAY_MS);
336		c.reset();
337	<	t1.join();
337	>	t1.join();
338		t2.join();
339	<	} catch(InterruptedException e){
339	>	} catch (InterruptedException e) {
340		unexpectedException();
341		}
342		}
#	Line 347 | Line 351 | public class CyclicBarrierTest extends J
351		public void run() {
352		try {
353		c.await();
354	<	} catch(Exception b){
354	>	} catch (Exception b) {
355		threadUnexpectedException();
356		}
357		}
#	Line 356 | Line 360 | public class CyclicBarrierTest extends J
360		public void run() {
361		try {
362		c.await();
363	<	} catch(Exception i){
363	>	} catch (Exception i) {
364		threadUnexpectedException();
365		}
366		}
#	Line 366 | Line 370 | public class CyclicBarrierTest extends J
370		t1.start();
371		t2.start();
372		c.await();
373	<	t1.join();
373	>	t1.join();
374		t2.join();
375	<	} catch(Exception e){
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	+	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	+	}
625		}

Diff Legend

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