Print this page


Split Close
Expand all
Collapse all
          --- old/test/java/util/concurrent/Phaser/Basic.java
          +++ new/test/java/util/concurrent/Phaser/Basic.java
↓ open down ↓ 44 lines elided ↑ open up ↑
  45   45  import java.util.concurrent.TimeoutException;
  46   46  import java.util.concurrent.atomic.AtomicInteger;
  47   47  import static java.util.concurrent.TimeUnit.*;
  48   48  
  49   49  public class Basic {
  50   50  
  51   51      private static void checkTerminated(final Phaser phaser) {
  52   52          check(phaser.isTerminated());
  53   53          int unarriverParties = phaser.getUnarrivedParties();
  54   54          int registeredParties = phaser.getRegisteredParties();
  55      -        equal(phaser.arrive(), -1);
  56      -        equal(phaser.arriveAndDeregister(), -1);
  57      -        equal(phaser.arriveAndAwaitAdvance(), -1);
  58      -        equal(phaser.bulkRegister(10), -1);
  59      -        equal(phaser.getPhase(), -1);
  60      -        equal(phaser.register(), -1);
       55 +        int phase = phaser.getPhase();
       56 +        check(phase < 0);
       57 +        equal(phase, phaser.arrive());
       58 +        equal(phase, phaser.arriveAndDeregister());
       59 +        equal(phase, phaser.arriveAndAwaitAdvance());
       60 +        equal(phase, phaser.bulkRegister(10));
       61 +        equal(phase, phaser.register());
  61   62          try {
  62      -            equal(phaser.awaitAdvanceInterruptibly(0), -1);
  63      -            equal(phaser.awaitAdvanceInterruptibly(0, 10, SECONDS), -1);
       63 +            equal(phase, phaser.awaitAdvanceInterruptibly(0));
       64 +            equal(phase, phaser.awaitAdvanceInterruptibly(0, 10, SECONDS));
  64   65          } catch (Exception ie) {
  65   66              unexpected(ie);
  66   67          }
  67   68          equal(phaser.getUnarrivedParties(), unarriverParties);
  68   69          equal(phaser.getRegisteredParties(), registeredParties);
  69   70      }
  70   71  
  71   72      private static void checkResult(Arriver a, Class<? extends Throwable> c) {
  72   73          Throwable t = a.result();
  73   74          if (! ((t == null && c == null) || (c != null && c.isInstance(t)))) {
↓ open down ↓ 13 lines elided ↑ open up ↑
  87   88      private static Phaser atTheStartingGate = new Phaser(3);
  88   89  
  89   90      private static void toTheStartingGate() {
  90   91          try {
  91   92              boolean expectNextPhase = false;
  92   93              if (atTheStartingGate.getUnarrivedParties() == 1) {
  93   94                  expectNextPhase = true;
  94   95              }
  95   96              int phase = atTheStartingGate.getPhase();
  96   97              equal(phase, atTheStartingGate.arrive());
  97      -            int AwaitPhase = atTheStartingGate.awaitAdvanceInterruptibly(phase,
  98      -                                                        10,
  99      -                                                        SECONDS);
 100      -            if (expectNextPhase) check(AwaitPhase == (phase + 1));
       98 +            int awaitPhase = atTheStartingGate.awaitAdvanceInterruptibly
       99 +                (phase, 10, SECONDS);
      100 +            if (expectNextPhase) check(awaitPhase == (phase + 1));
 101  101  
 102  102              pass();
 103  103          } catch (Throwable t) {
 104  104              unexpected(t);
 105  105             // reset(atTheStartingGate);
 106  106              throw new Error(t);
 107  107          }
 108  108      }
 109  109  
 110  110      //----------------------------------------------------------------
↓ open down ↓ 153 lines elided ↑ open up ↑
 264  264                  equal(phaser.getRegisteredParties(), 3);
 265  265                  equal(phaser.getArrivedParties(), 0);
 266  266                  phase++;
 267  267              }
 268  268          } catch (Throwable t) { unexpected(t); }
 269  269  
 270  270          //----------------------------------------------------------------
 271  271          // Phaser is terminated while threads are waiting
 272  272          //----------------------------------------------------------------
 273  273          try {
 274      -            Phaser phaser = new Phaser(3);
 275      -            Iterator<Awaiter> awaiters = awaiterIterator(phaser);
 276  274              for (int i = 0; i < 4; i++) {
      275 +                Phaser phaser = new Phaser(3);
      276 +                Iterator<Awaiter> awaiters = awaiterIterator(phaser);
 277  277                  Arriver a1 = awaiters.next(); a1.start();
 278  278                  Arriver a2 = awaiters.next(); a2.start();
 279  279                  toTheStartingGate();
 280  280                  while (phaser.getArrivedParties() < 2) Thread.yield();
      281 +                equal(0, phaser.getPhase());
 281  282                  phaser.forceTermination();
 282  283                  a1.join();
 283  284                  a2.join();
 284      -                check(a1.phase == -1);
 285      -                check(a2.phase == -1);
      285 +                equal(0 + Integer.MIN_VALUE, a1.phase);
      286 +                equal(0 + Integer.MIN_VALUE, a2.phase);
 286  287                  int arrivedParties = phaser.getArrivedParties();
 287  288                  checkTerminated(phaser);
 288  289                  equal(phaser.getArrivedParties(), arrivedParties);
 289  290              }
 290  291          } catch (Throwable t) { unexpected(t); }
 291  292  
 292  293          //----------------------------------------------------------------
 293  294          // Adds new unarrived parties to this phaser
 294  295          //----------------------------------------------------------------
 295  296          try {
↓ open down ↓ 112 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX