--- jsr166/src/test/tck/PhaserTest.java	2010/10/21 23:28:13	1.20
+++ jsr166/src/test/tck/PhaserTest.java	2010/12/03 21:54:32	1.28
@@ -25,45 +25,51 @@ public class PhaserTest extends JSR166Te
         return new TestSuite(PhaserTest.class);
     }
 
-    /** Checks state of phaser. */
+    private static final int maxParties = 65535;
+
+    /** 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 parties, int unarrived) {
+    protected void assertTerminated(Phaser phaser, int maxPhase, int parties) {
         assertTrue(phaser.isTerminated());
-        assertTrue(phaser.getPhase() < 0);
+        int expectedPhase = maxPhase + Integer.MIN_VALUE;
+        assertEquals(expectedPhase, phaser.getPhase());
         assertEquals(parties, phaser.getRegisteredParties());
-        assertEquals(unarrived, phaser.getUnarrivedParties());
-        assertEquals(parties - unarrived, phaser.getArrivedParties());
+        assertEquals(expectedPhase, phaser.register());
+        assertEquals(expectedPhase, phaser.arrive());
+        assertEquals(expectedPhase, phaser.arriveAndDeregister());
     }
 
-    protected void assertTerminated(Phaser phaser) {
-        assertTerminated(phaser, 0, 0);
+    protected void assertTerminated(Phaser phaser, int maxPhase) {
+        assertTerminated(phaser, maxPhase, 0);
     }
 
     /**
      * Empty constructor builds a new Phaser with no parent, no registered
      * parties and initial phase number of 0
      */
