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.8 by dl, Mon Apr 25 15:04:50 2005 UTC vs.
Revision 1.13 by jsr166, Sat Nov 21 02:33:20 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 11 | Line 11 | 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 32 | 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 42 | 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 50 | 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 66 | 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 85 | 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 95 | 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 113 | 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 130 | 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 140 | 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 152 | 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 168 | Line 169 | public class CyclicBarrierTest extends J
169		Thread t1 = new Thread(new Runnable() {
170		public void run() {
171		try {
172	<	c.await(LONG_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 179 | Line 180 | public class CyclicBarrierTest extends J
180		Thread t2 = new Thread(new Runnable() {
181		public void run() {
182		try {
183	<	c.await(LONG_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 192 | 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 207 | 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 233 | Line 234 | public class CyclicBarrierTest extends J
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 244 | 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 255 | 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 271 | Line 272 | public class CyclicBarrierTest extends J
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 283 | 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 293 | 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 311 | 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 321 | 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 333 | 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 350 | 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 359 | 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 369 | 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		}
#	Line 389 | Line 390 | public class CyclicBarrierTest extends J
390		try {
391		while (c.isBroken())
392		c.reset();
393	<
393	>
394		c.await();
395		threadFail("await should not return");
396		}
#	Line 400 | Line 401 | public class CyclicBarrierTest extends J
401		}
402		}
403		};
404	<
404	>
405		t.start();
406	<	for( int i = 0; i < 4; i++) {
406	>	for ( int i = 0; i < 4; i++) {
407		Thread.sleep(SHORT_DELAY_MS);
408		t.interrupt();
409		}
#	Line 425 | Line 426 | public class CyclicBarrierTest extends J
426		Thread t1 = new Thread(new Runnable() {
427		public void run() {
428		try { start.await(); }
429	<	catch (Exception ie) {
430	<	threadFail("start barrier");
429	>	catch (Exception ie) {
430	>	threadFail("start barrier");
431		}
432		try { barrier.await(); }
433	<	catch (Throwable thrown) {
434	<	unexpectedException();
433	>	catch (Throwable thrown) {
434	>	unexpectedException();
435		}}});
436	<
436	>
437		Thread t2 = new Thread(new Runnable() {
438		public void run() {
439		try { start.await(); }
440	<	catch (Exception ie) {
441	<	threadFail("start barrier");
440	>	catch (Exception ie) {
441	>	threadFail("start barrier");
442		}
443		try { barrier.await(); }
444	<	catch (Throwable thrown) {
445	<	unexpectedException();
444	>	catch (Throwable thrown) {
445	>	unexpectedException();
446		}}});
447	<
448	<
447	>
448	>
449		t1.start();
450		t2.start();
451		try { start.await(); }
#	Line 463 | Line 464 | public class CyclicBarrierTest extends J
464		unexpectedException();
465		}
466		}
467	<
467	>
468		/**
469		* Reset of a barrier after interruption reinitializes it.
470		*/
#	Line 475 | Line 476 | public class CyclicBarrierTest extends J
476		Thread t1 = new Thread(new Runnable() {
477		public void run() {
478		try { start.await(); }
479	<	catch (Exception ie) {
480	<	threadFail("start barrier");
479	>	catch (Exception ie) {
480	>	threadFail("start barrier");
481		}
482		try { barrier.await(); }
483	<	catch(InterruptedException ok) {}
484	<	catch (Throwable thrown) {
485	<	unexpectedException();
483	>	catch (InterruptedException ok) {}
484	>	catch (Throwable thrown) {
485	>	unexpectedException();
486		}}});
487	<
487	>
488		Thread t2 = new Thread(new Runnable() {
489		public void run() {
490		try { start.await(); }
491	<	catch (Exception ie) {
492	<	threadFail("start barrier");
491	>	catch (Exception ie) {
492	>	threadFail("start barrier");
493		}
494		try { barrier.await(); }
495	<	catch(BrokenBarrierException ok) {}
496	<	catch (Throwable thrown) {
497	<	unexpectedException();
495	>	catch (BrokenBarrierException ok) {}
496	>	catch (Throwable thrown) {
497	>	unexpectedException();
498		}}});
499	<
499	>
500		t1.start();
501		t2.start();
502		try { start.await(); }
#	Line 514 | Line 515 | public class CyclicBarrierTest extends J
515		unexpectedException();
516		}
517		}
518	<
518	>
519		/**
520		* Reset of a barrier after timeout reinitializes it.
521		*/
#	Line 526 | Line 527 | public class CyclicBarrierTest extends J
527		Thread t1 = new Thread(new Runnable() {
528		public void run() {
529		try { start.await(); }
530	<	catch (Exception ie) {
531	<	threadFail("start barrier");
530	>	catch (Exception ie) {
531	>	threadFail("start barrier");
532		}
533	<	try { barrier.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); }
534	<	catch(TimeoutException ok) {}
535	<	catch (Throwable thrown) {
536	<	unexpectedException();
533	>	try { barrier.await(MEDIUM_DELAY_MS, MILLISECONDS); }
534	>	catch (TimeoutException ok) {}
535	>	catch (Throwable thrown) {
536	>	unexpectedException();
537		}}});
538	<
538	>
539		Thread t2 = new Thread(new Runnable() {
540		public void run() {
541		try { start.await(); }
542	<	catch (Exception ie) {
543	<	threadFail("start barrier");
542	>	catch (Exception ie) {
543	>	threadFail("start barrier");
544		}
545		try { barrier.await(); }
546	<	catch(BrokenBarrierException ok) {}
547	<	catch (Throwable thrown) {
548	<	unexpectedException();
546	>	catch (BrokenBarrierException ok) {}
547	>	catch (Throwable thrown) {
548	>	unexpectedException();
549		}}});
550	<
550	>
551		t1.start();
552		t2.start();
553		try { start.await(); }
#	Line 565 | Line 566 | public class CyclicBarrierTest extends J
566		}
567		}
568
569	<
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 =
576	>	final CyclicBarrier barrier =
577		new CyclicBarrier(3, new Runnable() {
578	<	public void run() {
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");
584	>	catch (Exception ie) {
585	>	threadFail("start barrier");
586		}
587		try { barrier.await(); }
588	<	catch(BrokenBarrierException ok) {}
589	<	catch (Throwable thrown) {
590	<	unexpectedException();
588	>	catch (BrokenBarrierException ok) {}
589	>	catch (Throwable thrown) {
590	>	unexpectedException();
591		}}});
592	<
592	>
593		Thread t2 = new Thread(new Runnable() {
594		public void run() {
595		try { start.await(); }
596	<	catch (Exception ie) {
597	<	threadFail("start barrier");
596	>	catch (Exception ie) {
597	>	threadFail("start barrier");
598		}
599		try { barrier.await(); }
600	<	catch(BrokenBarrierException ok) {}
601	<	catch (Throwable thrown) {
602	<	unexpectedException();
600	>	catch (BrokenBarrierException ok) {}
601	>	catch (Throwable thrown) {
602	>	unexpectedException();
603		}}});
604	<
604	>
605		t1.start();
606		t2.start();
607		try { start.await(); }

Diff Legend

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