ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/CyclicBarrierTest.java
(Generate patch)

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.5 by dl, Sun Oct 5 23:00:40 2003 UTC

# Line 9 | Line 9 | import junit.framework.*;
9   import java.util.*;
10   import java.util.concurrent.*;
11  
12 < public class CyclicBarrierTest extends TestCase{
13 <    
12 > public class CyclicBarrierTest extends JSR166TestCase{
13      public static void main(String[] args) {
14          junit.textui.TestRunner.run (suite());  
15      }
17 –    
18 –    
16      public static Test suite() {
17          return new TestSuite(CyclicBarrierTest.class);
18      }
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;
19  
20 <    public void testConstructor1(){
21 <        try{
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 <            fail("should throw");
31 >            shouldThrow();
32          } catch(IllegalArgumentException e){}
33      }
34  
35 <    public void testConstructor2(){
36 <        try{
35 >    /**
36 >     * Creating with negative parties and no action throws IAE
37 >     */
38 >    public void testConstructor2() {
39 >        try {
40              new CyclicBarrier(-1);
41 <            fail("should throw");
41 >            shouldThrow();
42          } catch(IllegalArgumentException e){}
43      }
44  
45 <    public void testConstructor3(){
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);
# Line 54 | Line 64 | public class CyclicBarrierTest extends T
64              assertEquals(0, b.getNumberWaiting());
65          }
66          catch(Exception e) {
67 <            fail("unexpected exception");
67 >            unexpectedException();
68          }
69      }
70      
71 <    private volatile int countAction;
72 <    private class MyAction implements Runnable {
73 <        public void run() { ++countAction; }
64 <    }
65 <
71 >    /**
72 >     * The supplied barrier action is run at barrier
73 >     */
74      public void testBarrierAction() {
75          try {
76              countAction = 0;
# Line 75 | Line 83 | public class CyclicBarrierTest extends T
83              assertEquals(countAction, 2);
84          }
85          catch(Exception e) {
86 <            fail("unexpected exception");
86 >            unexpectedException();
87          }
88      }
89  
90 <
91 <    public void testTwoParties(){
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(){
96 >                public void run() {
97                      try {
98                          b.await();
99                          b.await();
100                          b.await();
101                          b.await();
102                      } catch(Exception e){
103 <                        fail("unexpected exception");
103 >                        threadUnexpectedException();
104                      }}});
105  
106          try {
# Line 101 | Line 111 | public class CyclicBarrierTest extends T
111              b.await();
112              t.join();
113          } catch(Exception e){
114 <            fail("unexpected exception");
114 >            unexpectedException();
115          }
116      }
117  
118  
119 <    public void testAwait1_Interrupted_BrokenBarrier(){
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{
126 >                public void run() {
127 >                    try {
128                          c.await();
129 <                        fail("should throw");
129 >                        threadShouldThrow();
130                      } catch(InterruptedException success){}                
131                      catch(Exception b){
132 <                        fail("should throw IE");
132 >                        threadUnexpectedException();
133                      }
134                  }
135              });
136 <        Thread t2 = new Thread(new Runnable(){
137 <                public void run(){
138 <                    try{
136 >        Thread t2 = new Thread(new Runnable() {
137 >                public void run() {
138 >                    try {
139                          c.await();
140 <                        fail("should throw");                        
140 >                        threadShouldThrow();                        
141                      } catch(BrokenBarrierException success){
142                      } catch(Exception i){
143 <                        fail("should throw BBE");
143 >                        threadUnexpectedException();
144                      }
145                  }
146              });
# Line 138 | Line 152 | public class CyclicBarrierTest extends T
152              t1.join();
153              t2.join();
154          } catch(InterruptedException e){
155 <            fail("unexpected exception");
155 >            unexpectedException();
156          }
157      }
158  
159 <    public void testAwait2_Interrupted_BrokenBarrier(){
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{
166 >                public void run() {
167 >                    try {
168                          c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
169 <                        fail("should throw");
169 >                        threadShouldThrow();
170                      } catch(InterruptedException success){
171                      } catch(Exception b){
172 <                        fail("should throw IE");
172 >                        threadUnexpectedException();
173                      }
174                  }
175              });
176 <        Thread t2 = new Thread(new Runnable(){
177 <                public void run(){
178 <                    try{
176 >        Thread t2 = new Thread(new Runnable() {
177 >                public void run() {
178 >                    try {
179                          c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
180 <                        fail("should throw");                        
180 >                        threadShouldThrow();                        
181                      } catch(BrokenBarrierException success){
182                      } catch(Exception i){
183 <                        fail("should throw BBE");
183 >                        threadUnexpectedException();
184                      }
185                  }
186              });
# Line 174 | Line 192 | public class CyclicBarrierTest extends T
192              t1.join();
193              t2.join();
194          } catch(InterruptedException e){
195 <            fail("unexpected exception");
195 >            unexpectedException();
196          }
197      }
198      
199 <    public void testAwait3_TimeOutException(){
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{
205 >                public void run() {
206 >                    try {
207                          c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
208 <                        fail("should throw");
208 >                        threadShouldThrow();
209                      } catch(TimeoutException success){
210                      } catch(Exception b){
211 <                        fail("should throw TOE");
211 >                        threadUnexpectedException();
212                          
213                      }
214                  }
# Line 196 | Line 217 | public class CyclicBarrierTest extends T
217              t.start();
218              t.join();
219          } catch(InterruptedException e){
220 <            fail("unexpected exception");
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   }

Diff Legend

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