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

Diff Legend

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