--- jsr166/src/test/tck/PhaserTest.java	2010/11/30 01:56:12	1.25
+++ jsr166/src/test/tck/PhaserTest.java	2011/05/31 16:16:24	1.32
@@ -1,19 +1,19 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  * Other contributors include John Vint
  */
 
+import junit.framework.*;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.*;
+import java.util.concurrent.Phaser;
+import java.util.concurrent.CountDownLatch;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
-import junit.framework.Test;
-import junit.framework.TestSuite;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 
 public class PhaserTest extends JSR166TestCase {
 
@@ -27,29 +27,29 @@ public class PhaserTest extends JSR166Te
 
     private static final int maxParties = 65535;
 
-    /** Checks state of phaser. */
+    /** Checks state of unterminated phaser. */
     protected void assertState(Phaser phaser,
                                int phase, int parties, int unarrived) {
         assertEquals(phase, phaser.getPhase());
         assertEquals(parties, phaser.getRegisteredParties());
         assertEquals(unarrived, phaser.getUnarrivedParties());
         assertEquals(parties - unarrived, phaser.getArrivedParties());
-        assertTrue((phaser.getPhase() >= 0) ^ phaser.isTerminated());
+        assertFalse(phaser.isTerminated());
     }
 
     /** Checks state of terminated phaser. */
-    protected void assertTerminated(Phaser phaser,
-                                    int maxPhase, int parties, int unarrived) {
+    protected void assertTerminated(Phaser phaser, int maxPhase, int parties) {
         assertTrue(phaser.isTerminated());
         int expectedPhase = maxPhase + Integer.MIN_VALUE;
-        assertState(phaser, expectedPhase, parties, unarrived);
+        assertEquals(expectedPhase, phaser.getPhase());
+        assertEquals(parties, phaser.getRegisteredParties());
         assertEquals(expectedPhase, phaser.register());
         assertEquals(expectedPhase, phaser.arrive());
         assertEquals(expectedPhase, phaser.arriveAndDeregister());
     }
 
     protected void assertTerminated(Phaser phaser, int maxPhase) {
-        assertTerminated(phaser, maxPhase, 0, 0);
+        assertTerminated(phaser, maxPhase, 0);
     }
 
     /**
@@ -158,6 +158,9 @@ public class PhaserTest extends JSR166Te
             phaser.bulkRegister(Integer.MAX_VALUE);
             shouldThrow();
         } catch (IllegalStateException success) {}
+
+        assertEquals(0, phaser.bulkRegister(0));
+        assertState(phaser, 0, maxParties, maxParties);
     }
 
     /**
@@ -201,6 +204,8 @@ public class PhaserTest extends JSR166Te
      */
     public void testBulkRegister2() {
         Phaser phaser = new Phaser();
+        assertEquals(0, phaser.bulkRegister(0));
+        assertState(phaser, 0, 0, 0);
         assertEquals(0, phaser.bulkRegister(20));
         assertState(phaser, 0, 20, 20);
     }
@@ -290,7 +295,7 @@ public class PhaserTest extends JSR166Te
     public void testArrive3() {
         Phaser phaser = new Phaser(1);
         phaser.forceTermination();
-        assertTerminated(phaser, 0, 1, 1);
+        assertTerminated(phaser, 0, 1);
         assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE);
         assertTrue(phaser.arrive() < 0);
         assertTrue(phaser.register() < 0);
@@ -583,6 +588,53 @@ public class PhaserTest extends JSR166Te
     }
 
     /**
+     * awaitAdvance returns the current phase in child phasers
+     */
+    public void testAwaitAdvanceTieredPhaser() throws Exception {
+        final Phaser parent = new Phaser();
+        final List<Phaser> zeroPartyChildren = new ArrayList<Phaser>(3);
+        final List<Phaser> onePartyChildren = new ArrayList<Phaser>(3);
+        for (int i = 0; i < 3; i++) {
+            zeroPartyChildren.add(new Phaser(parent, 0));
+            onePartyChildren.add(new Phaser(parent, 1));
+        }
+        final List<Phaser> phasers = new ArrayList<Phaser>();
+        phasers.addAll(zeroPartyChildren);
+        phasers.addAll(onePartyChildren);
+        phasers.add(parent);
+        for (Phaser phaser : phasers) {
+            assertEquals(-42, phaser.awaitAdvance(-42));
+            assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42));
+            assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, SMALL_DELAY_MS, MILLISECONDS));
+        }
+
+        for (Phaser child : onePartyChildren)
+            assertEquals(0, child.arrive());
+        for (Phaser phaser : phasers) {
+            assertEquals(-42, phaser.awaitAdvance(-42));
+            assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42));
+            assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, SMALL_DELAY_MS, MILLISECONDS));
+            assertEquals(1, phaser.awaitAdvance(0));
+            assertEquals(1, phaser.awaitAdvanceInterruptibly(0));
+            assertEquals(1, phaser.awaitAdvanceInterruptibly(0, SMALL_DELAY_MS, MILLISECONDS));
+        }
+
+        for (Phaser child : onePartyChildren)
+            assertEquals(1, child.arrive());
+        for (Phaser phaser : phasers) {
+            assertEquals(-42, phaser.awaitAdvance(-42));
+            assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42));
+            assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, SMALL_DELAY_MS, MILLISECONDS));
+            assertEquals(2, phaser.awaitAdvance(0));
+            assertEquals(2, phaser.awaitAdvanceInterruptibly(0));
+            assertEquals(2, phaser.awaitAdvanceInterruptibly(0, SMALL_DELAY_MS, MILLISECONDS));
+            assertEquals(2, phaser.awaitAdvance(1));
+            assertEquals(2, phaser.awaitAdvanceInterruptibly(1));
+            assertEquals(2, phaser.awaitAdvanceInterruptibly(1, SMALL_DELAY_MS, MILLISECONDS));
+        }
+    }
+
+    /**
      * awaitAdvance returns when the phaser is externally terminated
      */
     public void testAwaitAdvance6() throws InterruptedException {
@@ -604,11 +656,10 @@ public class PhaserTest extends JSR166Te
         }
         threadsStarted.await();
         phaser.forceTermination();
+        assertTrue(phaser.isTerminated());
         assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE);
         for (Thread thread : threads)
             awaitTermination(thread, SMALL_DELAY_MS);
-        assertTrue(phaser.isTerminated());
-        assertTrue(phaser.getPhase() < 0);
         assertEquals(3, phaser.getRegisteredParties());
     }