ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/PhaserTest.java

Comparing jsr166/src/test/tck/PhaserTest.java (file contents):
Revision 1.18 by jsr166, Tue Oct 12 06:19:44 2010 UTC vs.
Revision 1.19 by jsr166, Fri Oct 15 22:43:02 2010 UTC

#	Line 11 | Line 11 | import java.util.concurrent.atomic.Atomi
11		import java.util.concurrent.atomic.AtomicBoolean;
12		import java.util.concurrent.*;
13		import static java.util.concurrent.TimeUnit.MILLISECONDS;
14	+	import static java.util.concurrent.TimeUnit.NANOSECONDS;
15		import junit.framework.Test;
16		import junit.framework.TestSuite;
17
#	Line 24 | Line 25 | public class PhaserTest extends JSR166Te
25		return new TestSuite(PhaserTest.class);
26		}
27
28	+	/** Checks state of phaser. */
29	+	protected void assertState(Phaser phaser,
30	+	int phase, int parties, int unarrived) {
31	+	assertEquals(phase, phaser.getPhase());
32	+	assertEquals(parties, phaser.getRegisteredParties());
33	+	assertEquals(unarrived, phaser.getUnarrivedParties());
34	+	assertEquals(parties - unarrived, phaser.getArrivedParties());
35	+	assertTrue((phaser.getPhase() >= 0) ^ phaser.isTerminated());
36	+	}
37	+
38	+	/** Checks state of terminated phaser. */
39	+	protected void assertTerminated(Phaser phaser, int parties, int unarrived) {
40	+	assertTrue(phaser.isTerminated());
41	+	assertTrue(phaser.getPhase() < 0);
42	+	assertEquals(parties, phaser.getRegisteredParties());
43	+	assertEquals(unarrived, phaser.getUnarrivedParties());
44	+	assertEquals(parties - unarrived, phaser.getArrivedParties());
45	+	}
46	+
47	+	protected void assertTerminated(Phaser phaser) {
48	+	assertTerminated(phaser, 0, 0);
49	+	}
50	+
51		/**
52		* Empty constructor builds a new Phaser with no parent, no registered
53		* parties and initial phase number of 0
#	Line 81 | Line 105 | public class PhaserTest extends JSR166Te
105		*/
106		public void testRegister1() {
107		Phaser phaser = new Phaser();
108	<	assertEquals(0, phaser.getUnarrivedParties());
109	<	phaser.register();
110	<	assertEquals(1, phaser.getUnarrivedParties());
87	<	assertEquals(0, phaser.getArrivedParties());
108	>	assertState(phaser, 0, 0, 0);
109	>	assertEquals(0, phaser.register());
110	>	assertState(phaser, 0, 1, 1);
111		}
112
113		/**
#	Line 92 | Line 115 | public class PhaserTest extends JSR166Te
115		*/
116		public void testRegister2() {
117		Phaser phaser = new Phaser(0);
118	<	int expectedUnnarivedParties = (1 << 16) - 1;
119	<	for (int i = 0; i < expectedUnnarivedParties; i++) {
120	<	phaser.register();
121	<	assertEquals(i + 1, phaser.getUnarrivedParties());
118	>	int maxParties = (1 << 16) - 1;
119	>	assertState(phaser, 0, 0, 0);
120	>	assertEquals(0, phaser.bulkRegister(maxParties - 10));
121	>	assertState(phaser, 0, maxParties - 10, maxParties - 10);
122	>	for (int i = 0; i < 10; i++) {
123	>	assertState(phaser, 0, maxParties - 10 + i, maxParties - 10 + i);
124	>	assertEquals(0, phaser.register());
125		}
126	+	assertState(phaser, 0, maxParties, maxParties);
127		try {
128		phaser.register();
129		shouldThrow();
#	Line 110 | Line 137 | public class PhaserTest extends JSR166Te
137		public void testRegister3() {
138		Phaser phaser = new Phaser();
139		assertEquals(0, phaser.register());
140	<	phaser.arrive();
140	>	assertEquals(0, phaser.arrive());
141		assertEquals(1, phaser.register());
142	+	assertState(phaser, 1, 2, 2);
143		}
144
145		/**
#	Line 120 | Line 148 | public class PhaserTest extends JSR166Te
148		*/
149		public void testRegister4() {
150		Phaser phaser = new Phaser(1);
151	<	phaser.arrive();
152	<	int expectedPhase = phaser.register();
153	<	phaser.arrive();
154	<	assertEquals(expectedPhase, phaser.getPhase());
127	<	}
128	<
129	<	public void testRegister5() {
130	<	Phaser phaser = new Phaser();
131	<	phaser.register();
132	<	assertEquals(1, phaser.getUnarrivedParties());
151	>	assertEquals(0, phaser.arrive());
152	>	assertEquals(1, phaser.register());
153	>	assertEquals(1, phaser.arrive());
154	>	assertState(phaser, 1, 2, 1);
155		}
156
157		/**
#	Line 149 | Line 171 | public class PhaserTest extends JSR166Te
171		*/
172		public void testBulkRegister2() {
173		Phaser phaser = new Phaser();
174	<	phaser.bulkRegister(20);
175	<	assertEquals(20, phaser.getUnarrivedParties());
174	>	assertEquals(0, phaser.bulkRegister(20));
175	>	assertState(phaser, 0, 20, 20);
176		}
177
178		/**
#	Line 158 | Line 180 | public class PhaserTest extends JSR166Te
180		* throws IllegalStateException.
181		*/
182		public void testBulkRegister3() {
183	+	assertEquals(0, new Phaser().bulkRegister((1 << 16) - 1));
184	+
185		try {
186		new Phaser().bulkRegister(1 << 16);
187		shouldThrow();
188		} catch (IllegalStateException success) {}
189	+
190	+	try {
191	+	new Phaser(2).bulkRegister((1 << 16) - 2);
192	+	shouldThrow();
193	+	} catch (IllegalStateException success) {}
194		}
195
196		/**
#	Line 178 | Line 207 | public class PhaserTest extends JSR166Te
207		}
208
209		/**
210	<	* Arrive() on a registered phaser increments phase.
210	>	* arrive() on a registered phaser increments phase.
211		*/
212		public void testArrive1() {
213		Phaser phaser = new Phaser(1);
214	<	phaser.arrive();
215	<	assertEquals(1, phaser.getPhase());
214	>	assertState(phaser, 0, 1, 1);
215	>	assertEquals(0, phaser.arrive());
216	>	assertState(phaser, 1, 1, 1);
217		}
218
219		/**
220		* arriveAndDeregister does not wait for others to arrive at barrier
221		*/
222	<	public void testArrive2() throws InterruptedException {
222	>	public void testArriveAndDeregister() throws InterruptedException {
223		final Phaser phaser = new Phaser(1);
224	<	phaser.register();
224	>	for (int i = 0; i < 10; i++) {
225	>	assertState(phaser, 0, 1, 1);
226	>	assertEquals(0, phaser.register());
227	>	assertState(phaser, 0, 2, 2);
228	>	assertEquals(0, phaser.arriveAndDeregister());
229	>	assertState(phaser, 0, 1, 1);
230	>	}
231	>	assertEquals(0, phaser.arriveAndDeregister());
232	>	assertTerminated(phaser);
233	>	}
234	>
235	>	/**
236	>	* arriveAndDeregister does not wait for others to arrive at barrier
237	>	*/
238	>	public void testArrive2() throws InterruptedException {
239	>	final Phaser phaser = new Phaser();
240	>	assertEquals(0, phaser.register());
241		List<Thread> threads = new ArrayList<Thread>();
242	<	for (int i = 0; i < 10; i++)
243	<	phaser.register();
242	>	for (int i = 0; i < 10; i++) {
243	>	assertEquals(0, phaser.register());
244		threads.add(newStartedThread(new CheckedRunnable() {
245		public void realRun() throws InterruptedException {
246	<	Thread.sleep(SMALL_DELAY_MS);
201	<	phaser.arriveAndDeregister();
246	>	assertEquals(0, phaser.arriveAndDeregister());
247		}}));
248	+	}
249
204	–	phaser.arrive();
205	–	assertTrue(threads.get(0).isAlive());
206	–	assertFalse(phaser.isTerminated());
250		for (Thread thread : threads)
251	<	thread.join();
251	>	awaitTermination(thread, LONG_DELAY_MS);
252	>	assertState(phaser, 0, 1, 1);
253	>	assertEquals(0, phaser.arrive());
254	>	assertState(phaser, 1, 1, 1);
255		}
256
257		/**
#	Line 214 | Line 260 | public class PhaserTest extends JSR166Te
260		public void testArrive3() {
261		Phaser phaser = new Phaser(1);
262		phaser.forceTermination();
263	+	assertTerminated(phaser, 1, 1);
264		assertTrue(phaser.arrive() < 0);
265	+	assertTrue(phaser.register() < 0);
266	+	assertTrue(phaser.arriveAndDeregister() < 0);
267	+	assertTrue(phaser.awaitAdvance(1) < 0);
268	+	assertTrue(phaser.getPhase() < 0);
269		}
270
271		/**
#	Line 230 | Line 281 | public class PhaserTest extends JSR166Te
281		}
282
283		/**
284	<	* arriveAndDeregister deregisters reduces the number of arrived parties
284	>	* arriveAndDeregister reduces the number of arrived parties
285		*/
286	<	public void testArriveAndDergeister2() {
286	>	public void testArriveAndDeregister2() {
287		final Phaser phaser = new Phaser(1);
288	<	phaser.register();
289	<	phaser.arrive();
290	<	int p = phaser.getArrivedParties();
291	<	assertEquals(1, p);
292	<	phaser.arriveAndDeregister();
242	<	assertTrue(phaser.getArrivedParties() < p);
288	>	assertEquals(0, phaser.register());
289	>	assertEquals(0, phaser.arrive());
290	>	assertState(phaser, 0, 2, 1);
291	>	assertEquals(0, phaser.arriveAndDeregister());
292	>	assertState(phaser, 1, 1, 1);
293		}
294
295		/**
296	<	* arriveAndDeregister arrives to the barrier on a phaser with a parent and
296	>	* arriveAndDeregister arrives at the barrier on a phaser with a parent and
297		* when a deregistration occurs and causes the phaser to have zero parties
298		* its parent will be deregistered as well
299		*/
300	<	public void testArriveAndDeregsiter3() {
300	>	public void testArriveAndDeregister3() {
301		Phaser parent = new Phaser();
302	<	Phaser root = new Phaser(parent);
303	<	root.register();
304	<	assertTrue(parent.getUnarrivedParties() > 0);
305	<	assertTrue(root.getUnarrivedParties() > 0);
306	<	root.arriveAndDeregister();
307	<	assertEquals(0, parent.getUnarrivedParties());
308	<	assertEquals(0, root.getUnarrivedParties());
309	<	assertTrue(root.isTerminated() && parent.isTerminated());
302	>	Phaser child = new Phaser(parent);
303	>	assertState(child, 0, 0, 0);
304	>	assertState(parent, 0, 1, 1);
305	>	assertEquals(0, child.register());
306	>	assertState(child, 0, 1, 1);
307	>	assertState(parent, 0, 1, 1);
308	>	assertEquals(0, child.arriveAndDeregister());
309	>	assertTerminated(child);
310	>	assertTerminated(parent);
311		}
312
313		/**
314		* arriveAndDeregister deregisters one party from its parent when
315	<	* the number of parties of root is zero after deregistration
315	>	* the number of parties of child is zero after deregistration
316		*/
317	<	public void testArriveAndDeregsiter4() {
317	>	public void testArriveAndDeregister4() {
318		Phaser parent = new Phaser();
319	<	Phaser root = new Phaser(parent);
320	<	parent.register();
321	<	root.register();
322	<	int parentParties = parent.getUnarrivedParties();
323	<	root.arriveAndDeregister();
324	<	assertEquals(parentParties - 1, parent.getUnarrivedParties());
319	>	Phaser child = new Phaser(parent);
320	>	assertEquals(0, parent.register());
321	>	assertEquals(0, child.register());
322	>	assertState(child, 0, 1, 1);
323	>	assertState(parent, 0, 2, 2);
324	>	assertEquals(0, child.arriveAndDeregister());
325	>	assertState(child, 0, 0, 0);
326	>	assertState(parent, 0, 1, 1);
327		}
328
329		/**
#	Line 278 | Line 331 | public class PhaserTest extends JSR166Te
331		* the number of parties of root is nonzero after deregistration.
332		*/
333		public void testArriveAndDeregister5() {
334	<	Phaser parent = new Phaser();
334	>	Phaser root = new Phaser();
335	>	Phaser parent = new Phaser(root);
336		Phaser child = new Phaser(parent);
337	<	Phaser root = new Phaser(child);
338	<	assertTrue(parent.getUnarrivedParties() > 0);
339	<	assertTrue(child.getUnarrivedParties() > 0);
340	<	root.register();
341	<	root.arriveAndDeregister();
342	<	assertEquals(0, parent.getUnarrivedParties());
343	<	assertEquals(0, child.getUnarrivedParties());
344	<	assertTrue(root.isTerminated());
337	>	assertState(root, 0, 1, 1);
338	>	assertState(parent, 0, 1, 1);
339	>	assertState(child, 0, 0, 0);
340	>	assertEquals(0, child.register());
341	>	assertState(root, 0, 1, 1);
342	>	assertState(parent, 0, 1, 1);
343	>	assertState(child, 0, 1, 1);
344	>	assertEquals(0, child.arriveAndDeregister());
345	>	assertTerminated(child);
346	>	assertTerminated(parent);
347	>	assertTerminated(root);
348		}
349
350		/**
#	Line 298 | Line 355 | public class PhaserTest extends JSR166Te
355		final Phaser phaser = new Phaser(2);
356		Thread t = newStartedThread(new CheckedRunnable() {
357		public void realRun() {
358	<	sleepTillInterrupted(SHORT_DELAY_MS);
302	<	phaser.arrive();
358	>	assertEquals(0, phaser.arrive());
359		}});
360	<	phaser.arriveAndAwaitAdvance();
361	<	int phase = phaser.arriveAndDeregister();
362	<	assertEquals(phase, phaser.getPhase());
363	<	t.join();
360	>	assertEquals(1, phaser.arriveAndAwaitAdvance());
361	>	assertState(phaser, 1, 2, 2);
362	>	assertEquals(1, phaser.arriveAndDeregister());
363	>	assertState(phaser, 1, 1, 1);
364	>	assertEquals(1, phaser.arriveAndDeregister());
365	>	assertTerminated(phaser);
366	>	awaitTermination(t, SHORT_DELAY_MS);
367		}
368
369		/**
#	Line 312 | Line 371 | public class PhaserTest extends JSR166Te
371		*/
372		public void testAwaitAdvance1() {
373		final Phaser phaser = new Phaser(1);
374	<	phaser.awaitAdvance(phaser.arrive());
374	>	assertEquals(0, phaser.arrive());
375	>	assertEquals(1, phaser.awaitAdvance(0));
376		}
377
378		/**
#	Line 321 | Line 381 | public class PhaserTest extends JSR166Te
381		*/
382		public void testAwaitAdvance2() {
383		Phaser phaser = new Phaser();
384	<	phaser.awaitAdvance(-1);
384	>	assertTrue(phaser.awaitAdvance(-1) < 0);
385	>	assertState(phaser, 0, 0, 0);
386		}
387
388		/**
389	<	* awaitAdvance while waiting does not abort on interrupt.
389	>	* awaitAdvance continues waiting if interrupted
390		*/
391		public void testAwaitAdvance3() throws InterruptedException {
392		final Phaser phaser = new Phaser();
393	<	phaser.register();
393	>	assertEquals(0, phaser.register());
394		final CountDownLatch threadStarted = new CountDownLatch(1);
395
396		Thread t = newStartedThread(new CheckedRunnable() {
397		public void realRun() throws InterruptedException {
398	<	phaser.register();
398	>	assertEquals(0, phaser.register());
399		threadStarted.countDown();
400	<	phaser.awaitAdvance(phaser.arrive());
400	>	assertEquals(1, phaser.awaitAdvance(phaser.arrive()));
401		assertTrue(Thread.currentThread().isInterrupted());
402		}});
403		assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
404		t.interrupt();
405	<	phaser.arrive();
405	>	assertEquals(0, phaser.arrive());
406		awaitTermination(t, SMALL_DELAY_MS);
407		}
408
#	Line 351 | Line 412 | public class PhaserTest extends JSR166Te
412		*/
413		public void testAwaitAdvance4() throws InterruptedException {
414		final Phaser phaser = new Phaser(4);
415	<	final AtomicInteger phaseCount = new AtomicInteger(0);
415	>	final AtomicInteger count = new AtomicInteger(0);
416		List<Thread> threads = new ArrayList<Thread>();
417	<	for (int i = 0; i < 4; i++) {
417	>	for (int i = 0; i < 4; i++)
418		threads.add(newStartedThread(new CheckedRunnable() {
419		public void realRun() {
420	<	int phase = phaser.arrive();
421	<	phaseCount.incrementAndGet();
422	<	sleepTillInterrupted(SMALL_DELAY_MS);
423	<	phaser.awaitAdvance(phase);
424	<	assertEquals(phaseCount.get(), 4);
425	<	}}));
426	<	}
420	>	for (int k = 0; k < 3; k++) {
421	>	assertEquals(2*k+1, phaser.arriveAndAwaitAdvance());
422	>	count.incrementAndGet();
423	>	assertEquals(2*k+1, phaser.arrive());
424	>	assertEquals(2*k+2, phaser.awaitAdvance(2*k+1));
425	>	assertEquals(count.get(), 4*(k+1));
426	>	}}}));
427	>
428		for (Thread thread : threads)
429	<	thread.join();
429	>	awaitTermination(thread, MEDIUM_DELAY_MS);
430		}
431
432		/**
#	Line 372 | Line 434 | public class PhaserTest extends JSR166Te
434		*/
435		public void testAwaitAdvance5() throws InterruptedException {
436		final Phaser phaser = new Phaser(1);
437	<	int phase = phaser.awaitAdvance(phaser.arrive());
438	<	assertEquals(phase, phaser.getPhase());
439	<	phaser.register();
437	>	assertEquals(1, phaser.awaitAdvance(phaser.arrive()));
438	>	assertEquals(1, phaser.getPhase());
439	>	assertEquals(1, phaser.register());
440		List<Thread> threads = new ArrayList<Thread>();
441		for (int i = 0; i < 8; i++) {
442		final CountDownLatch latch = new CountDownLatch(1);
#	Line 391 | Line 453 | public class PhaserTest extends JSR166Te
453		assertTrue(latch.await(SMALL_DELAY_MS, MILLISECONDS));
454		else
455		latch.countDown();
456	<	phase = phaser.awaitAdvance(phaser.arrive());
457	<	assertEquals(phase, phaser.getPhase());
456	>	assertEquals(i + 2, phaser.awaitAdvance(phaser.arrive()));
457	>	assertEquals(i + 2, phaser.getPhase());
458		}
459		for (Thread thread : threads)
460		awaitTermination(thread, SMALL_DELAY_MS);
#	Line 408 | Line 470 | public class PhaserTest extends JSR166Te
470		for (int i = 0; i < 2; i++) {
471		Runnable r = new CheckedRunnable() {
472		public void realRun() {
473	<	int p1 = phaser.arrive();
412	<	assertTrue(p1 >= 0);
473	>	assertEquals(0, phaser.arrive());
474		threadsStarted.countDown();
475	<	int phase = phaser.awaitAdvance(p1);
415	<	assertTrue(phase < 0);
475	>	assertTrue(phaser.awaitAdvance(0) < 0);
476		assertTrue(phaser.isTerminated());
477	+	assertTrue(phaser.getPhase() < 0);
478	+	assertEquals(3, phaser.getRegisteredParties());
479		}};
480		threads.add(newStartedThread(r));
481		}
#	Line 421 | Line 483 | public class PhaserTest extends JSR166Te
483		phaser.forceTermination();
484		for (Thread thread : threads)
485		awaitTermination(thread, SMALL_DELAY_MS);
486	+	assertTrue(phaser.isTerminated());
487	+	assertTrue(phaser.getPhase() < 0);
488	+	assertEquals(3, phaser.getRegisteredParties());
489		}
490
491		/**
#	Line 446 | Line 511 | public class PhaserTest extends JSR166Te
511		Thread t = newStartedThread(new CheckedRunnable() {
512		public void realRun() throws InterruptedException {
513		threadStarted.countDown();
514	<	phaser.arriveAndAwaitAdvance();
514	>	assertEquals(1, phaser.arriveAndAwaitAdvance());
515	>	assertState(phaser, 1, 2, 2);
516		advanced.set(true);
517		assertTrue(Thread.currentThread().isInterrupted());
518		while (!checkedInterruptStatus.get())
#	Line 455 | Line 521 | public class PhaserTest extends JSR166Te
521
522		assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
523		t.interrupt();
524	<	phaser.arrive();
524	>	assertEquals(0, phaser.arrive());
525		while (!advanced.get())
526		Thread.yield();
527		assertTrue(t.isInterrupted());
#	Line 470 | Line 536 | public class PhaserTest extends JSR166Te
536		*/
537		public void testArriveAndAwaitAdvance3() throws InterruptedException {
538		final Phaser phaser = new Phaser(1);
539	+	final int THREADS = 3;
540	+	final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
541		final List<Thread> threads = new ArrayList<Thread>();
542	<	for (int i = 0; i < 3; i++) {
542	>	for (int i = 0; i < THREADS; i++)
543		threads.add(newStartedThread(new CheckedRunnable() {
544	<	public void realRun() throws InterruptedException {
545	<	phaser.register();
546	<	phaser.arriveAndAwaitAdvance();
547	<	}}));
548	<	}
549	<	Thread.sleep(MEDIUM_DELAY_MS);
550	<	assertEquals(phaser.getArrivedParties(), 3);
544	>	public void realRun() throws InterruptedException {
545	>	assertEquals(0, phaser.register());
546	>	threadsStarted.countDown();
547	>	assertEquals(1, phaser.arriveAndAwaitAdvance());
548	>	}}));
549	>
550	>	assertTrue(threadsStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
551	>	long t0 = System.nanoTime();
552	>	while (phaser.getArrivedParties() < THREADS)
553	>	Thread.yield();
554	>	assertEquals(THREADS, phaser.getArrivedParties());
555	>	assertTrue(NANOSECONDS.toMillis(System.nanoTime() - t0) < SMALL_DELAY_MS);
556	>	for (Thread thread : threads)
557	>	assertTrue(thread.isAlive());
558	>	assertState(phaser, 0, THREADS + 1, 1);
559		phaser.arriveAndAwaitAdvance();
560		for (Thread thread : threads)
561	<	thread.join();
561	>	awaitTermination(thread, SMALL_DELAY_MS);
562	>	assertState(phaser, 1, THREADS + 1, THREADS + 1);
563		}
564
565		}

Diff Legend

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