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.1 by dl, Sun Aug 31 19:24:54 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 TestCase{
13	<
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		}
17	–
18	–
20		public static Test suite() {
21	<	return new TestSuite(CyclicBarrierTest.class);
21	>	return new TestSuite(CyclicBarrierTest.class);
22		}
22	–
23	–	private static long SHORT_DELAY_MS = 100;
24	–	private static long MEDIUM_DELAY_MS = 1000;
25	–	private static long LONG_DELAY_MS = 10000;
23
24	<	public void testConstructor1(){
25	<	try{
24	>	private volatile int countAction;
25	>	private class MyAction implements Runnable {
26	>	public void run() { ++countAction; }
27	>	}
28	>
29	>	/**
30	>	* Creating with negative parties throws IAE
31	>	*/
32	>	public void testConstructor1() {
33	>	try {
34		new CyclicBarrier(-1, (Runnable)null);
35	<	fail("should throw");
36	<	} catch(IllegalArgumentException e){}
35	>	shouldThrow();
36	>	} catch (IllegalArgumentException e) {}
37		}
38
39	<	public void testConstructor2(){
40	<	try{
39	>	/**
40	>	* Creating with negative parties and no action throws IAE
41	>	*/
42	>	public void testConstructor2() {
43	>	try {
44		new CyclicBarrier(-1);
45	<	fail("should throw");
46	<	} catch(IllegalArgumentException e){}
45	>	shouldThrow();
46	>	} catch (IllegalArgumentException e) {}
47		}
48
49	<	public void testConstructor3(){
49	>	/**
50	>	* getParties returns the number of parties given in constructor
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
58	+	/**
59	+	* A 1-party barrier triggers after single await
60	+	*/
61		public void testSingleParty() {
62		try {
63		CyclicBarrier b = new CyclicBarrier(1);
#	Line 53 | Line 67 | public class CyclicBarrierTest extends T
67		b.await();
68		assertEquals(0, b.getNumberWaiting());
69		}
70	<	catch(Exception e) {
71	<	fail("unexpected exception");
70	>	catch (Exception e) {
71	>	unexpectedException();
72		}
73		}
60	–
61	–	private volatile int countAction;
62	–	private class MyAction implements Runnable {
63	–	public void run() { ++countAction; }
64	–	}
74
75	+	/**
76	+	* The supplied barrier action is run at barrier
77	+	*/
78		public void testBarrierAction() {
79		try {
80		countAction = 0;
#	Line 74 | Line 86 | public class CyclicBarrierTest extends T
86		assertEquals(0, b.getNumberWaiting());
87		assertEquals(countAction, 2);
88		}
89	<	catch(Exception e) {
90	<	fail("unexpected exception");
89	>	catch (Exception e) {
90	>	unexpectedException();
91		}
92		}
93
94	<
95	<	public void testTwoParties(){
94	>	/**
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){
107	<	fail("unexpected exception");
106	>	} catch (Exception e) {
107	>	threadUnexpectedException();
108		}}});
109
110		try {
#	Line 100 | Line 114 | public class CyclicBarrierTest extends T
114		b.await();
115		b.await();
116		t.join();
117	<	} catch(Exception e){
118	<	fail("unexpected exception");
117	>	} catch (Exception e) {
118	>	unexpectedException();
119		}
120		}
121
122
123	<	public void testAwait1_Interrupted_BrokenBarrier(){
123	>	/**
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);
129		Thread t1 = new Thread(new Runnable() {
130	<	public void run(){
131	<	try{
130	>	public void run() {
131	>	try {
132		c.await();
133	<	fail("should throw");
134	<	} catch(InterruptedException success){}
135	<	catch(Exception b){
136	<	fail("should throw IE");
133	>	threadShouldThrow();
134	>	} catch (InterruptedException success) {}
135	>	catch (Exception b) {
136	>	threadUnexpectedException();
137		}
138		}
139		});
140	<	Thread t2 = new Thread(new Runnable(){
141	<	public void run(){
142	<	try{
140	>	Thread t2 = new Thread(new Runnable() {
141	>	public void run() {
142	>	try {
143		c.await();
144	<	fail("should throw");
145	<	} catch(BrokenBarrierException success){
146	<	} catch(Exception i){
147	<	fail("should throw BBE");
144	>	threadShouldThrow();
145	>	} catch (BrokenBarrierException success) {
146	>	} catch (Exception i) {
147	>	threadUnexpectedException();
148		}
149		}
150		});
#	Line 135 | Line 153 | public class CyclicBarrierTest extends T
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){
159	<	fail("unexpected exception");
158	>	} catch (InterruptedException e) {
159	>	unexpectedException();
160		}
161		}
162
163	<	public void testAwait2_Interrupted_BrokenBarrier(){
164	<	final CyclicBarrier c = new CyclicBarrier(3);
163	>	/**
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);
169		Thread t1 = new Thread(new Runnable() {
170	<	public void run(){
171	<	try{
172	<	c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
173	<	fail("should throw");
174	<	} catch(InterruptedException success){
175	<	} catch(Exception b){
176	<	fail("should throw IE");
170	>	public void run() {
171	>	try {
172	>	c.await(LONG_DELAY_MS, MILLISECONDS);
173	>	threadShouldThrow();
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	<	fail("should throw");
185	<	} catch(BrokenBarrierException success){
186	<	} catch(Exception i){
187	<	fail("should throw BBE");
180	>	Thread t2 = new Thread(new Runnable() {
181	>	public void run() {
182	>	try {
183	>	c.await(LONG_DELAY_MS, MILLISECONDS);
184	>	threadShouldThrow();
185	>	} catch (BrokenBarrierException success) {
186	>	} catch (Exception i) {
187	>	threadUnexpectedException();
188		}
189		}
190		});
#	Line 171 | Line 193 | public class CyclicBarrierTest extends T
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){
199	<	fail("unexpected exception");
198	>	} catch (InterruptedException e) {
199	>	unexpectedException();
200		}
201		}
202	<
203	<	public void testAwait3_TimeOutException(){
202	>
203	>	/**
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);
212	<	fail("should throw");
213	<	} catch(TimeoutException success){
214	<	} catch(Exception b){
215	<	fail("should throw TOE");
216	<
209	>	public void run() {
210	>	try {
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	<	fail("unexpected exception");
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 (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	>	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		}
202	–
625		}

Diff Legend

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