79 (c == null ? "<null>" : c.getName()));
80 } else {
81 pass();
82 }
83 }
84
85 //----------------------------------------------------------------
86 // Mechanism to get all test threads into "running" mode.
87 //----------------------------------------------------------------
88 private static Phaser atTheStartingGate = new Phaser(3);
89
90 private static void toTheStartingGate() {
91 try {
92 boolean expectNextPhase = false;
93 if (atTheStartingGate.getUnarrivedParties() == 1) {
94 expectNextPhase = true;
95 }
96 int phase = atTheStartingGate.getPhase();
97 equal(phase, atTheStartingGate.arrive());
98 int awaitPhase = atTheStartingGate.awaitAdvanceInterruptibly
99 (phase, 10, SECONDS);
100 if (expectNextPhase) check(awaitPhase == (phase + 1));
101
102 pass();
103 } catch (Throwable t) {
104 unexpected(t);
105 // reset(atTheStartingGate);
106 throw new Error(t);
107 }
108 }
109
110 //----------------------------------------------------------------
111 // Convenience methods for creating threads that call arrive,
112 // awaitAdvance, arriveAndAwaitAdvance, awaitAdvanceInterruptibly
113 //----------------------------------------------------------------
114 private static abstract class Arriver extends Thread {
115 static AtomicInteger count = new AtomicInteger(1);
116
117 Arriver() {
118 this("Arriver");
119 }
171 phase(phaser.awaitAdvanceInterruptibly(phaser.arrive(),
172 timeout,
173 unit));
174 } catch (Throwable result) { result(result); }}};
175 }
176
177 // Returns an infinite lazy list of all possible arriver/awaiter combinations.
178 private static Iterator<Arriver> arriverIterator(final Phaser phaser) {
179 return new Iterator<Arriver>() {
180 int i = 0;
181 public boolean hasNext() { return true; }
182 public Arriver next() {
183 switch ((i++)&7) {
184 case 0: case 4:
185 return arriver(phaser);
186 case 1: case 5:
187 return awaiter(phaser);
188 case 2: case 6: case 7:
189 return awaiter(phaser, -1, SECONDS);
190 default:
191 return awaiter(phaser, 10, SECONDS); }}
192 public void remove() {throw new UnsupportedOperationException();}};
193 }
194
195 // Returns an infinite lazy list of all possible awaiter only combinations.
196 private static Iterator<Awaiter> awaiterIterator(final Phaser phaser) {
197 return new Iterator<Awaiter>() {
198 int i = 0;
199 public boolean hasNext() { return true; }
200 public Awaiter next() {
201 switch ((i++)&7) {
202 case 1: case 4: case 7:
203 return awaiter(phaser);
204 case 2: case 5:
205 return awaiter(phaser, -1, SECONDS);
206 default:
207 return awaiter(phaser, 10, SECONDS); }}
208 public void remove() {throw new UnsupportedOperationException();}};
209 }
210
211 private static void realMain(String[] args) throws Throwable {
212
213 Thread.currentThread().setName("mainThread");
214
215 //----------------------------------------------------------------
216 // Normal use
217 //----------------------------------------------------------------
218 try {
219 Phaser phaser = new Phaser(3);
220 equal(phaser.getRegisteredParties(), 3);
221 equal(phaser.getArrivedParties(), 0);
222 equal(phaser.getPhase(), 0);
223 check(phaser.getRoot().equals(phaser));
224 equal(phaser.getParent(), null);
225 check(!phaser.isTerminated());
226
227 Iterator<Arriver> arrivers = arriverIterator(phaser);
234 phaser.arriveAndAwaitAdvance();
235 a1.join();
236 a2.join();
237 checkResult(a1, null);
238 checkResult(a2, null);
239 check(!phaser.isTerminated());
240 equal(phaser.getRegisteredParties(), 3);
241 equal(phaser.getArrivedParties(), 0);
242 }
243 } catch (Throwable t) { unexpected(t); }
244
245 //----------------------------------------------------------------
246 // One thread interrupted
247 //----------------------------------------------------------------
248 try {
249 Phaser phaser = new Phaser(3);
250 Iterator<Arriver> arrivers = arriverIterator(phaser);
251 int phase = phaser.getPhase();
252 for (int i = 0; i < 4; i++) {
253 check(phaser.getPhase() == phase);
254 Awaiter a1 = awaiter(phaser, 10, SECONDS); a1.start();
255 Arriver a2 = arrivers.next(); a2.start();
256 toTheStartingGate();
257 a1.interrupt();
258 a1.join();
259 phaser.arriveAndAwaitAdvance();
260 a2.join();
261 checkResult(a1, InterruptedException.class);
262 checkResult(a2, null);
263 check(!phaser.isTerminated());
264 equal(phaser.getRegisteredParties(), 3);
265 equal(phaser.getArrivedParties(), 0);
266 phase++;
267 }
268 } catch (Throwable t) { unexpected(t); }
269
270 //----------------------------------------------------------------
271 // Phaser is terminated while threads are waiting
272 //----------------------------------------------------------------
273 try {
274 for (int i = 0; i < 4; i++) {
|
79 (c == null ? "<null>" : c.getName()));
80 } else {
81 pass();
82 }
83 }
84
85 //----------------------------------------------------------------
86 // Mechanism to get all test threads into "running" mode.
87 //----------------------------------------------------------------
88 private static Phaser atTheStartingGate = new Phaser(3);
89
90 private static void toTheStartingGate() {
91 try {
92 boolean expectNextPhase = false;
93 if (atTheStartingGate.getUnarrivedParties() == 1) {
94 expectNextPhase = true;
95 }
96 int phase = atTheStartingGate.getPhase();
97 equal(phase, atTheStartingGate.arrive());
98 int awaitPhase = atTheStartingGate.awaitAdvanceInterruptibly
99 (phase, 30, SECONDS);
100 if (expectNextPhase) check(awaitPhase == (phase + 1));
101
102 pass();
103 } catch (Throwable t) {
104 unexpected(t);
105 // reset(atTheStartingGate);
106 throw new Error(t);
107 }
108 }
109
110 //----------------------------------------------------------------
111 // Convenience methods for creating threads that call arrive,
112 // awaitAdvance, arriveAndAwaitAdvance, awaitAdvanceInterruptibly
113 //----------------------------------------------------------------
114 private static abstract class Arriver extends Thread {
115 static AtomicInteger count = new AtomicInteger(1);
116
117 Arriver() {
118 this("Arriver");
119 }
171 phase(phaser.awaitAdvanceInterruptibly(phaser.arrive(),
172 timeout,
173 unit));
174 } catch (Throwable result) { result(result); }}};
175 }
176
177 // Returns an infinite lazy list of all possible arriver/awaiter combinations.
178 private static Iterator<Arriver> arriverIterator(final Phaser phaser) {
179 return new Iterator<Arriver>() {
180 int i = 0;
181 public boolean hasNext() { return true; }
182 public Arriver next() {
183 switch ((i++)&7) {
184 case 0: case 4:
185 return arriver(phaser);
186 case 1: case 5:
187 return awaiter(phaser);
188 case 2: case 6: case 7:
189 return awaiter(phaser, -1, SECONDS);
190 default:
191 return awaiter(phaser, 30, SECONDS); }}
192 public void remove() {throw new UnsupportedOperationException();}};
193 }
194
195 // Returns an infinite lazy list of all possible awaiter only combinations.
196 private static Iterator<Awaiter> awaiterIterator(final Phaser phaser) {
197 return new Iterator<Awaiter>() {
198 int i = 0;
199 public boolean hasNext() { return true; }
200 public Awaiter next() {
201 switch ((i++)&7) {
202 case 1: case 4: case 7:
203 return awaiter(phaser);
204 case 2: case 5:
205 return awaiter(phaser, -1, SECONDS);
206 default:
207 return awaiter(phaser, 30, SECONDS); }}
208 public void remove() {throw new UnsupportedOperationException();}};
209 }
210
211 private static void realMain(String[] args) throws Throwable {
212
213 Thread.currentThread().setName("mainThread");
214
215 //----------------------------------------------------------------
216 // Normal use
217 //----------------------------------------------------------------
218 try {
219 Phaser phaser = new Phaser(3);
220 equal(phaser.getRegisteredParties(), 3);
221 equal(phaser.getArrivedParties(), 0);
222 equal(phaser.getPhase(), 0);
223 check(phaser.getRoot().equals(phaser));
224 equal(phaser.getParent(), null);
225 check(!phaser.isTerminated());
226
227 Iterator<Arriver> arrivers = arriverIterator(phaser);
234 phaser.arriveAndAwaitAdvance();
235 a1.join();
236 a2.join();
237 checkResult(a1, null);
238 checkResult(a2, null);
239 check(!phaser.isTerminated());
240 equal(phaser.getRegisteredParties(), 3);
241 equal(phaser.getArrivedParties(), 0);
242 }
243 } catch (Throwable t) { unexpected(t); }
244
245 //----------------------------------------------------------------
246 // One thread interrupted
247 //----------------------------------------------------------------
248 try {
249 Phaser phaser = new Phaser(3);
250 Iterator<Arriver> arrivers = arriverIterator(phaser);
251 int phase = phaser.getPhase();
252 for (int i = 0; i < 4; i++) {
253 check(phaser.getPhase() == phase);
254 Awaiter a1 = awaiter(phaser, 30, SECONDS); a1.start();
255 Arriver a2 = arrivers.next(); a2.start();
256 toTheStartingGate();
257 a1.interrupt();
258 a1.join();
259 phaser.arriveAndAwaitAdvance();
260 a2.join();
261 checkResult(a1, InterruptedException.class);
262 checkResult(a2, null);
263 check(!phaser.isTerminated());
264 equal(phaser.getRegisteredParties(), 3);
265 equal(phaser.getArrivedParties(), 0);
266 phase++;
267 }
268 } catch (Throwable t) { unexpected(t); }
269
270 //----------------------------------------------------------------
271 // Phaser is terminated while threads are waiting
272 //----------------------------------------------------------------
273 try {
274 for (int i = 0; i < 4; i++) {
|