-    public void testConstructor1() {
+    public void testConstructorDefaultValues() {
         Phaser phaser = new Phaser();
         assertNull(phaser.getParent());
+        assertEquals(0, phaser.getRegisteredParties());
         assertEquals(0, phaser.getArrivedParties());
+        assertEquals(0, phaser.getUnarrivedParties());
         assertEquals(0, phaser.getPhase());
     }
 
     /**
-     * A negative party number for the constructor throws illegal argument
-     * exception
+     * Constructing with a negative number of parties throws
+     * IllegalArgumentException
      */
-    public void testConstructor2() {
+    public void testConstructorNegativeParties() {
         try {
             new Phaser(-1);
             shouldThrow();
@@ -71,37 +77,57 @@ public class PhaserTest extends JSR166Te
     }
 
     /**
-     * The parent being input into the constructor should equal the original
-     * parent when being returned
+     * Constructing with a negative number of parties throws
+     * IllegalArgumentException
      */
-    public void testConstructor3() {
-        Phaser parent = new Phaser();
-        assertEquals(parent, new Phaser(parent).getParent());
+    public void testConstructorNegativeParties2() {
+        try {
+            new Phaser(new Phaser(), -1);
+            shouldThrow();
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
-     * A negative party number for the constructor throws illegal argument
-     * exception
+     * Constructing with a number of parties > 65535 throws
+     * IllegalArgumentException
      */
-    public void testConstructor4() {
+    public void testConstructorPartiesExceedsLimit() {
+        new Phaser(maxParties);
         try {
-            new Phaser(new Phaser(), -1);
+            new Phaser(maxParties + 1);
+            shouldThrow();
+        } catch (IllegalArgumentException success) {}
+
+        new Phaser(new Phaser(), maxParties);
+        try {
+            new Phaser(new Phaser(), maxParties + 1);
             shouldThrow();
         } catch (IllegalArgumentException success) {}
     }
 
     /**
+     * The parent provided to the constructor should be returned from
+     * a later call to getParent
+     */
+    public void testConstructor3() {
+        Phaser parent = new Phaser();
+        assertSame(parent, new Phaser(parent).getParent());
+        assertNull(new Phaser(null).getParent());
+    }
+
+    /**
      * The parent being input into the parameter should equal the original
      * parent when being returned
      */
     public void testConstructor5() {
         Phaser parent = new Phaser();
-        assertEquals(parent, new Phaser(parent, 0).getParent());
+        assertSame(parent, new Phaser(parent, 0).getParent());
+        assertNull(new Phaser(null, 0).getParent());
     }
 
     /**
-     * register() will increment the number of unarrived parties by one and not
-     * affect its arrived parties
+     * register() will increment the number of unarrived parties by
+     * one and not affect its arrived parties
      */
     public void testRegister1() {
         Phaser phaser = new Phaser();
@@ -115,7 +141,6 @@ public class PhaserTest extends JSR166Te
      */
     public void testRegister2() {
         Phaser phaser = new Phaser(0);
-        int maxParties = (1 << 16) - 1;
         assertState(phaser, 0, 0, 0);
         assertEquals(0, phaser.bulkRegister(maxParties - 10));
         assertState(phaser, 0, maxParties - 10, maxParties - 10);
@@ -128,6 +153,11 @@ public class PhaserTest extends JSR166Te
             phaser.register();
             shouldThrow();
         } catch (IllegalStateException success) {}
+
+        try {
+            phaser.bulkRegister(Integer.MAX_VALUE);
+            shouldThrow();
+        } catch (IllegalStateException success) {}
     }
 
     /**
@@ -229,7 +259,7 @@ public class PhaserTest extends JSR166Te
             assertState(phaser, 0, 1, 1);
         }
         assertEquals(0, phaser.arriveAndDeregister());
-        assertTerminated(phaser);
+        assertTerminated(phaser, 1);
     }
 
     /**
@@ -260,7 +290,8 @@ public class PhaserTest extends JSR166Te
     public void testArrive3() {
         Phaser phaser = new Phaser(1);
         phaser.forceTermination();
-        assertTerminated(phaser, 1, 1);
+        assertTerminated(phaser, 0, 1);
+        assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE);
         assertTrue(phaser.arrive() < 0);
         assertTrue(phaser.register() < 0);
         assertTrue(phaser.arriveAndDeregister() < 0);
@@ -301,13 +332,13 @@ public class PhaserTest extends JSR166Te
         Phaser parent = new Phaser();
         Phaser child = new Phaser(parent);
         assertState(child, 0, 0, 0);
-        assertState(parent, 0, 1, 1);
+        assertState(parent, 0, 0, 0);
         assertEquals(0, child.register());
         assertState(child, 0, 1, 1);
         assertState(parent, 0, 1, 1);
         assertEquals(0, child.arriveAndDeregister());
-        assertTerminated(child);
-        assertTerminated(parent);
+        assertTerminated(child, 1);
+        assertTerminated(parent, 1);
     }
 
     /**
@@ -334,17 +365,17 @@ public class PhaserTest extends JSR166Te
         Phaser root = new Phaser();
         Phaser parent = new Phaser(root);
         Phaser child = new Phaser(parent);
-        assertState(root, 0, 1, 1);
-        assertState(parent, 0, 1, 1);
+        assertState(root, 0, 0, 0);
+        assertState(parent, 0, 0, 0);
         assertState(child, 0, 0, 0);
         assertEquals(0, child.register());
         assertState(root, 0, 1, 1);
         assertState(parent, 0, 1, 1);
         assertState(child, 0, 1, 1);
         assertEquals(0, child.arriveAndDeregister());
-        assertTerminated(child);
-        assertTerminated(parent);
-        assertTerminated(root);
+        assertTerminated(child, 1);
+        assertTerminated(parent, 1);
+        assertTerminated(root, 1);
     }
 
     /**
@@ -362,7 +393,7 @@ public class PhaserTest extends JSR166Te
         assertEquals(1, phaser.arriveAndDeregister());
         assertState(phaser, 1, 1, 1);
         assertEquals(1, phaser.arriveAndDeregister());
-        assertTerminated(phaser);
+        assertTerminated(phaser, 2);
         awaitTermination(t, SHORT_DELAY_MS);
     }
 
@@ -566,16 +597,17 @@ public class PhaserTest extends JSR166Te
                     assertTrue(phaser.awaitAdvance(0) < 0);
                     assertTrue(phaser.isTerminated());
                     assertTrue(phaser.getPhase() < 0);
+                    assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE);
                     assertEquals(3, phaser.getRegisteredParties());
                 }};
             threads.add(newStartedThread(r));
         }
         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());
     }