test/tck/CyclicBarrierTest.java

/*
 * Written by members of JCP JSR-166 Expert Group and released to the
 * public domain. Use, modify, and redistribute this code in any way
 * without acknowledgement. Other contributors include Andrew Wright,
 * Jeffrey Hayes, Pat Fischer, Mike Judd.
 */

import junit.framework.*;
import java.util.*;
import java.util.concurrent.*;

public class CyclicBarrierTest extends JSR166TestCase{
    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());  
    }
    public static Test suite() {
        return new TestSuite(CyclicBarrierTest.class);
    }

    private volatile int countAction;
    private class MyAction implements Runnable {
        public void run() { ++countAction; }
    }
    
    /**
     * Creating with negative parties throws IAE
     */
    public void testConstructor1() {
        try {
            new CyclicBarrier(-1, (Runnable)null);
            shouldThrow();
        } catch(IllegalArgumentException e){}
    }

    /**
     * Creating with negative parties and no action throws IAE
     */
    public void testConstructor2() {
        try {
            new CyclicBarrier(-1);
            shouldThrow();
        } catch(IllegalArgumentException e){}
    }

    /**
     * getParties returns the number of parties given in constructor
     */
    public void testGetParties() {
        CyclicBarrier b = new CyclicBarrier(2);
        assertEquals(2, b.getParties());
        assertEquals(0, b.getNumberWaiting());
    }

    /**
     * A 1-party barrier triggers after single await
     */
    public void testSingleParty() {
        try {
            CyclicBarrier b = new CyclicBarrier(1);
            assertEquals(1, b.getParties());
            assertEquals(0, b.getNumberWaiting());
            b.await();
            b.await();
            assertEquals(0, b.getNumberWaiting());
        }
        catch(Exception e) {
            unexpectedException();
        }
    }
    
    /**
     * The supplied barrier action is run at barrier
     */
    public void testBarrierAction() {
        try {
            countAction = 0;
            CyclicBarrier b = new CyclicBarrier(1, new MyAction());
            assertEquals(1, b.getParties());
            assertEquals(0, b.getNumberWaiting());
            b.await();
            b.await();
            assertEquals(0, b.getNumberWaiting());
            assertEquals(countAction, 2);
        }
        catch(Exception e) {
            unexpectedException();
        }
    }

    /**
     * A 2-party/thread barrier triggers after both threads invoke await
     */
    public void testTwoParties() {
        final CyclicBarrier b = new CyclicBarrier(2);
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        b.await();
                        b.await();
                        b.await();
                        b.await();
                    } catch(Exception e){
                        threadUnexpectedException();
                    }}});

        try {
            t.start();
            b.await();
            b.await();
            b.await();
            b.await();
            t.join();
        } catch(Exception e){
            unexpectedException();
        }
    }


    /**
     * An interruption in one party causes others waiting in await to
     * throw BrokenBarrierException
     */
    public void testAwait1_Interrupted_BrokenBarrier() {
        final CyclicBarrier c = new CyclicBarrier(3);
        Thread t1 = new Thread(new Runnable() {
                public void run() {
                    try {
                        c.await();
                        threadShouldThrow();
                    } catch(InterruptedException success){}                
                    catch(Exception b){
                        threadUnexpectedException();
                    }
                }
            });
        Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        c.await();
                        threadShouldThrow();                        
                    } catch(BrokenBarrierException success){
                    } catch(Exception i){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t1.start();
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            t1.interrupt();
            t1.join(); 
            t2.join();
        } catch(InterruptedException e){
            unexpectedException();
        }
    }

    /**
     * An interruption in one party causes others waiting in timed await to
     * throw BrokenBarrierException
     */
    public void testAwait2_Interrupted_BrokenBarrier() {
      final CyclicBarrier c = new CyclicBarrier(3);
        Thread t1 = new Thread(new Runnable() {
                public void run() {
                    try {
                        c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadShouldThrow();
                    } catch(InterruptedException success){
                    } catch(Exception b){
                        threadUnexpectedException();
                    }
                }
            });
        Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadShouldThrow();                        
                    } catch(BrokenBarrierException success){
                    } catch(Exception i){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t1.start();
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            t1.interrupt();
            t1.join(); 
            t2.join();
        } catch(InterruptedException e){
            unexpectedException();
        }
    }
    
    /**
     * A timeout in timed await throws TimeoutException
     */
    public void testAwait3_TimeOutException() {
        final CyclicBarrier c = new CyclicBarrier(2);
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadShouldThrow();
                    } catch(TimeoutException success){
                    } catch(Exception b){
                        threadUnexpectedException();
                        
                    }
                }
            });
        try {
            t.start();
            t.join(); 
        } catch(InterruptedException e){
            unexpectedException();
        }
    }

    /**
     * A timeout in one party causes others waiting in timed await to
     * throw BrokenBarrierException
     */
    public void testAwait4_Timeout_BrokenBarrier() {
      final CyclicBarrier c = new CyclicBarrier(3);
        Thread t1 = new Thread(new Runnable() {
                public void run() {
                    try {
                        c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadShouldThrow();
                    } catch(TimeoutException success){
                    } catch(Exception b){
                        threadUnexpectedException();
                    }
                }
            });
        Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadShouldThrow();                        
                    } catch(BrokenBarrierException success){
                    } catch(Exception i){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t1.start();
            t2.start();
            t1.join(); 
            t2.join();
        } catch(InterruptedException e){
            unexpectedException();
        }
    }

    /**
     * A timeout in one party causes others waiting in await to
     * throw BrokenBarrierException
     */
    public void testAwait5_Timeout_BrokenBarrier() {
      final CyclicBarrier c = new CyclicBarrier(3);
        Thread t1 = new Thread(new Runnable() {
                public void run() {
                    try {
                        c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadShouldThrow();
                    } catch(TimeoutException success){
                    } catch(Exception b){
                        threadUnexpectedException();
                    }
                }
            });
        Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        c.await();
                        threadShouldThrow();                        
                    } catch(BrokenBarrierException success){
                    } catch(Exception i){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t1.start();
            t2.start();
            t1.join(); 
            t2.join();
        } catch(InterruptedException e){
            unexpectedException();
        }
    }
    
    /**
     * A reset of an active barrier causes waiting threads to throw
     * BrokenBarrierException
     */
    public void testReset_BrokenBarrier() {
        final CyclicBarrier c = new CyclicBarrier(3);
        Thread t1 = new Thread(new Runnable() {
                public void run() {
                    try {
                        c.await();
                        threadShouldThrow();
                    } catch(BrokenBarrierException success){}                
                    catch(Exception b){
                        threadUnexpectedException();
                    }
                }
            });
        Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        c.await();
                        threadShouldThrow();                        
                    } catch(BrokenBarrierException success){
                    } catch(Exception i){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t1.start();
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            c.reset();
            t1.join(); 
            t2.join();
        } catch(InterruptedException e){
            unexpectedException();
        }
    }

    /**
     * A reset before threads enter barrier does not throw
     * BrokenBarrierException
     */
    public void testReset_NoBrokenBarrier() {
        final CyclicBarrier c = new CyclicBarrier(3);
        Thread t1 = new Thread(new Runnable() {
                public void run() {
                    try {
                        c.await();
                    } catch(Exception b){
                        threadUnexpectedException();
                    }
                }
            });
        Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        c.await();
                    } catch(Exception i){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            c.reset();
            t1.start();
            t2.start();
            c.await();
            t1.join(); 
            t2.join();
        } catch(Exception e){
            unexpectedException();
        }
    }

}
Revision:	1.5
Committed:	Sun Oct 5 23:00:40 2003 UTC (20 years, 7 months ago) by dl
Branch:	MAIN
CVS Tags:	JSR166_NOV3_FREEZE, JSR166_DEC9_PRE_ES_SUBMIT, JSR166_DEC9_POST_ES_SUBMIT
Changes since 1.4:	+78 -2 lines
Log Message:	Added tests and documentation
#	Content
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.
6	*/
7
8	import junit.framework.*;
9	import java.util.*;
10	import java.util.concurrent.*;
11
12	public class CyclicBarrierTest extends JSR166TestCase{
13	public static void main(String[] args) {
14	junit.textui.TestRunner.run (suite());
15	}
16	public static Test suite() {
17	return new TestSuite(CyclicBarrierTest.class);
18	}
19
20	private volatile int countAction;
21	private class MyAction implements Runnable {
22	public void run() { ++countAction; }
23	}
24
25	/**
26	* Creating with negative parties throws IAE
27	*/
28	public void testConstructor1() {
29	try {
30	new CyclicBarrier(-1, (Runnable)null);
31	shouldThrow();
32	} catch(IllegalArgumentException e){}
33	}
34
35	/**
36	* Creating with negative parties and no action throws IAE
37	*/
38	public void testConstructor2() {
39	try {
40	new CyclicBarrier(-1);
41	shouldThrow();
42	} catch(IllegalArgumentException e){}
43	}
44
45	/**
46	* getParties returns the number of parties given in constructor
47	*/
48	public void testGetParties() {
49	CyclicBarrier b = new CyclicBarrier(2);
50	assertEquals(2, b.getParties());
51	assertEquals(0, b.getNumberWaiting());
52	}
53
54	/**
55	* A 1-party barrier triggers after single await
56	*/
57	public void testSingleParty() {
58	try {
59	CyclicBarrier b = new CyclicBarrier(1);
60	assertEquals(1, b.getParties());
61	assertEquals(0, b.getNumberWaiting());
62	b.await();
63	b.await();
64	assertEquals(0, b.getNumberWaiting());
65	}
66	catch(Exception e) {
67	unexpectedException();
68	}
69	}
70
71	/**
72	* The supplied barrier action is run at barrier
73	*/
74	public void testBarrierAction() {
75	try {
76	countAction = 0;
77	CyclicBarrier b = new CyclicBarrier(1, new MyAction());
78	assertEquals(1, b.getParties());
79	assertEquals(0, b.getNumberWaiting());
80	b.await();
81	b.await();
82	assertEquals(0, b.getNumberWaiting());
83	assertEquals(countAction, 2);
84	}
85	catch(Exception e) {
86	unexpectedException();
87	}
88	}
89
90	/**
91	* A 2-party/thread barrier triggers after both threads invoke await
92	*/
93	public void testTwoParties() {
94	final CyclicBarrier b = new CyclicBarrier(2);
95	Thread t = new Thread(new Runnable() {
96	public void run() {
97	try {
98	b.await();
99	b.await();
100	b.await();
101	b.await();
102	} catch(Exception e){
103	threadUnexpectedException();
104	}}});
105
106	try {
107	t.start();
108	b.await();
109	b.await();
110	b.await();
111	b.await();
112	t.join();
113	} catch(Exception e){
114	unexpectedException();
115	}
116	}
117
118
119	/**
120	* An interruption in one party causes others waiting in await to
121	* throw BrokenBarrierException
122	*/
123	public void testAwait1_Interrupted_BrokenBarrier() {
124	final CyclicBarrier c = new CyclicBarrier(3);
125	Thread t1 = new Thread(new Runnable() {
126	public void run() {
127	try {
128	c.await();
129	threadShouldThrow();
130	} catch(InterruptedException success){}
131	catch(Exception b){
132	threadUnexpectedException();
133	}
134	}
135	});
136	Thread t2 = new Thread(new Runnable() {
137	public void run() {
138	try {
139	c.await();
140	threadShouldThrow();
141	} catch(BrokenBarrierException success){
142	} catch(Exception i){
143	threadUnexpectedException();
144	}
145	}
146	});
147	try {
148	t1.start();
149	t2.start();
150	Thread.sleep(SHORT_DELAY_MS);
151	t1.interrupt();
152	t1.join();
153	t2.join();
154	} catch(InterruptedException e){
155	unexpectedException();
156	}
157	}
158
159	/**
160	* An interruption in one party causes others waiting in timed await to
161	* throw BrokenBarrierException
162	*/
163	public void testAwait2_Interrupted_BrokenBarrier() {
164	final CyclicBarrier c = new CyclicBarrier(3);
165	Thread t1 = new Thread(new Runnable() {
166	public void run() {
167	try {
168	c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
169	threadShouldThrow();
170	} catch(InterruptedException success){
171	} catch(Exception b){
172	threadUnexpectedException();
173	}
174	}
175	});
176	Thread t2 = new Thread(new Runnable() {
177	public void run() {
178	try {
179	c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
180	threadShouldThrow();
181	} catch(BrokenBarrierException success){
182	} catch(Exception i){
183	threadUnexpectedException();
184	}
185	}
186	});
187	try {
188	t1.start();
189	t2.start();
190	Thread.sleep(SHORT_DELAY_MS);
191	t1.interrupt();
192	t1.join();
193	t2.join();
194	} catch(InterruptedException e){
195	unexpectedException();
196	}
197	}
198
199	/**
200	* A timeout in timed await throws TimeoutException
201	*/
202	public void testAwait3_TimeOutException() {
203	final CyclicBarrier c = new CyclicBarrier(2);
204	Thread t = new Thread(new Runnable() {
205	public void run() {
206	try {
207	c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
208	threadShouldThrow();
209	} catch(TimeoutException success){
210	} catch(Exception b){
211	threadUnexpectedException();
212
213	}
214	}
215	});
216	try {
217	t.start();
218	t.join();
219	} catch(InterruptedException e){
220	unexpectedException();
221	}
222	}
223
224	/**
225	* A timeout in one party causes others waiting in timed await to
226	* throw BrokenBarrierException
227	*/
228	public void testAwait4_Timeout_BrokenBarrier() {
229	final CyclicBarrier c = new CyclicBarrier(3);
230	Thread t1 = new Thread(new Runnable() {
231	public void run() {
232	try {
233	c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
234	threadShouldThrow();
235	} catch(TimeoutException success){
236	} catch(Exception b){
237	threadUnexpectedException();
238	}
239	}
240	});
241	Thread t2 = new Thread(new Runnable() {
242	public void run() {
243	try {
244	c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
245	threadShouldThrow();
246	} catch(BrokenBarrierException success){
247	} catch(Exception i){
248	threadUnexpectedException();
249	}
250	}
251	});
252	try {
253	t1.start();
254	t2.start();
255	t1.join();
256	t2.join();
257	} catch(InterruptedException e){
258	unexpectedException();
259	}
260	}
261
262	/**
263	* A timeout in one party causes others waiting in await to
264	* throw BrokenBarrierException
265	*/
266	public void testAwait5_Timeout_BrokenBarrier() {
267	final CyclicBarrier c = new CyclicBarrier(3);
268	Thread t1 = new Thread(new Runnable() {
269	public void run() {
270	try {
271	c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
272	threadShouldThrow();
273	} catch(TimeoutException success){
274	} catch(Exception b){
275	threadUnexpectedException();
276	}
277	}
278	});
279	Thread t2 = new Thread(new Runnable() {
280	public void run() {
281	try {
282	c.await();
283	threadShouldThrow();
284	} catch(BrokenBarrierException success){
285	} catch(Exception i){
286	threadUnexpectedException();
287	}
288	}
289	});
290	try {
291	t1.start();
292	t2.start();
293	t1.join();
294	t2.join();
295	} catch(InterruptedException e){
296	unexpectedException();
297	}
298	}
299
300	/**
301	* A reset of an active barrier causes waiting threads to throw
302	* BrokenBarrierException
303	*/
304	public void testReset_BrokenBarrier() {
305	final CyclicBarrier c = new CyclicBarrier(3);
306	Thread t1 = new Thread(new Runnable() {
307	public void run() {
308	try {
309	c.await();
310	threadShouldThrow();
311	} catch(BrokenBarrierException success){}
312	catch(Exception b){
313	threadUnexpectedException();
314	}
315	}
316	});
317	Thread t2 = new Thread(new Runnable() {
318	public void run() {
319	try {
320	c.await();
321	threadShouldThrow();
322	} catch(BrokenBarrierException success){
323	} catch(Exception i){
324	threadUnexpectedException();
325	}
326	}
327	});
328	try {
329	t1.start();
330	t2.start();
331	Thread.sleep(SHORT_DELAY_MS);
332	c.reset();
333	t1.join();
334	t2.join();
335	} catch(InterruptedException e){
336	unexpectedException();
337	}
338	}
339
340	/**
341	* A reset before threads enter barrier does not throw
342	* BrokenBarrierException
343	*/
344	public void testReset_NoBrokenBarrier() {
345	final CyclicBarrier c = new CyclicBarrier(3);
346	Thread t1 = new Thread(new Runnable() {
347	public void run() {
348	try {
349	c.await();
350	} catch(Exception b){
351	threadUnexpectedException();
352	}
353	}
354	});
355	Thread t2 = new Thread(new Runnable() {
356	public void run() {
357	try {
358	c.await();
359	} catch(Exception i){
360	threadUnexpectedException();
361	}
362	}
363	});
364	try {
365	c.reset();
366	t1.start();
367	t2.start();
368	c.await();
369	t1.join();
370	t2.join();
371	} catch(Exception e){
372	unexpectedException();
373	}
374	}
375
376	}