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

Comparing jsr166/src/test/tck/PhaserTest.java (file contents):
Revision 1.5 by jsr166, Mon Aug 3 20:33:57 2009 UTC vs.
Revision 1.12 by dl, Wed Dec 2 10:50:48 2009 UTC

# Line 40 | Line 40 | public class PhaserTest extends JSR166Te
40      public void testConstructor2() {
41          try {
42              new Phaser(-1);
43 <            this.shouldThrow();
44 <        } catch (IllegalArgumentException success) {
45 <        }
43 >            shouldThrow();
44 >        } catch (IllegalArgumentException success) {}
45      }
46  
47      /**
# Line 62 | Line 61 | public class PhaserTest extends JSR166Te
61          try {
62              new Phaser(new Phaser(), -1);
63              shouldThrow();
64 <        } catch (IllegalArgumentException success) {
66 <        }
64 >        } catch (IllegalArgumentException success) {}
65      }
66  
67      /**
# Line 100 | Line 98 | public class PhaserTest extends JSR166Te
98          try {
99              phaser.register();
100              shouldThrow();
101 <        } catch (IllegalStateException success) {
104 <        }
101 >        } catch (IllegalStateException success) {}
102      }
103  
104      /**
# Line 141 | Line 138 | public class PhaserTest extends JSR166Te
138          try {
139              new Phaser().bulkRegister(-1);
140              shouldThrow();
141 <        } catch (IllegalArgumentException success) {
145 <        }
141 >        } catch (IllegalArgumentException success) {}
142      }
143  
144      /**
# Line 163 | Line 159 | public class PhaserTest extends JSR166Te
159          try {
160              new Phaser().bulkRegister(1 << 16);
161              shouldThrow();
162 <        } catch (IllegalStateException success) {
167 <        }
162 >        } catch (IllegalStateException success) {}
163      }
164  
165      /**
# Line 190 | Line 185 | public class PhaserTest extends JSR166Te
185      }
186  
187      /**
188 <     * arrive does not wait for others to arrive at barrier
188 >     * arriveAndDeregister does not wait for others to arrive at barrier
189       */
190 <    public void testArrive2() {
190 >    public void testArrive2() throws InterruptedException {
191          final Phaser phaser = new Phaser(1);
192          phaser.register();
193 <        Thread thread = null;
194 <        for (final Runnable r : getRunnables(10, SHORT_DELAY_MS)) {
193 >        List<Thread> threads = new ArrayList<Thread>();
194 >        for (int i = 0; i < 10; i++)
195              phaser.register();
196 <            thread = new Thread(new CheckedRunnable() {
197 <                void realRun() {
198 <                    r.run();
196 >            threads.add(newStartedThread(new CheckedRunnable() {
197 >                public void realRun() throws InterruptedException {
198 >                    Thread.sleep(SMALL_DELAY_MS);
199                      phaser.arriveAndDeregister();
200 <                }});
206 <            thread.start();
207 <        }
200 >                }}));
201  
202          phaser.arrive();
203 <        assertTrue(thread.isAlive());
203 >        assertTrue(threads.get(0).isAlive());
204          assertFalse(phaser.isTerminated());
205 +        for (Thread thread : threads)
206 +            thread.join();
207      }
208  
209      /**
# Line 218 | Line 213 | public class PhaserTest extends JSR166Te
213          Phaser phaser = new Phaser(1);
214          phaser.forceTermination();
215          assertTrue(phaser.arrive() < 0);
221 –
216      }
217  
218      /**
# Line 230 | Line 224 | public class PhaserTest extends JSR166Te
224              Phaser phaser = new Phaser();
225              phaser.arriveAndDeregister();
226              shouldThrow();
227 <
234 <        } catch (IllegalStateException success) {
235 <        }
227 >        } catch (IllegalStateException success) {}
228      }
229  
230      /**
# Line 300 | Line 292 | public class PhaserTest extends JSR166Te
292       * arriveAndDeregister returns the phase in which it leaves the
293       * phaser in after deregistration
294       */
295 <    public void testArriveAndDeregister6() {
295 >    public void testArriveAndDeregister6() throws InterruptedException {
296          final Phaser phaser = new Phaser(2);
297 <        new Thread(new CheckedRunnable() {
298 <            void realRun() {
299 <                getRunnable(SHORT_DELAY_MS).run();
297 >        Thread t = newStartedThread(new CheckedRunnable() {
298 >            public void realRun() {
299 >                sleepTillInterrupted(SHORT_DELAY_MS);
300                  phaser.arrive();
301 <            }}).start();
301 >            }});
302          phaser.arriveAndAwaitAdvance();
303          int phase = phaser.arriveAndDeregister();
304          assertEquals(phase, phaser.getPhase());
305 +        t.join();
306      }
307  
308      /**
# Line 325 | Line 318 | public class PhaserTest extends JSR166Te
318       * phaser
319       */
320      public void testAwaitAdvance2() {
321 <        try {
322 <            Phaser phaser = new Phaser();
330 <            phaser.awaitAdvance(-1);
331 <        } catch (Exception failure) {
332 <            this.unexpectedException();
333 <        }
321 >        Phaser phaser = new Phaser();
322 >        phaser.awaitAdvance(-1);
323      }
324  
325      /**
326       * awaitAdvance while waiting does not abort on interrupt.
327       */
328 <    public void testAwaitAdvance3() {
328 >    public void testAwaitAdvance3() throws InterruptedException {
329          final Phaser phaser = new Phaser();
330 +        phaser.register();
331  
332 <        Thread th1 = new Thread(new CheckedRunnable() {
333 <            void realRun() throws InterruptedException {
332 >        Thread t = newStartedThread(new CheckedRunnable() {
333 >            public void realRun() throws InterruptedException {
334                  phaser.register();
335 <                getRunnable(LONG_DELAY_MS).run();
335 >                sleepTillInterrupted(LONG_DELAY_MS);
336                  phaser.awaitAdvance(phaser.arrive());
337              }});
338 <        phaser.register();
339 <        th1.start();
340 <        try {
341 <            Thread.sleep(SHORT_DELAY_MS);
342 <            th1.interrupt();
343 <            Thread.sleep(LONG_DELAY_MS);
354 <            phaser.arrive();
355 <        } catch (InterruptedException failure) {
356 <            threadUnexpectedException(failure);
357 <        }
358 <        assertFalse(th1.isInterrupted());
338 >        Thread.sleep(SMALL_DELAY_MS);
339 >        t.interrupt();
340 >        Thread.sleep(SMALL_DELAY_MS);
341 >        phaser.arrive();
342 >        assertFalse(t.isInterrupted());
343 >        t.join();
344      }
345  
346      /**
# Line 367 | Line 352 | public class PhaserTest extends JSR166Te
352          final AtomicInteger phaseCount = new AtomicInteger(0);
353          List<Thread> threads = new ArrayList<Thread>();
354          for (int i = 0; i < 4; i++) {
355 <            threads.add(new Thread(new CheckedRunnable() {
356 <                void realRun() {
355 >            threads.add(newStartedThread(new CheckedRunnable() {
356 >                public void realRun() {
357                      int phase = phaser.arrive();
358                      phaseCount.incrementAndGet();
359 <                    getRunnable(LONG_DELAY_MS).run();
359 >                    sleepTillInterrupted(SMALL_DELAY_MS);
360                      phaser.awaitAdvance(phase);
361 <                    threadAssertTrue(phaseCount.get() == 4);
361 >                    assertEquals(phaseCount.get(), 4);
362                  }}));
363          }
364          for (Thread thread : threads)
380 –            thread.start();
381 –        for (Thread thread : threads)
365              thread.join();
366      }
367  
368      /**
369       * awaitAdvance returns the current phase
370       */
371 <    public void testAwaitAdvance5() {
371 >    public void testAwaitAdvance5() throws InterruptedException {
372          final Phaser phaser = new Phaser(1);
373          int phase = phaser.awaitAdvance(phaser.arrive());
374          assertEquals(phase, phaser.getPhase());
375          phaser.register();
376 <        for (int i = 0; i < eight; i++) {
377 <            new Thread(new CheckedRunnable() {
378 <                void realRun() {
379 <                    getRunnable(SHORT_DELAY_MS).run();
376 >        List<Thread> threads = new ArrayList<Thread>();
377 >        for (int i = 0; i < 8; i++) {
378 >            threads.add(newStartedThread(new CheckedRunnable() {
379 >                public void realRun() {
380 >                    sleepTillInterrupted(SHORT_DELAY_MS);
381                      phaser.arrive();
382 <                }
399 <                }).start();
382 >                }}));
383              phase = phaser.awaitAdvance(phaser.arrive());
384 <            threadAssertEquals(phase, phaser.getPhase());
384 >            assertEquals(phase, phaser.getPhase());
385          }
386 +        for (Thread thread : threads)
387 +            thread.join();
388      }
389  
390      /**
391       * awaitAdvance returns when the phaser is externally terminated
392       */
393 <    public void testAwaitAdvance6() {
393 >    public void testAwaitAdvance6() throws InterruptedException {
394          final Phaser phaser = new Phaser(3);
395          /*
396           * Start new thread. This thread waits a small amount of time
# Line 413 | Line 398 | public class PhaserTest extends JSR166Te
398           * in the main thread arrives quickly so at best this thread
399           * waits for the second thread's party to arrive
400           */
401 <        new Thread(new CheckedRunnable() {
402 <            void realRun() {
403 <                getRunnable(SMALL_DELAY_MS).run();
401 >        Thread t1 = newStartedThread(new CheckedRunnable() {
402 >            public void realRun() {
403 >                sleepTillInterrupted(SMALL_DELAY_MS);
404                  int phase = phaser.awaitAdvance(phaser.arrive());
405                  /*
406                   * This point is reached when force termination is called in which phase = -1
407                   */
408 <                threadAssertTrue(phase < 0);
409 <                threadAssertTrue(phaser.isTerminated());
410 <            }}).start();
408 >                assertTrue(phase < 0);
409 >                assertTrue(phaser.isTerminated());
410 >            }});
411          /*
412           * This thread will cause the first thread run to wait, in doing so
413           * the main thread will force termination in which the first thread
414           * should exit peacefully as this one
415           */
416 <        new Thread(new CheckedRunnable() {
417 <            void realRun() {
418 <                getRunnable(LONG_DELAY_MS).run();
416 >        Thread t2 = newStartedThread(new CheckedRunnable() {
417 >            public void realRun() {
418 >                sleepTillInterrupted(MEDIUM_DELAY_MS);
419                  int p1 = phaser.arrive();
420                  int phase = phaser.awaitAdvance(p1);
421 <                threadAssertTrue(phase < 0);
422 <                threadAssertTrue(phaser.isTerminated());
423 <            }}).start();
421 >                assertTrue(phase < 0);
422 >                assertTrue(phaser.isTerminated());
423 >            }});
424  
425          phaser.arrive();
426          phaser.forceTermination();
427 +        t1.join();
428 +        t2.join();
429      }
430  
431      /**
# Line 450 | Line 437 | public class PhaserTest extends JSR166Te
437              Phaser phaser = new Phaser();
438              phaser.arriveAndAwaitAdvance();
439              shouldThrow();
440 <        } catch (IllegalStateException success) {
454 <        }
440 >        } catch (IllegalStateException success) {}
441      }
442  
443      /**
444       * Interrupted arriveAndAwaitAdvance does not throw InterruptedException
445       */
446 <    public void testArriveAndAwaitAdvance2() {
446 >    public void testArriveAndAwaitAdvance2() throws InterruptedException {
447          final Phaser phaser = new Phaser(2);
448 <        Thread th = new Thread(new CheckedRunnable() {
449 <            void realRun() {
448 >        Thread th = newStartedThread(new CheckedRunnable() {
449 >            public void realRun() {
450                  phaser.arriveAndAwaitAdvance();
451              }});
452  
453 <        try {
454 <            th.start();
455 <            Thread.sleep(LONG_DELAY_MS);
456 <            th.interrupt();
471 <            Thread.sleep(LONG_DELAY_MS);
472 <            phaser.arrive();
473 <        } catch (InterruptedException failure) {
474 <            this.unexpectedException();
475 <        }
453 >        Thread.sleep(SMALL_DELAY_MS);
454 >        th.interrupt();
455 >        Thread.sleep(SMALL_DELAY_MS);
456 >        phaser.arrive();
457          assertFalse(th.isInterrupted());
458 +        th.join();
459      }
460  
461      /**
# Line 481 | Line 463 | public class PhaserTest extends JSR166Te
463       * number of arrived parties is the same number that is accounted
464       * for when the main thread awaitsAdvance
465       */
466 <    public void testArriveAndAwaitAdvance3() {
466 >    public void testArriveAndAwaitAdvance3() throws InterruptedException {
467          final Phaser phaser = new Phaser(1);
468 <        final AtomicInteger arrivingCount = new AtomicInteger(0);
469 <        for (final Runnable run : getRunnables(six, SHORT_DELAY_MS)) {
470 <            new Thread(new CheckedRunnable() {
471 <                void realRun() {
472 <                    phaser.register();
473 <                    run.run();
474 <                    arrivingCount.getAndIncrement();
493 <                    phaser.arrive();
494 <                }}).start();
468 >        final List<Thread> threads = new ArrayList<Thread>();
469 >        for (int i = 0; i < 3; i++) {
470 >            threads.add(newStartedThread(new CheckedRunnable() {
471 >                    public void realRun() throws InterruptedException {
472 >                        phaser.register();
473 >                        phaser.arriveAndAwaitAdvance();
474 >                    }}));
475          }
476 <        int phaseNumber = phaser.arriveAndAwaitAdvance();
477 <        arrivingCount.incrementAndGet();
478 <        //the + 1 adds to expectedArrive to account for the main threads arrival
479 <        int expectedArrived = phaseNumber > 0 ? phaseNumber * six + 1 : phaser.getArrivedParties() + 1;
480 <        threadAssertEquals(expectedArrived, arrivingCount.get());
501 <    }
502 <    // .. initially called, for n tasks via
503 <    private List<Runnable> getRunnables(int size, long wait) {
504 <        List<Runnable> list = new ArrayList<Runnable>();
505 <        for (int i = 0; i < size; i++) {
506 <            list.add(getRunnable(wait));
507 <        }
508 <        return list;
509 <    }
510 <
511 <    private Runnable getRunnable(final long wait) {
512 <        return new CheckedRunnable() {
513 <            void realRun() {
514 <                try {
515 <                    Thread.sleep(wait);
516 <                } catch (InterruptedException noop) {
517 <                // sleep interruption isn't a problem case for these example
518 <                }
519 <            }
520 <        };
476 >        Thread.sleep(LONG_DELAY_MS);
477 >        assertEquals(phaser.getArrivedParties(), 3);
478 >        phaser.arriveAndAwaitAdvance();
479 >        for (Thread thread : threads)
480 >            thread.join();
481      }
482  
483   }

Diff Legend

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