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.19 by jsr166, Fri Oct 15 22:43:02 2010 UTC vs.
Revision 1.33 by jsr166, Wed Jun 22 07:46:57 2011 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		* Other contributors include John Vint
6		*/
7
8	+	import junit.framework.*;
9		import java.util.ArrayList;
10		import java.util.List;
11	<	import java.util.concurrent.atomic.AtomicInteger;
12	<	import java.util.concurrent.atomic.AtomicBoolean;
13	<	import java.util.concurrent.*;
11	>	import java.util.concurrent.Phaser;
12	>	import java.util.concurrent.CountDownLatch;
13	>	import java.util.concurrent.TimeoutException;
14		import static java.util.concurrent.TimeUnit.MILLISECONDS;
15		import static java.util.concurrent.TimeUnit.NANOSECONDS;
16	<	import junit.framework.Test;
17	<	import junit.framework.TestSuite;
16	>	import java.util.concurrent.atomic.AtomicBoolean;
17	>	import java.util.concurrent.atomic.AtomicInteger;
18
19		public class PhaserTest extends JSR166TestCase {
20
#	Line 25 | Line 26 | public class PhaserTest extends JSR166Te
26		return new TestSuite(PhaserTest.class);
27		}
28
29	<	/** Checks state of phaser. */
29	>	private static final int maxParties = 65535;
30	>
31	>	/** Checks state of unterminated phaser. */
32		protected void assertState(Phaser phaser,
33		int phase, int parties, int unarrived) {
34		assertEquals(phase, phaser.getPhase());
35		assertEquals(parties, phaser.getRegisteredParties());
36		assertEquals(unarrived, phaser.getUnarrivedParties());
37		assertEquals(parties - unarrived, phaser.getArrivedParties());
38	<	assertTrue((phaser.getPhase() >= 0) ^ phaser.isTerminated());
38	>	assertFalse(phaser.isTerminated());
39		}
40
41		/** Checks state of terminated phaser. */
42	<	protected void assertTerminated(Phaser phaser, int parties, int unarrived) {
42	>	protected void assertTerminated(Phaser phaser, int maxPhase, int parties) {
43		assertTrue(phaser.isTerminated());
44	<	assertTrue(phaser.getPhase() < 0);
44	>	int expectedPhase = maxPhase + Integer.MIN_VALUE;
45	>	assertEquals(expectedPhase, phaser.getPhase());
46		assertEquals(parties, phaser.getRegisteredParties());
47	<	assertEquals(unarrived, phaser.getUnarrivedParties());
48	<	assertEquals(parties - unarrived, phaser.getArrivedParties());
47	>	assertEquals(expectedPhase, phaser.register());
48	>	assertEquals(expectedPhase, phaser.arrive());
49	>	assertEquals(expectedPhase, phaser.arriveAndDeregister());
50		}
51
52	<	protected void assertTerminated(Phaser phaser) {
53	<	assertTerminated(phaser, 0, 0);
52	>	protected void assertTerminated(Phaser phaser, int maxPhase) {
53	>	assertTerminated(phaser, maxPhase, 0);
54		}
55
56		/**
57		* Empty constructor builds a new Phaser with no parent, no registered
58		* parties and initial phase number of 0
59		*/
60	<	public void testConstructor1() {
60	>	public void testConstructorDefaultValues() {
61		Phaser phaser = new Phaser();
62		assertNull(phaser.getParent());
63	+	assertEquals(0, phaser.getRegisteredParties());
64		assertEquals(0, phaser.getArrivedParties());
65	+	assertEquals(0, phaser.getUnarrivedParties());
66		assertEquals(0, phaser.getPhase());
67		}
68
69		/**
70	<	* A negative party number for the constructor throws illegal argument
71	<	* exception
70	>	* Constructing with a negative number of parties throws
71	>	* IllegalArgumentException
72		*/
73	<	public void testConstructor2() {
73	>	public void testConstructorNegativeParties() {
74		try {
75		new Phaser(-1);
76		shouldThrow();
#	Line 71 | Line 78 | public class PhaserTest extends JSR166Te
78		}
79
80		/**
81	<	* The parent being input into the constructor should equal the original
82	<	* parent when being returned
81	>	* Constructing with a negative number of parties throws
82	>	* IllegalArgumentException
83		*/
84	<	public void testConstructor3() {
85	<	Phaser parent = new Phaser();
86	<	assertEquals(parent, new Phaser(parent).getParent());
84	>	public void testConstructorNegativeParties2() {
85	>	try {
86	>	new Phaser(new Phaser(), -1);
87	>	shouldThrow();
88	>	} catch (IllegalArgumentException success) {}
89		}
90
91		/**
92	<	* A negative party number for the constructor throws illegal argument
93	<	* exception
92	>	* Constructing with a number of parties > 65535 throws
93	>	* IllegalArgumentException
94		*/
95	<	public void testConstructor4() {
95	>	public void testConstructorPartiesExceedsLimit() {
96	>	new Phaser(maxParties);
97		try {
98	<	new Phaser(new Phaser(), -1);
98	>	new Phaser(maxParties + 1);
99	>	shouldThrow();
100	>	} catch (IllegalArgumentException success) {}
101	>
102	>	new Phaser(new Phaser(), maxParties);
103	>	try {
104	>	new Phaser(new Phaser(), maxParties + 1);
105		shouldThrow();
106		} catch (IllegalArgumentException success) {}
107		}
108
109		/**
110	+	* The parent provided to the constructor should be returned from
111	+	* a later call to getParent
112	+	*/
113	+	public void testConstructor3() {
114	+	Phaser parent = new Phaser();
115	+	assertSame(parent, new Phaser(parent).getParent());
116	+	assertNull(new Phaser(null).getParent());
117	+	}
118	+
119	+	/**
120		* The parent being input into the parameter should equal the original
121		* parent when being returned
122		*/
123		public void testConstructor5() {
124		Phaser parent = new Phaser();
125	<	assertEquals(parent, new Phaser(parent, 0).getParent());
125	>	assertSame(parent, new Phaser(parent, 0).getParent());
126	>	assertNull(new Phaser(null, 0).getParent());
127		}
128
129		/**
130	<	* register() will increment the number of unarrived parties by one and not
131	<	* affect its arrived parties
130	>	* register() will increment the number of unarrived parties by
131	>	* one and not affect its arrived parties
132		*/
133		public void testRegister1() {
134		Phaser phaser = new Phaser();
#	Line 115 | Line 142 | public class PhaserTest extends JSR166Te
142		*/
143		public void testRegister2() {
144		Phaser phaser = new Phaser(0);
118	–	int maxParties = (1 << 16) - 1;
145		assertState(phaser, 0, 0, 0);
146		assertEquals(0, phaser.bulkRegister(maxParties - 10));
147		assertState(phaser, 0, maxParties - 10, maxParties - 10);
#	Line 128 | Line 154 | public class PhaserTest extends JSR166Te
154		phaser.register();
155		shouldThrow();
156		} catch (IllegalStateException success) {}
157	+
158	+	try {
159	+	phaser.bulkRegister(Integer.MAX_VALUE);
160	+	shouldThrow();
161	+	} catch (IllegalStateException success) {}
162	+
163	+	assertEquals(0, phaser.bulkRegister(0));
164	+	assertState(phaser, 0, maxParties, maxParties);
165		}
166
167		/**
#	Line 171 | Line 205 | public class PhaserTest extends JSR166Te
205		*/
206		public void testBulkRegister2() {
207		Phaser phaser = new Phaser();
208	+	assertEquals(0, phaser.bulkRegister(0));
209	+	assertState(phaser, 0, 0, 0);
210		assertEquals(0, phaser.bulkRegister(20));
211		assertState(phaser, 0, 20, 20);
212		}
#	Line 219 | Line 255 | public class PhaserTest extends JSR166Te
255		/**
256		* arriveAndDeregister does not wait for others to arrive at barrier
257		*/
258	<	public void testArriveAndDeregister() throws InterruptedException {
258	>	public void testArriveAndDeregister() {
259		final Phaser phaser = new Phaser(1);
260		for (int i = 0; i < 10; i++) {
261		assertState(phaser, 0, 1, 1);
#	Line 229 | Line 265 | public class PhaserTest extends JSR166Te
265		assertState(phaser, 0, 1, 1);
266		}
267		assertEquals(0, phaser.arriveAndDeregister());
268	<	assertTerminated(phaser);
268	>	assertTerminated(phaser, 1);
269		}
270
271		/**
272		* arriveAndDeregister does not wait for others to arrive at barrier
273		*/
274	<	public void testArrive2() throws InterruptedException {
274	>	public void testArrive2() {
275		final Phaser phaser = new Phaser();
276		assertEquals(0, phaser.register());
277		List<Thread> threads = new ArrayList<Thread>();
278		for (int i = 0; i < 10; i++) {
279		assertEquals(0, phaser.register());
280		threads.add(newStartedThread(new CheckedRunnable() {
281	<	public void realRun() throws InterruptedException {
281	>	public void realRun() {
282		assertEquals(0, phaser.arriveAndDeregister());
283		}}));
284		}
285
286		for (Thread thread : threads)
287	<	awaitTermination(thread, LONG_DELAY_MS);
287	>	awaitTermination(thread);
288		assertState(phaser, 0, 1, 1);
289		assertEquals(0, phaser.arrive());
290		assertState(phaser, 1, 1, 1);
#	Line 260 | Line 296 | public class PhaserTest extends JSR166Te
296		public void testArrive3() {
297		Phaser phaser = new Phaser(1);
298		phaser.forceTermination();
299	<	assertTerminated(phaser, 1, 1);
299	>	assertTerminated(phaser, 0, 1);
300	>	assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE);
301		assertTrue(phaser.arrive() < 0);
302		assertTrue(phaser.register() < 0);
303		assertTrue(phaser.arriveAndDeregister() < 0);
#	Line 301 | Line 338 | public class PhaserTest extends JSR166Te
338		Phaser parent = new Phaser();
339		Phaser child = new Phaser(parent);
340		assertState(child, 0, 0, 0);
341	<	assertState(parent, 0, 1, 1);
341	>	assertState(parent, 0, 0, 0);
342		assertEquals(0, child.register());
343		assertState(child, 0, 1, 1);
344		assertState(parent, 0, 1, 1);
345		assertEquals(0, child.arriveAndDeregister());
346	<	assertTerminated(child);
347	<	assertTerminated(parent);
346	>	assertTerminated(child, 1);
347	>	assertTerminated(parent, 1);
348		}
349
350		/**
#	Line 334 | Line 371 | public class PhaserTest extends JSR166Te
371		Phaser root = new Phaser();
372		Phaser parent = new Phaser(root);
373		Phaser child = new Phaser(parent);
374	<	assertState(root, 0, 1, 1);
375	<	assertState(parent, 0, 1, 1);
374	>	assertState(root, 0, 0, 0);
375	>	assertState(parent, 0, 0, 0);
376		assertState(child, 0, 0, 0);
377		assertEquals(0, child.register());
378		assertState(root, 0, 1, 1);
379		assertState(parent, 0, 1, 1);
380		assertState(child, 0, 1, 1);
381		assertEquals(0, child.arriveAndDeregister());
382	<	assertTerminated(child);
383	<	assertTerminated(parent);
384	<	assertTerminated(root);
382	>	assertTerminated(child, 1);
383	>	assertTerminated(parent, 1);
384	>	assertTerminated(root, 1);
385		}
386
387		/**
388		* arriveAndDeregister returns the phase in which it leaves the
389		* phaser in after deregistration
390		*/
391	<	public void testArriveAndDeregister6() throws InterruptedException {
391	>	public void testArriveAndDeregister6() {
392		final Phaser phaser = new Phaser(2);
393		Thread t = newStartedThread(new CheckedRunnable() {
394		public void realRun() {
#	Line 362 | Line 399 | public class PhaserTest extends JSR166Te
399		assertEquals(1, phaser.arriveAndDeregister());
400		assertState(phaser, 1, 1, 1);
401		assertEquals(1, phaser.arriveAndDeregister());
402	<	assertTerminated(phaser);
403	<	awaitTermination(t, SHORT_DELAY_MS);
402	>	assertTerminated(phaser, 2);
403	>	awaitTermination(t);
404		}
405
406		/**
#	Line 386 | Line 423 | public class PhaserTest extends JSR166Te
423		}
424
425		/**
426	<	* awaitAdvance continues waiting if interrupted
426	>	* awaitAdvanceInterruptibly blocks interruptibly
427	>	*/
428	>	public void testAwaitAdvanceInterruptibly_interruptible() throws InterruptedException {
429	>	final Phaser phaser = new Phaser(1);
430	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
431	>
432	>	Thread t1 = newStartedThread(new CheckedRunnable() {
433	>	public void realRun() {
434	>	Thread.currentThread().interrupt();
435	>	try {
436	>	phaser.awaitAdvanceInterruptibly(0);
437	>	shouldThrow();
438	>	} catch (InterruptedException success) {}
439	>	assertFalse(Thread.interrupted());
440	>
441	>	pleaseInterrupt.countDown();
442	>	try {
443	>	phaser.awaitAdvanceInterruptibly(0);
444	>	shouldThrow();
445	>	} catch (InterruptedException success) {}
446	>	assertFalse(Thread.interrupted());
447	>	}});
448	>
449	>	Thread t2 = newStartedThread(new CheckedRunnable() {
450	>	public void realRun() throws TimeoutException {
451	>	Thread.currentThread().interrupt();
452	>	try {
453	>	phaser.awaitAdvanceInterruptibly(0, 2*LONG_DELAY_MS, MILLISECONDS);
454	>	shouldThrow();
455	>	} catch (InterruptedException success) {}
456	>	assertFalse(Thread.interrupted());
457	>
458	>	pleaseInterrupt.countDown();
459	>	try {
460	>	phaser.awaitAdvanceInterruptibly(0, 2*LONG_DELAY_MS, MILLISECONDS);
461	>	shouldThrow();
462	>	} catch (InterruptedException success) {}
463	>	assertFalse(Thread.interrupted());
464	>	}});
465	>
466	>	await(pleaseInterrupt);
467	>	assertState(phaser, 0, 1, 1);
468	>	assertThreadsStayAlive(t1, t2);
469	>	t1.interrupt();
470	>	t2.interrupt();
471	>	awaitTermination(t1);
472	>	awaitTermination(t2);
473	>	assertState(phaser, 0, 1, 1);
474	>	assertEquals(0, phaser.arrive());
475	>	assertState(phaser, 1, 1, 1);
476	>	}
477	>
478	>	/**
479	>	* awaitAdvance continues waiting if interrupted before waiting
480		*/
481	<	public void testAwaitAdvance3() throws InterruptedException {
481	>	public void testAwaitAdvanceAfterInterrupt() {
482		final Phaser phaser = new Phaser();
483		assertEquals(0, phaser.register());
484	<	final CountDownLatch threadStarted = new CountDownLatch(1);
484	>	final CountDownLatch pleaseArrive = new CountDownLatch(1);
485
486		Thread t = newStartedThread(new CheckedRunnable() {
487	<	public void realRun() throws InterruptedException {
487	>	public void realRun() {
488	>	Thread.currentThread().interrupt();
489		assertEquals(0, phaser.register());
490	<	threadStarted.countDown();
491	<	assertEquals(1, phaser.awaitAdvance(phaser.arrive()));
490	>	assertEquals(0, phaser.arrive());
491	>	pleaseArrive.countDown();
492		assertTrue(Thread.currentThread().isInterrupted());
493	+	assertEquals(1, phaser.awaitAdvance(0));
494	+	assertTrue(Thread.interrupted());
495		}});
496	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
496	>
497	>	await(pleaseArrive);
498	>	waitForThreadToEnterWaitState(t, SHORT_DELAY_MS);
499	>	assertEquals(0, phaser.arrive());
500	>	awaitTermination(t);
501	>
502	>	Thread.currentThread().interrupt();
503	>	assertEquals(1, phaser.awaitAdvance(0));
504	>	assertTrue(Thread.interrupted());
505	>	}
506	>
507	>	/**
508	>	*  awaitAdvance continues waiting if interrupted while waiting
509	>	*/
510	>	public void testAwaitAdvanceBeforeInterrupt() {
511	>	final Phaser phaser = new Phaser();
512	>	assertEquals(0, phaser.register());
513	>	final CountDownLatch pleaseArrive = new CountDownLatch(1);
514	>
515	>	Thread t = newStartedThread(new CheckedRunnable() {
516	>	public void realRun() {
517	>	assertEquals(0, phaser.register());
518	>	assertEquals(0, phaser.arrive());
519	>	assertFalse(Thread.currentThread().isInterrupted());
520	>	pleaseArrive.countDown();
521	>	assertEquals(1, phaser.awaitAdvance(0));
522	>	assertTrue(Thread.interrupted());
523	>	}});
524	>
525	>	await(pleaseArrive);
526	>	waitForThreadToEnterWaitState(t, SHORT_DELAY_MS);
527		t.interrupt();
528		assertEquals(0, phaser.arrive());
529	<	awaitTermination(t, SMALL_DELAY_MS);
529	>	awaitTermination(t);
530	>
531	>	Thread.currentThread().interrupt();
532	>	assertEquals(1, phaser.awaitAdvance(0));
533	>	assertTrue(Thread.interrupted());
534	>	}
535	>
536	>	/**
537	>	* arriveAndAwaitAdvance continues waiting if interrupted before waiting
538	>	*/
539	>	public void testArriveAndAwaitAdvanceAfterInterrupt() {
540	>	final Phaser phaser = new Phaser();
541	>	assertEquals(0, phaser.register());
542	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
543	>
544	>	Thread t = newStartedThread(new CheckedRunnable() {
545	>	public void realRun() {
546	>	Thread.currentThread().interrupt();
547	>	assertEquals(0, phaser.register());
548	>	pleaseInterrupt.countDown();
549	>	assertTrue(Thread.currentThread().isInterrupted());
550	>	assertEquals(1, phaser.arriveAndAwaitAdvance());
551	>	assertTrue(Thread.currentThread().isInterrupted());
552	>	}});
553	>
554	>	await(pleaseInterrupt);
555	>	waitForThreadToEnterWaitState(t, SHORT_DELAY_MS);
556	>	Thread.currentThread().interrupt();
557	>	assertEquals(1, phaser.arriveAndAwaitAdvance());
558	>	assertTrue(Thread.interrupted());
559	>	awaitTermination(t);
560	>	}
561	>
562	>	/**
563	>	* arriveAndAwaitAdvance continues waiting if interrupted while waiting
564	>	*/
565	>	public void testArriveAndAwaitAdvanceBeforeInterrupt() {
566	>	final Phaser phaser = new Phaser();
567	>	assertEquals(0, phaser.register());
568	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
569	>
570	>	Thread t = newStartedThread(new CheckedRunnable() {
571	>	public void realRun() {
572	>	assertEquals(0, phaser.register());
573	>	assertFalse(Thread.currentThread().isInterrupted());
574	>	pleaseInterrupt.countDown();
575	>	assertEquals(1, phaser.arriveAndAwaitAdvance());
576	>	assertTrue(Thread.currentThread().isInterrupted());
577	>	}});
578	>
579	>	await(pleaseInterrupt);
580	>	waitForThreadToEnterWaitState(t, SHORT_DELAY_MS);
581	>	t.interrupt();
582	>	Thread.currentThread().interrupt();
583	>	assertEquals(1, phaser.arriveAndAwaitAdvance());
584	>	assertTrue(Thread.interrupted());
585	>	awaitTermination(t);
586		}
587
588		/**
589		* awaitAdvance atomically waits for all parties within the same phase to
590		* complete before continuing
591		*/
592	<	public void testAwaitAdvance4() throws InterruptedException {
592	>	public void testAwaitAdvance4() {
593		final Phaser phaser = new Phaser(4);
594		final AtomicInteger count = new AtomicInteger(0);
595		List<Thread> threads = new ArrayList<Thread>();
#	Line 426 | Line 605 | public class PhaserTest extends JSR166Te
605		}}}));
606
607		for (Thread thread : threads)
608	<	awaitTermination(thread, MEDIUM_DELAY_MS);
608	>	awaitTermination(thread);
609		}
610
611		/**
612		* awaitAdvance returns the current phase
613		*/
614	<	public void testAwaitAdvance5() throws InterruptedException {
614	>	public void testAwaitAdvance5() {
615		final Phaser phaser = new Phaser(1);
616		assertEquals(1, phaser.awaitAdvance(phaser.arrive()));
617		assertEquals(1, phaser.getPhase());
#	Line 442 | Line 621 | public class PhaserTest extends JSR166Te
621		final CountDownLatch latch = new CountDownLatch(1);
622		final boolean goesFirst = ((i & 1) == 0);
623		threads.add(newStartedThread(new CheckedRunnable() {
624	<	public void realRun() throws InterruptedException {
624	>	public void realRun() {
625		if (goesFirst)
626		latch.countDown();
627		else
628	<	assertTrue(latch.await(SMALL_DELAY_MS, MILLISECONDS));
628	>	await(latch);
629		phaser.arrive();
630		}}));
631		if (goesFirst)
632	<	assertTrue(latch.await(SMALL_DELAY_MS, MILLISECONDS));
632	>	await(latch);
633		else
634		latch.countDown();
635		assertEquals(i + 2, phaser.awaitAdvance(phaser.arrive()));
636		assertEquals(i + 2, phaser.getPhase());
637		}
638		for (Thread thread : threads)
639	<	awaitTermination(thread, SMALL_DELAY_MS);
639	>	awaitTermination(thread);
640	>	}
641	>
642	>	/**
643	>	* awaitAdvance returns the current phase in child phasers
644	>	*/
645	>	public void testAwaitAdvanceTieredPhaser() throws Exception {
646	>	final Phaser parent = new Phaser();
647	>	final List<Phaser> zeroPartyChildren = new ArrayList<Phaser>(3);
648	>	final List<Phaser> onePartyChildren = new ArrayList<Phaser>(3);
649	>	for (int i = 0; i < 3; i++) {
650	>	zeroPartyChildren.add(new Phaser(parent, 0));
651	>	onePartyChildren.add(new Phaser(parent, 1));
652	>	}
653	>	final List<Phaser> phasers = new ArrayList<Phaser>();
654	>	phasers.addAll(zeroPartyChildren);
655	>	phasers.addAll(onePartyChildren);
656	>	phasers.add(parent);
657	>	for (Phaser phaser : phasers) {
658	>	assertEquals(-42, phaser.awaitAdvance(-42));
659	>	assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42));
660	>	assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, SMALL_DELAY_MS, MILLISECONDS));
661	>	}
662	>
663	>	for (Phaser child : onePartyChildren)
664	>	assertEquals(0, child.arrive());
665	>	for (Phaser phaser : phasers) {
666	>	assertEquals(-42, phaser.awaitAdvance(-42));
667	>	assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42));
668	>	assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, SMALL_DELAY_MS, MILLISECONDS));
669	>	assertEquals(1, phaser.awaitAdvance(0));
670	>	assertEquals(1, phaser.awaitAdvanceInterruptibly(0));
671	>	assertEquals(1, phaser.awaitAdvanceInterruptibly(0, SMALL_DELAY_MS, MILLISECONDS));
672	>	}
673	>
674	>	for (Phaser child : onePartyChildren)
675	>	assertEquals(1, child.arrive());
676	>	for (Phaser phaser : phasers) {
677	>	assertEquals(-42, phaser.awaitAdvance(-42));
678	>	assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42));
679	>	assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, SMALL_DELAY_MS, MILLISECONDS));
680	>	assertEquals(2, phaser.awaitAdvance(0));
681	>	assertEquals(2, phaser.awaitAdvanceInterruptibly(0));
682	>	assertEquals(2, phaser.awaitAdvanceInterruptibly(0, SMALL_DELAY_MS, MILLISECONDS));
683	>	assertEquals(2, phaser.awaitAdvance(1));
684	>	assertEquals(2, phaser.awaitAdvanceInterruptibly(1));
685	>	assertEquals(2, phaser.awaitAdvanceInterruptibly(1, SMALL_DELAY_MS, MILLISECONDS));
686	>	}
687		}
688
689		/**
690		* awaitAdvance returns when the phaser is externally terminated
691		*/
692	<	public void testAwaitAdvance6() throws InterruptedException {
692	>	public void testAwaitAdvance6() {
693		final Phaser phaser = new Phaser(3);
694	<	final CountDownLatch threadsStarted = new CountDownLatch(2);
694	>	final CountDownLatch pleaseForceTermination = new CountDownLatch(2);
695		final List<Thread> threads = new ArrayList<Thread>();
696		for (int i = 0; i < 2; i++) {
697		Runnable r = new CheckedRunnable() {
698		public void realRun() {
699		assertEquals(0, phaser.arrive());
700	<	threadsStarted.countDown();
700	>	pleaseForceTermination.countDown();
701		assertTrue(phaser.awaitAdvance(0) < 0);
702		assertTrue(phaser.isTerminated());
703		assertTrue(phaser.getPhase() < 0);
704	+	assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE);
705		assertEquals(3, phaser.getRegisteredParties());
706		}};
707		threads.add(newStartedThread(r));
708		}
709	<	threadsStarted.await();
709	>	await(pleaseForceTermination);
710		phaser.forceTermination();
484	–	for (Thread thread : threads)
485	–	awaitTermination(thread, SMALL_DELAY_MS);
711		assertTrue(phaser.isTerminated());
712	<	assertTrue(phaser.getPhase() < 0);
712	>	assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE);
713	>	for (Thread thread : threads)
714	>	awaitTermination(thread);
715		assertEquals(3, phaser.getRegisteredParties());
716		}
717
#	Line 501 | Line 728 | public class PhaserTest extends JSR166Te
728		}
729
730		/**
504	–	* Interrupted arriveAndAwaitAdvance does not throw InterruptedException
505	–	*/
506	–	public void testArriveAndAwaitAdvance2() throws InterruptedException {
507	–	final Phaser phaser = new Phaser(2);
508	–	final CountDownLatch threadStarted = new CountDownLatch(1);
509	–	final AtomicBoolean advanced = new AtomicBoolean(false);
510	–	final AtomicBoolean checkedInterruptStatus = new AtomicBoolean(false);
511	–	Thread t = newStartedThread(new CheckedRunnable() {
512	–	public void realRun() throws InterruptedException {
513	–	threadStarted.countDown();
514	–	assertEquals(1, phaser.arriveAndAwaitAdvance());
515	–	assertState(phaser, 1, 2, 2);
516	–	advanced.set(true);
517	–	assertTrue(Thread.currentThread().isInterrupted());
518	–	while (!checkedInterruptStatus.get())
519	–	Thread.yield();
520	–	}});
521	–
522	–	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
523	–	t.interrupt();
524	–	assertEquals(0, phaser.arrive());
525	–	while (!advanced.get())
526	–	Thread.yield();
527	–	assertTrue(t.isInterrupted());
528	–	checkedInterruptStatus.set(true);
529	–	awaitTermination(t, SMALL_DELAY_MS);
530	–	}
531	–
532	–	/**
731		* arriveAndAwaitAdvance waits for all threads to arrive, the
732		* number of arrived parties is the same number that is accounted
733		* for when the main thread awaitsAdvance
734		*/
735	<	public void testArriveAndAwaitAdvance3() throws InterruptedException {
735	>	public void testArriveAndAwaitAdvance3() {
736		final Phaser phaser = new Phaser(1);
737		final int THREADS = 3;
738	<	final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
738	>	final CountDownLatch pleaseArrive = new CountDownLatch(THREADS);
739		final List<Thread> threads = new ArrayList<Thread>();
740		for (int i = 0; i < THREADS; i++)
741		threads.add(newStartedThread(new CheckedRunnable() {
742	<	public void realRun() throws InterruptedException {
742	>	public void realRun() {
743		assertEquals(0, phaser.register());
744	<	threadsStarted.countDown();
744	>	pleaseArrive.countDown();
745		assertEquals(1, phaser.arriveAndAwaitAdvance());
746		}}));
747
748	<	assertTrue(threadsStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
749	<	long t0 = System.nanoTime();
748	>	await(pleaseArrive);
749	>	long startTime = System.nanoTime();
750		while (phaser.getArrivedParties() < THREADS)
751		Thread.yield();
752		assertEquals(THREADS, phaser.getArrivedParties());
753	<	assertTrue(NANOSECONDS.toMillis(System.nanoTime() - t0) < SMALL_DELAY_MS);
753	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
754	>	for (Thread thread : threads)
755	>	waitForThreadToEnterWaitState(thread, SHORT_DELAY_MS);
756		for (Thread thread : threads)
757		assertTrue(thread.isAlive());
758		assertState(phaser, 0, THREADS + 1, 1);
759		phaser.arriveAndAwaitAdvance();
760		for (Thread thread : threads)
761	<	awaitTermination(thread, SMALL_DELAY_MS);
761	>	awaitTermination(thread);
762		assertState(phaser, 1, THREADS + 1, THREADS + 1);
763		}
764

Diff Legend

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