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.9 by jsr166, Thu Nov 26 15:42:15 2009 UTC vs.
Revision 1.16 by jsr166, Mon Oct 11 05:35:19 2010 UTC

# Line 8 | Line 8
8   import java.util.ArrayList;
9   import java.util.List;
10   import java.util.concurrent.atomic.AtomicInteger;
11 + import java.util.concurrent.atomic.AtomicBoolean;
12   import java.util.concurrent.*;
13 + import static java.util.concurrent.TimeUnit.MILLISECONDS;
14   import junit.framework.Test;
15   import junit.framework.TestSuite;
16  
# Line 176 | Line 178 | public class PhaserTest extends JSR166Te
178      }
179  
180      /**
181 <     *  Arrive() on a registered phaser increments phase.
181 >     * Arrive() on a registered phaser increments phase.
182       */
183      public void testArrive1() {
184          Phaser phaser = new Phaser(1);
# Line 235 | Line 237 | public class PhaserTest extends JSR166Te
237          phaser.register();
238          phaser.arrive();
239          int p = phaser.getArrivedParties();
240 <        assertTrue(p == 1);
240 >        assertEquals(1, p);
241          phaser.arriveAndDeregister();
242          assertTrue(phaser.getArrivedParties() < p);
243      }
# Line 252 | Line 254 | public class PhaserTest extends JSR166Te
254          assertTrue(parent.getUnarrivedParties() > 0);
255          assertTrue(root.getUnarrivedParties() > 0);
256          root.arriveAndDeregister();
257 <        assertTrue(parent.getUnarrivedParties() == 0);
258 <        assertTrue(root.getUnarrivedParties() == 0);
257 >        assertEquals(0, parent.getUnarrivedParties());
258 >        assertEquals(0, root.getUnarrivedParties());
259          assertTrue(root.isTerminated() && parent.isTerminated());
260      }
261  
# Line 283 | Line 285 | public class PhaserTest extends JSR166Te
285          assertTrue(child.getUnarrivedParties() > 0);
286          root.register();
287          root.arriveAndDeregister();
288 <        assertTrue(parent.getUnarrivedParties() == 0);
289 <        assertTrue(child.getUnarrivedParties() == 0);
288 >        assertEquals(0, parent.getUnarrivedParties());
289 >        assertEquals(0, child.getUnarrivedParties());
290          assertTrue(root.isTerminated());
291      }
292  
# Line 358 | Line 360 | public class PhaserTest extends JSR166Te
360                      phaseCount.incrementAndGet();
361                      sleepTillInterrupted(SMALL_DELAY_MS);
362                      phaser.awaitAdvance(phase);
363 <                    threadAssertTrue(phaseCount.get() == 4);
363 >                    assertEquals(phaseCount.get(), 4);
364                  }}));
365          }
366          for (Thread thread : threads)
# Line 381 | Line 383 | public class PhaserTest extends JSR166Te
383                      phaser.arrive();
384                  }}));
385              phase = phaser.awaitAdvance(phaser.arrive());
386 <            threadAssertEquals(phase, phaser.getPhase());
386 >            assertEquals(phase, phaser.getPhase());
387          }
388          for (Thread thread : threads)
389              thread.join();
# Line 405 | Line 407 | public class PhaserTest extends JSR166Te
407                  /*
408                   * This point is reached when force termination is called in which phase = -1
409                   */
410 <                threadAssertTrue(phase < 0);
411 <                threadAssertTrue(phaser.isTerminated());
410 >                assertTrue(phase < 0);
411 >                assertTrue(phaser.isTerminated());
412              }});
413          /*
414           * This thread will cause the first thread run to wait, in doing so
# Line 418 | Line 420 | public class PhaserTest extends JSR166Te
420                  sleepTillInterrupted(MEDIUM_DELAY_MS);
421                  int p1 = phaser.arrive();
422                  int phase = phaser.awaitAdvance(p1);
423 <                threadAssertTrue(phase < 0);
424 <                threadAssertTrue(phaser.isTerminated());
423 >                assertTrue(phase < 0);
424 >                assertTrue(phaser.isTerminated());
425              }});
426  
427          phaser.arrive();
# Line 445 | Line 447 | public class PhaserTest extends JSR166Te
447       */
448      public void testArriveAndAwaitAdvance2() throws InterruptedException {
449          final Phaser phaser = new Phaser(2);
450 <        Thread th = newStartedThread(new CheckedRunnable() {
451 <            public void realRun() {
450 >        final CountDownLatch threadStarted = new CountDownLatch(1);
451 >        final AtomicBoolean advanced = new AtomicBoolean(false);
452 >        final AtomicBoolean checkedInterruptStatus = new AtomicBoolean(false);
453 >        Thread t = newStartedThread(new CheckedRunnable() {
454 >            public void realRun() throws InterruptedException {
455 >                threadStarted.countDown();
456                  phaser.arriveAndAwaitAdvance();
457 +                advanced.set(true);
458 +                assertTrue(Thread.currentThread().isInterrupted());
459 +                while (!checkedInterruptStatus.get())
460 +                    Thread.yield();
461              }});
462  
463 <        Thread.sleep(SMALL_DELAY_MS);
464 <        th.interrupt();
455 <        Thread.sleep(SMALL_DELAY_MS);
463 >        assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
464 >        t.interrupt();
465          phaser.arrive();
466 <        assertFalse(th.isInterrupted());
467 <        th.join();
466 >        while (!advanced.get())
467 >            Thread.yield();
468 >        assertTrue(t.isInterrupted());
469 >        checkedInterruptStatus.set(true);
470 >        awaitTermination(t, SMALL_DELAY_MS);
471      }
472  
473      /**
# Line 465 | Line 477 | public class PhaserTest extends JSR166Te
477       */
478      public void testArriveAndAwaitAdvance3() throws InterruptedException {
479          final Phaser phaser = new Phaser(1);
468 –        final AtomicInteger arrivingCount = new AtomicInteger(0);
480          final List<Thread> threads = new ArrayList<Thread>();
481 <        for (int i = 0; i < 6; i++) {
481 >        for (int i = 0; i < 3; i++) {
482              threads.add(newStartedThread(new CheckedRunnable() {
483 <                public void realRun() throws InterruptedException {
484 <                    phaser.register();
485 <                    sleepTillInterrupted(SHORT_DELAY_MS);
486 <                    arrivingCount.getAndIncrement();
476 <                    phaser.arrive();
477 <                }}));
483 >                    public void realRun() throws InterruptedException {
484 >                        phaser.register();
485 >                        phaser.arriveAndAwaitAdvance();
486 >                    }}));
487          }
488 <        int phaseNumber = phaser.arriveAndAwaitAdvance();
489 <        arrivingCount.incrementAndGet();
490 <        //the + 1 adds to expectedArrive to account for the main threads arrival
482 <        int expectedArrived = phaseNumber > 0 ? phaseNumber * six + 1 : phaser.getArrivedParties() + 1;
483 <        threadAssertEquals(expectedArrived, arrivingCount.get());
488 >        Thread.sleep(MEDIUM_DELAY_MS);
489 >        assertEquals(phaser.getArrivedParties(), 3);
490 >        phaser.arriveAndAwaitAdvance();
491          for (Thread thread : threads)
492              thread.join();
493      }

Diff Legend

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