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.24 by dl, Mon Nov 29 15:47:29 2010 UTC vs.
Revision 1.29 by jsr166, Fri Dec 3 23:55:55 2010 UTC

# Line 27 | Line 27 | public class PhaserTest extends JSR166Te
27  
28      private static final int maxParties = 65535;
29  
30 <    /** Checks state of phaser. */
30 >    /** Checks state of unterminated phaser. */
31      protected void assertState(Phaser phaser,
32                                 int phase, int parties, int unarrived) {
33          assertEquals(phase, phaser.getPhase());
34          assertEquals(parties, phaser.getRegisteredParties());
35          assertEquals(unarrived, phaser.getUnarrivedParties());
36          assertEquals(parties - unarrived, phaser.getArrivedParties());
37 <        assertTrue((phaser.getPhase() >= 0) ^ phaser.isTerminated());
37 >        assertFalse(phaser.isTerminated());
38      }
39  
40      /** Checks state of terminated phaser. */
41 <    protected void assertTerminated(Phaser phaser, int parties, int unarrived) {
41 >    protected void assertTerminated(Phaser phaser, int maxPhase, int parties) {
42          assertTrue(phaser.isTerminated());
43 <        assertTrue(phaser.getPhase() < 0);
43 >        int expectedPhase = maxPhase + Integer.MIN_VALUE;
44 >        assertEquals(expectedPhase, phaser.getPhase());
45          assertEquals(parties, phaser.getRegisteredParties());
46 <        assertEquals(unarrived, phaser.getUnarrivedParties());
47 <        assertEquals(parties - unarrived, phaser.getArrivedParties());
46 >        assertEquals(expectedPhase, phaser.register());
47 >        assertEquals(expectedPhase, phaser.arrive());
48 >        assertEquals(expectedPhase, phaser.arriveAndDeregister());
49      }
50  
51 <    protected void assertTerminated(Phaser phaser) {
52 <        assertTerminated(phaser, 0, 0);
51 >    protected void assertTerminated(Phaser phaser, int maxPhase) {
52 >        assertTerminated(phaser, maxPhase, 0);
53      }
54  
55      /**
# Line 257 | Line 259 | public class PhaserTest extends JSR166Te
259              assertState(phaser, 0, 1, 1);
260          }
261          assertEquals(0, phaser.arriveAndDeregister());
262 <        assertTerminated(phaser);
261 <        assertEquals(1, phaser.getPhase() + Integer.MIN_VALUE);
262 >        assertTerminated(phaser, 1);
263      }
264  
265      /**
# Line 289 | Line 290 | public class PhaserTest extends JSR166Te
290      public void testArrive3() {
291          Phaser phaser = new Phaser(1);
292          phaser.forceTermination();
293 <        assertTerminated(phaser, 1, 1);
293 >        assertTerminated(phaser, 0, 1);
294          assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE);
295          assertTrue(phaser.arrive() < 0);
296          assertTrue(phaser.register() < 0);
# Line 336 | Line 337 | public class PhaserTest extends JSR166Te
337          assertState(child, 0, 1, 1);
338          assertState(parent, 0, 1, 1);
339          assertEquals(0, child.arriveAndDeregister());
340 <        assertTerminated(child);
341 <        assertTerminated(parent);
340 >        assertTerminated(child, 1);
341 >        assertTerminated(parent, 1);
342      }
343  
344      /**
# Line 372 | Line 373 | public class PhaserTest extends JSR166Te
373          assertState(parent, 0, 1, 1);
374          assertState(child, 0, 1, 1);
375          assertEquals(0, child.arriveAndDeregister());
376 <        assertTerminated(child);
377 <        assertTerminated(parent);
378 <        assertTerminated(root);
378 <        assertEquals(1, root.getPhase() + Integer.MIN_VALUE);
376 >        assertTerminated(child, 1);
377 >        assertTerminated(parent, 1);
378 >        assertTerminated(root, 1);
379      }
380  
381      /**
# Line 393 | Line 393 | public class PhaserTest extends JSR166Te
393          assertEquals(1, phaser.arriveAndDeregister());
394          assertState(phaser, 1, 1, 1);
395          assertEquals(1, phaser.arriveAndDeregister());
396 <        assertTerminated(phaser);
397 <        assertEquals(2, phaser.getPhase() + Integer.MIN_VALUE);
396 >        assertTerminated(phaser, 2);
397          awaitTermination(t, SHORT_DELAY_MS);
398      }
399  
# Line 584 | Line 583 | public class PhaserTest extends JSR166Te
583      }
584  
585      /**
586 +     * awaitAdvance returns the current phase in child phasers
587 +     */
588 +    public void testAwaitAdvanceTieredPhaser() throws Exception {
589 +        final Phaser parent = new Phaser();
590 +        final List<Phaser> zeroPartyChildren = new ArrayList<Phaser>(3);
591 +        final List<Phaser> onePartyChildren = new ArrayList<Phaser>(3);
592 +        for (int i = 0; i < 3; i++) {
593 +            zeroPartyChildren.add(new Phaser(parent, 0));
594 +            onePartyChildren.add(new Phaser(parent, 1));
595 +        }
596 +        final List<Phaser> phasers = new ArrayList<Phaser>();
597 +        phasers.addAll(zeroPartyChildren);
598 +        phasers.addAll(onePartyChildren);
599 +        phasers.add(parent);
600 +        for (Phaser phaser : phasers) {
601 +            assertEquals(-42, phaser.awaitAdvance(-42));
602 +            assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42));
603 +            assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, SMALL_DELAY_MS, MILLISECONDS));
604 +        }
605 +
606 +        for (Phaser child : onePartyChildren)
607 +            assertEquals(0, child.arrive());
608 +        for (Phaser phaser : phasers) {
609 +            assertEquals(-42, phaser.awaitAdvance(-42));
610 +            assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42));
611 +            assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, SMALL_DELAY_MS, MILLISECONDS));
612 +            assertEquals(1, phaser.awaitAdvance(0));
613 +            assertEquals(1, phaser.awaitAdvanceInterruptibly(0));
614 +            assertEquals(1, phaser.awaitAdvanceInterruptibly(0, SMALL_DELAY_MS, MILLISECONDS));
615 +        }
616 +
617 +        for (Phaser child : onePartyChildren)
618 +            assertEquals(1, child.arrive());
619 +        for (Phaser phaser : phasers) {
620 +            assertEquals(-42, phaser.awaitAdvance(-42));
621 +            assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42));
622 +            assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, SMALL_DELAY_MS, MILLISECONDS));
623 +            assertEquals(2, phaser.awaitAdvance(0));
624 +            assertEquals(2, phaser.awaitAdvanceInterruptibly(0));
625 +            assertEquals(2, phaser.awaitAdvanceInterruptibly(0, SMALL_DELAY_MS, MILLISECONDS));
626 +            assertEquals(2, phaser.awaitAdvance(1));
627 +            assertEquals(2, phaser.awaitAdvanceInterruptibly(1));
628 +            assertEquals(2, phaser.awaitAdvanceInterruptibly(1, SMALL_DELAY_MS, MILLISECONDS));
629 +        }
630 +    }
631 +
632 +    /**
633       * awaitAdvance returns when the phaser is externally terminated
634       */
635      public void testAwaitAdvance6() throws InterruptedException {
# Line 605 | Line 651 | public class PhaserTest extends JSR166Te
651          }
652          threadsStarted.await();
653          phaser.forceTermination();
654 +        assertTrue(phaser.isTerminated());
655          assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE);
656          for (Thread thread : threads)
657              awaitTermination(thread, SMALL_DELAY_MS);
611 –        assertTrue(phaser.isTerminated());
612 –        assertTrue(phaser.getPhase() < 0);
658          assertEquals(3, phaser.getRegisteredParties());
659      }
660  

Diff Legend

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