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.6 by jsr166, Mon Aug 3 22:06:50 2009 UTC vs.
Revision 1.17 by jsr166, Mon Oct 11 07:43:53 2010 UTC

#	Line 8 | Line 8
8		import java.util.ArrayList;
9		import java.util.List;
10		import java.util.concurrent.atomic.AtomicInteger;
11	+	import java.util.concurrent.atomic.AtomicBoolean;
12		import java.util.concurrent.*;
13	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
14		import junit.framework.Test;
15		import junit.framework.TestSuite;
16
#	Line 41 | Line 43 | public class PhaserTest extends JSR166Te
43		try {
44		new Phaser(-1);
45		shouldThrow();
46	<	} catch (IllegalArgumentException success) {
45	<	}
46	>	} catch (IllegalArgumentException success) {}
47		}
48
49		/**
#	Line 62 | Line 63 | public class PhaserTest extends JSR166Te
63		try {
64		new Phaser(new Phaser(), -1);
65		shouldThrow();
66	<	} catch (IllegalArgumentException success) {
66	<	}
66	>	} catch (IllegalArgumentException success) {}
67		}
68
69		/**
#	Line 100 | Line 100 | public class PhaserTest extends JSR166Te
100		try {
101		phaser.register();
102		shouldThrow();
103	<	} catch (IllegalStateException success) {
104	<	}
103	>	} catch (IllegalStateException success) {}
104		}
105
106		/**
#	Line 141 | Line 140 | public class PhaserTest extends JSR166Te
140		try {
141		new Phaser().bulkRegister(-1);
142		shouldThrow();
143	<	} catch (IllegalArgumentException success) {
145	<	}
143	>	} catch (IllegalArgumentException success) {}
144		}
145
146		/**
#	Line 163 | Line 161 | public class PhaserTest extends JSR166Te
161		try {
162		new Phaser().bulkRegister(1 << 16);
163		shouldThrow();
164	<	} catch (IllegalStateException success) {
167	<	}
164	>	} catch (IllegalStateException success) {}
165		}
166
167		/**
#	Line 181 | Line 178 | public class PhaserTest extends JSR166Te
178		}
179
180		/**
181	<	*  Arrive() on a registered phaser increments phase.
181	>	* Arrive() on a registered phaser increments phase.
182		*/
183		public void testArrive1() {
184		Phaser phaser = new Phaser(1);
#	Line 190 | Line 187 | public class PhaserTest extends JSR166Te
187		}
188
189		/**
190	<	* arrive does not wait for others to arrive at barrier
190	>	* arriveAndDeregister does not wait for others to arrive at barrier
191		*/
192	<	public void testArrive2() {
192	>	public void testArrive2() throws InterruptedException {
193		final Phaser phaser = new Phaser(1);
194		phaser.register();
195	<	Thread thread = null;
196	<	for (final Runnable r : getRunnables(10, SHORT_DELAY_MS)) {
195	>	List<Thread> threads = new ArrayList<Thread>();
196	>	for (int i = 0; i < 10; i++)
197		phaser.register();
198	<	thread = new Thread(new CheckedRunnable() {
199	<	void realRun() {
200	<	r.run();
198	>	threads.add(newStartedThread(new CheckedRunnable() {
199	>	public void realRun() throws InterruptedException {
200	>	Thread.sleep(SMALL_DELAY_MS);
201		phaser.arriveAndDeregister();
202	<	}});
206	<	thread.start();
207	<	}
202	>	}}));
203
204		phaser.arrive();
205	<	assertTrue(thread.isAlive());
205	>	assertTrue(threads.get(0).isAlive());
206		assertFalse(phaser.isTerminated());
207	+	for (Thread thread : threads)
208	+	thread.join();
209		}
210
211		/**
#	Line 218 | Line 215 | public class PhaserTest extends JSR166Te
215		Phaser phaser = new Phaser(1);
216		phaser.forceTermination();
217		assertTrue(phaser.arrive() < 0);
221	–
218		}
219
220		/**
#	Line 230 | Line 226 | public class PhaserTest extends JSR166Te
226		Phaser phaser = new Phaser();
227		phaser.arriveAndDeregister();
228		shouldThrow();
229	<	} catch (IllegalStateException success) {
234	<	}
229	>	} catch (IllegalStateException success) {}
230		}
231
232		/**
#	Line 242 | Line 237 | public class PhaserTest extends JSR166Te
237		phaser.register();
238		phaser.arrive();
239		int p = phaser.getArrivedParties();
240	<	assertTrue(p == 1);
240	>	assertEquals(1, p);
241		phaser.arriveAndDeregister();
242		assertTrue(phaser.getArrivedParties() < p);
243		}
#	Line 259 | Line 254 | public class PhaserTest extends JSR166Te
254		assertTrue(parent.getUnarrivedParties() > 0);
255		assertTrue(root.getUnarrivedParties() > 0);
256		root.arriveAndDeregister();
257	<	assertTrue(parent.getUnarrivedParties() == 0);
258	<	assertTrue(root.getUnarrivedParties() == 0);
257	>	assertEquals(0, parent.getUnarrivedParties());
258	>	assertEquals(0, root.getUnarrivedParties());
259		assertTrue(root.isTerminated() && parent.isTerminated());
260		}
261
#	Line 290 | Line 285 | public class PhaserTest extends JSR166Te
285		assertTrue(child.getUnarrivedParties() > 0);
286		root.register();
287		root.arriveAndDeregister();
288	<	assertTrue(parent.getUnarrivedParties() == 0);
289	<	assertTrue(child.getUnarrivedParties() == 0);
288	>	assertEquals(0, parent.getUnarrivedParties());
289	>	assertEquals(0, child.getUnarrivedParties());
290		assertTrue(root.isTerminated());
291		}
292
#	Line 299 | Line 294 | public class PhaserTest extends JSR166Te
294		* arriveAndDeregister returns the phase in which it leaves the
295		* phaser in after deregistration
296		*/
297	<	public void testArriveAndDeregister6() {
297	>	public void testArriveAndDeregister6() throws InterruptedException {
298		final Phaser phaser = new Phaser(2);
299	<	new Thread(new CheckedRunnable() {
300	<	void realRun() {
301	<	getRunnable(SHORT_DELAY_MS).run();
299	>	Thread t = newStartedThread(new CheckedRunnable() {
300	>	public void realRun() {
301	>	sleepTillInterrupted(SHORT_DELAY_MS);
302		phaser.arrive();
303	<	}}).start();
303	>	}});
304		phaser.arriveAndAwaitAdvance();
305		int phase = phaser.arriveAndDeregister();
306		assertEquals(phase, phaser.getPhase());
307	+	t.join();
308		}
309
310		/**
#	Line 333 | Line 329 | public class PhaserTest extends JSR166Te
329		*/
330		public void testAwaitAdvance3() throws InterruptedException {
331		final Phaser phaser = new Phaser();
332	+	phaser.register();
333	+	final CountDownLatch threadStarted = new CountDownLatch(1);
334
335	<	Thread th1 = new Thread(new CheckedRunnable() {
336	<	void realRun() throws InterruptedException {
335	>	Thread t = newStartedThread(new CheckedRunnable() {
336	>	public void realRun() throws InterruptedException {
337		phaser.register();
338	<	getRunnable(LONG_DELAY_MS).run();
338	>	threadStarted.countDown();
339		phaser.awaitAdvance(phaser.arrive());
340	+	assertTrue(Thread.currentThread().isInterrupted());
341		}});
342	<	phaser.register();
343	<	th1.start();
345	<	Thread.sleep(SHORT_DELAY_MS);
346	<	th1.interrupt();
347	<	Thread.sleep(LONG_DELAY_MS);
342	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
343	>	t.interrupt();
344		phaser.arrive();
345	<	assertFalse(th1.isInterrupted());
345	>	awaitTermination(t, SMALL_DELAY_MS);
346		}
347
348		/**
#	Line 358 | Line 354 | public class PhaserTest extends JSR166Te
354		final AtomicInteger phaseCount = new AtomicInteger(0);
355		List<Thread> threads = new ArrayList<Thread>();
356		for (int i = 0; i < 4; i++) {
357	<	threads.add(new Thread(new CheckedRunnable() {
358	<	void realRun() {
357	>	threads.add(newStartedThread(new CheckedRunnable() {
358	>	public void realRun() {
359		int phase = phaser.arrive();
360		phaseCount.incrementAndGet();
361	<	getRunnable(LONG_DELAY_MS).run();
361	>	sleepTillInterrupted(SMALL_DELAY_MS);
362		phaser.awaitAdvance(phase);
363	<	threadAssertTrue(phaseCount.get() == 4);
363	>	assertEquals(phaseCount.get(), 4);
364		}}));
365		}
366		for (Thread thread : threads)
371	–	thread.start();
372	–	for (Thread thread : threads)
367		thread.join();
368		}
369
370		/**
371		* awaitAdvance returns the current phase
372		*/
373	<	public void testAwaitAdvance5() {
373	>	public void testAwaitAdvance5() throws InterruptedException {
374		final Phaser phaser = new Phaser(1);
375		int phase = phaser.awaitAdvance(phaser.arrive());
376		assertEquals(phase, phaser.getPhase());
377		phaser.register();
378	<	for (int i = 0; i < eight; i++) {
379	<	new Thread(new CheckedRunnable() {
380	<	void realRun() {
381	<	getRunnable(SHORT_DELAY_MS).run();
378	>	List<Thread> threads = new ArrayList<Thread>();
379	>	for (int i = 0; i < 8; i++) {
380	>	threads.add(newStartedThread(new CheckedRunnable() {
381	>	public void realRun() {
382	>	sleepTillInterrupted(SHORT_DELAY_MS);
383		phaser.arrive();
384	<	}}).start();
384	>	}}));
385		phase = phaser.awaitAdvance(phaser.arrive());
386	<	threadAssertEquals(phase, phaser.getPhase());
386	>	assertEquals(phase, phaser.getPhase());
387		}
388	+	for (Thread thread : threads)
389	+	thread.join();
390		}
391
392		/**
393		* awaitAdvance returns when the phaser is externally terminated
394		*/
395	<	public void testAwaitAdvance6() {
395	>	public void testAwaitAdvance6() throws InterruptedException {
396		final Phaser phaser = new Phaser(3);
397		/*
398		* Start new thread. This thread waits a small amount of time
#	Line 403 | Line 400 | public class PhaserTest extends JSR166Te
400		* in the main thread arrives quickly so at best this thread
401		* waits for the second thread's party to arrive
402		*/
403	<	new Thread(new CheckedRunnable() {
404	<	void realRun() {
405	<	getRunnable(SMALL_DELAY_MS).run();
403	>	Thread t1 = newStartedThread(new CheckedRunnable() {
404	>	public void realRun() {
405	>	sleepTillInterrupted(SMALL_DELAY_MS);
406		int phase = phaser.awaitAdvance(phaser.arrive());
407		/*
408		* This point is reached when force termination is called in which phase = -1
409		*/
410	<	threadAssertTrue(phase < 0);
411	<	threadAssertTrue(phaser.isTerminated());
412	<	}}).start();
410	>	assertTrue(phase < 0);
411	>	assertTrue(phaser.isTerminated());
412	>	}});
413		/*
414		* This thread will cause the first thread run to wait, in doing so
415		* the main thread will force termination in which the first thread
416		* should exit peacefully as this one
417		*/
418	<	new Thread(new CheckedRunnable() {
419	<	void realRun() {
420	<	getRunnable(LONG_DELAY_MS).run();
418	>	Thread t2 = newStartedThread(new CheckedRunnable() {
419	>	public void realRun() {
420	>	sleepTillInterrupted(MEDIUM_DELAY_MS);
421		int p1 = phaser.arrive();
422		int phase = phaser.awaitAdvance(p1);
423	<	threadAssertTrue(phase < 0);
424	<	threadAssertTrue(phaser.isTerminated());
425	<	}}).start();
423	>	assertTrue(phase < 0);
424	>	assertTrue(phaser.isTerminated());
425	>	}});
426
427		phaser.arrive();
428		phaser.forceTermination();
429	+	t1.join();
430	+	t2.join();
431		}
432
433		/**
#	Line 440 | Line 439 | public class PhaserTest extends JSR166Te
439		Phaser phaser = new Phaser();
440		phaser.arriveAndAwaitAdvance();
441		shouldThrow();
442	<	} catch (IllegalStateException success) {
444	<	}
442	>	} catch (IllegalStateException success) {}
443		}
444
445		/**
#	Line 449 | Line 447 | public class PhaserTest extends JSR166Te
447		*/
448		public void testArriveAndAwaitAdvance2() throws InterruptedException {
449		final Phaser phaser = new Phaser(2);
450	<	Thread th = new Thread(new CheckedRunnable() {
451	<	void realRun() {
450	>	final CountDownLatch threadStarted = new CountDownLatch(1);
451	>	final AtomicBoolean advanced = new AtomicBoolean(false);
452	>	final AtomicBoolean checkedInterruptStatus = new AtomicBoolean(false);
453	>	Thread t = newStartedThread(new CheckedRunnable() {
454	>	public void realRun() throws InterruptedException {
455	>	threadStarted.countDown();
456		phaser.arriveAndAwaitAdvance();
457	+	advanced.set(true);
458	+	assertTrue(Thread.currentThread().isInterrupted());
459	+	while (!checkedInterruptStatus.get())
460	+	Thread.yield();
461		}});
462
463	<	th.start();
464	<	Thread.sleep(LONG_DELAY_MS);
459	<	th.interrupt();
460	<	Thread.sleep(LONG_DELAY_MS);
463	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
464	>	t.interrupt();
465		phaser.arrive();
466	<	assertFalse(th.isInterrupted());
466	>	while (!advanced.get())
467	>	Thread.yield();
468	>	assertTrue(t.isInterrupted());
469	>	checkedInterruptStatus.set(true);
470	>	awaitTermination(t, SMALL_DELAY_MS);
471		}
472
473		/**
#	Line 467 | Line 475 | public class PhaserTest extends JSR166Te
475		* number of arrived parties is the same number that is accounted
476		* for when the main thread awaitsAdvance
477		*/
478	<	public void testArriveAndAwaitAdvance3() {
478	>	public void testArriveAndAwaitAdvance3() throws InterruptedException {
479		final Phaser phaser = new Phaser(1);
480	<	final AtomicInteger arrivingCount = new AtomicInteger(0);
481	<	for (final Runnable run : getRunnables(six, SHORT_DELAY_MS)) {
482	<	new Thread(new CheckedRunnable() {
483	<	void realRun() {
484	<	phaser.register();
485	<	run.run();
486	<	arrivingCount.getAndIncrement();
479	<	phaser.arrive();
480	<	}}).start();
480	>	final List<Thread> threads = new ArrayList<Thread>();
481	>	for (int i = 0; i < 3; i++) {
482	>	threads.add(newStartedThread(new CheckedRunnable() {
483	>	public void realRun() throws InterruptedException {
484	>	phaser.register();
485	>	phaser.arriveAndAwaitAdvance();
486	>	}}));
487		}
488	<	int phaseNumber = phaser.arriveAndAwaitAdvance();
489	<	arrivingCount.incrementAndGet();
490	<	//the + 1 adds to expectedArrive to account for the main threads arrival
491	<	int expectedArrived = phaseNumber > 0 ? phaseNumber * six + 1 : phaser.getArrivedParties() + 1;
492	<	threadAssertEquals(expectedArrived, arrivingCount.get());
487	<	}
488	<	// .. initially called, for n tasks via
489	<	private List<Runnable> getRunnables(int size, long wait) {
490	<	List<Runnable> list = new ArrayList<Runnable>();
491	<	for (int i = 0; i < size; i++) {
492	<	list.add(getRunnable(wait));
493	<	}
494	<	return list;
495	<	}
496	<
497	<	private Runnable getRunnable(final long wait) {
498	<	return new CheckedRunnable() {
499	<	void realRun() {
500	<	try {
501	<	Thread.sleep(wait);
502	<	} catch (InterruptedException noop) {
503	<	// sleep interruption isn't a problem case for these example
504	<	}
505	<	}
506	<	};
488	>	Thread.sleep(MEDIUM_DELAY_MS);
489	>	assertEquals(phaser.getArrivedParties(), 3);
490	>	phaser.arriveAndAwaitAdvance();
491	>	for (Thread thread : threads)
492	>	thread.join();
493		}
494
495		}

Diff Legend

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