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.4 by dl, Thu Sep 25 11:02:41 2003 UTC vs.
Revision 1.9 by jsr166, Mon Nov 2 20:28:31 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{
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 52 | Line 55 | public class CyclicBarrierTest extends J
55      }
56  
57      /**
58 <     * A 1-party barrier triggers properly
58 >     * A 1-party barrier triggers after single await
59       */
60      public void testSingleParty() {
61          try {
# Line 67 | Line 70 | public class CyclicBarrierTest extends J
70              unexpectedException();
71          }
72      }
73 <    
73 >
74      /**
75       * The supplied barrier action is run at barrier
76       */
# Line 88 | Line 91 | public class CyclicBarrierTest extends J
91      }
92  
93      /**
94 <     * A 2-party/thread barrier triggers properly
94 >     * A 2-party/thread barrier triggers after both threads invoke await
95       */
96      public void testTwoParties() {
97          final CyclicBarrier b = new CyclicBarrier(2);
# Line 127 | Line 130 | public class CyclicBarrierTest extends J
130                      try {
131                          c.await();
132                          threadShouldThrow();
133 <                    } catch(InterruptedException success){}                
133 >                    } catch(InterruptedException success){}
134                      catch(Exception b){
135                          threadUnexpectedException();
136                      }
# Line 137 | Line 140 | public class CyclicBarrierTest extends J
140                  public void run() {
141                      try {
142                          c.await();
143 <                        threadShouldThrow();                        
143 >                        threadShouldThrow();
144                      } catch(BrokenBarrierException success){
145                      } catch(Exception i){
146                          threadUnexpectedException();
# 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){
158              unexpectedException();
# 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){
# 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();                        
182 >                        c.await(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
183 >                        threadShouldThrow();
184                      } catch(BrokenBarrierException success){
185                      } catch(Exception i){
186                          threadUnexpectedException();
# 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){
198              unexpectedException();
199          }
200      }
201 <    
201 >
202      /**
203       * A timeout in timed await throws TimeoutException
204       */
# Line 209 | Line 212 | public class CyclicBarrierTest extends J
212                      } catch(TimeoutException success){
213                      } catch(Exception b){
214                          threadUnexpectedException();
215 <                        
215 >
216                      }
217                  }
218              });
219          try {
220              t.start();
221 <            t.join();
221 >            t.join();
222          } catch(InterruptedException e){
223              unexpectedException();
224          }
225      }
226 <    
226 >
227 >    /**
228 >     * A timeout in one party causes others waiting in timed await to
229 >     * throw BrokenBarrierException
230 >     */
231 >    public void testAwait4_Timeout_BrokenBarrier() {
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){
240 >                        threadUnexpectedException();
241 >                    }
242 >                }
243 >            });
244 >        Thread t2 = new Thread(new Runnable() {
245 >                public void run() {
246 >                    try {
247 >                        c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
248 >                        threadShouldThrow();
249 >                    } catch(BrokenBarrierException success){
250 >                    } catch(Exception i){
251 >                        threadUnexpectedException();
252 >                    }
253 >                }
254 >            });
255 >        try {
256 >            t1.start();
257 >            t2.start();
258 >            t1.join();
259 >            t2.join();
260 >        } catch(InterruptedException e){
261 >            unexpectedException();
262 >        }
263 >    }
264 >
265 >    /**
266 >     * A timeout in one party causes others waiting in await to
267 >     * throw BrokenBarrierException
268 >     */
269 >    public void testAwait5_Timeout_BrokenBarrier() {
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){
278 >                        threadUnexpectedException();
279 >                    }
280 >                }
281 >            });
282 >        Thread t2 = new Thread(new Runnable() {
283 >                public void run() {
284 >                    try {
285 >                        c.await();
286 >                        threadShouldThrow();
287 >                    } catch(BrokenBarrierException success){
288 >                    } catch(Exception i){
289 >                        threadUnexpectedException();
290 >                    }
291 >                }
292 >            });
293 >        try {
294 >            t1.start();
295 >            t2.start();
296 >            t1.join();
297 >            t2.join();
298 >        } catch(InterruptedException e){
299 >            unexpectedException();
300 >        }
301 >    }
302 >
303      /**
304       * A reset of an active barrier causes waiting threads to throw
305       * BrokenBarrierException
# Line 232 | Line 311 | public class CyclicBarrierTest extends J
311                      try {
312                          c.await();
313                          threadShouldThrow();
314 <                    } catch(BrokenBarrierException success){}                
314 >                    } catch(BrokenBarrierException success){}
315                      catch(Exception b){
316                          threadUnexpectedException();
317                      }
# Line 242 | Line 321 | public class CyclicBarrierTest extends J
321                  public void run() {
322                      try {
323                          c.await();
324 <                        threadShouldThrow();                        
324 >                        threadShouldThrow();
325                      } catch(BrokenBarrierException success){
326                      } catch(Exception i){
327                          threadUnexpectedException();
# Line 254 | 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){
339              unexpectedException();
# Line 290 | 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){
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