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.14 by jsr166, Thu Sep 16 00:52:49 2010 UTC

#	Line 41 | Line 41 | public class PhaserTest extends JSR166Te
41		try {
42		new Phaser(-1);
43		shouldThrow();
44	<	} catch (IllegalArgumentException success) {
45	<	}
44	>	} catch (IllegalArgumentException success) {}
45		}
46
47		/**
#	Line 62 | Line 61 | public class PhaserTest extends JSR166Te
61		try {
62		new Phaser(new Phaser(), -1);
63		shouldThrow();
64	<	} catch (IllegalArgumentException success) {
66	<	}
64	>	} catch (IllegalArgumentException success) {}
65		}
66
67		/**
#	Line 100 | Line 98 | public class PhaserTest extends JSR166Te
98		try {
99		phaser.register();
100		shouldThrow();
101	<	} catch (IllegalStateException success) {
104	<	}
101	>	} catch (IllegalStateException success) {}
102		}
103
104		/**
#	Line 141 | Line 138 | public class PhaserTest extends JSR166Te
138		try {
139		new Phaser().bulkRegister(-1);
140		shouldThrow();
141	<	} catch (IllegalArgumentException success) {
145	<	}
141	>	} catch (IllegalArgumentException success) {}
142		}
143
144		/**
#	Line 163 | Line 159 | public class PhaserTest extends JSR166Te
159		try {
160		new Phaser().bulkRegister(1 << 16);
161		shouldThrow();
162	<	} catch (IllegalStateException success) {
167	<	}
162	>	} catch (IllegalStateException success) {}
163		}
164
165		/**
#	Line 190 | Line 185 | public class PhaserTest extends JSR166Te
185		}
186
187		/**
188	<	* arrive does not wait for others to arrive at barrier
188	>	* arriveAndDeregister does not wait for others to arrive at barrier
189		*/
190	<	public void testArrive2() {
190	>	public void testArrive2() throws InterruptedException {
191		final Phaser phaser = new Phaser(1);
192		phaser.register();
193	<	Thread thread = null;
194	<	for (final Runnable r : getRunnables(10, SHORT_DELAY_MS)) {
193	>	List<Thread> threads = new ArrayList<Thread>();
194	>	for (int i = 0; i < 10; i++)
195		phaser.register();
196	<	thread = new Thread(new CheckedRunnable() {
197	<	void realRun() {
198	<	r.run();
196	>	threads.add(newStartedThread(new CheckedRunnable() {
197	>	public void realRun() throws InterruptedException {
198	>	Thread.sleep(SMALL_DELAY_MS);
199		phaser.arriveAndDeregister();
200	<	}});
206	<	thread.start();
207	<	}
200	>	}}));
201
202		phaser.arrive();
203	<	assertTrue(thread.isAlive());
203	>	assertTrue(threads.get(0).isAlive());
204		assertFalse(phaser.isTerminated());
205	+	for (Thread thread : threads)
206	+	thread.join();
207		}
208
209		/**
#	Line 218 | Line 213 | public class PhaserTest extends JSR166Te
213		Phaser phaser = new Phaser(1);
214		phaser.forceTermination();
215		assertTrue(phaser.arrive() < 0);
221	–
216		}
217
218		/**
#	Line 230 | Line 224 | public class PhaserTest extends JSR166Te
224		Phaser phaser = new Phaser();
225		phaser.arriveAndDeregister();
226		shouldThrow();
227	<	} catch (IllegalStateException success) {
234	<	}
227	>	} catch (IllegalStateException success) {}
228		}
229
230		/**
#	Line 242 | Line 235 | public class PhaserTest extends JSR166Te
235		phaser.register();
236		phaser.arrive();
237		int p = phaser.getArrivedParties();
238	<	assertTrue(p == 1);
238	>	assertEquals(1, p);
239		phaser.arriveAndDeregister();
240		assertTrue(phaser.getArrivedParties() < p);
241		}
#	Line 259 | Line 252 | public class PhaserTest extends JSR166Te
252		assertTrue(parent.getUnarrivedParties() > 0);
253		assertTrue(root.getUnarrivedParties() > 0);
254		root.arriveAndDeregister();
255	<	assertTrue(parent.getUnarrivedParties() == 0);
256	<	assertTrue(root.getUnarrivedParties() == 0);
255	>	assertEquals(0, parent.getUnarrivedParties());
256	>	assertEquals(0, root.getUnarrivedParties());
257		assertTrue(root.isTerminated() && parent.isTerminated());
258		}
259
#	Line 290 | Line 283 | public class PhaserTest extends JSR166Te
283		assertTrue(child.getUnarrivedParties() > 0);
284		root.register();
285		root.arriveAndDeregister();
286	<	assertTrue(parent.getUnarrivedParties() == 0);
287	<	assertTrue(child.getUnarrivedParties() == 0);
286	>	assertEquals(0, parent.getUnarrivedParties());
287	>	assertEquals(0, child.getUnarrivedParties());
288		assertTrue(root.isTerminated());
289		}
290
#	Line 299 | Line 292 | public class PhaserTest extends JSR166Te
292		* arriveAndDeregister returns the phase in which it leaves the
293		* phaser in after deregistration
294		*/
295	<	public void testArriveAndDeregister6() {
295	>	public void testArriveAndDeregister6() throws InterruptedException {
296		final Phaser phaser = new Phaser(2);
297	<	new Thread(new CheckedRunnable() {
298	<	void realRun() {
299	<	getRunnable(SHORT_DELAY_MS).run();
297	>	Thread t = newStartedThread(new CheckedRunnable() {
298	>	public void realRun() {
299	>	sleepTillInterrupted(SHORT_DELAY_MS);
300		phaser.arrive();
301	<	}}).start();
301	>	}});
302		phaser.arriveAndAwaitAdvance();
303		int phase = phaser.arriveAndDeregister();
304		assertEquals(phase, phaser.getPhase());
305	+	t.join();
306		}
307
308		/**
#	Line 333 | Line 327 | public class PhaserTest extends JSR166Te
327		*/
328		public void testAwaitAdvance3() throws InterruptedException {
329		final Phaser phaser = new Phaser();
330	+	phaser.register();
331
332	<	Thread th1 = new Thread(new CheckedRunnable() {
333	<	void realRun() throws InterruptedException {
332	>	Thread t = newStartedThread(new CheckedRunnable() {
333	>	public void realRun() throws InterruptedException {
334		phaser.register();
335	<	getRunnable(LONG_DELAY_MS).run();
335	>	sleepTillInterrupted(LONG_DELAY_MS);
336		phaser.awaitAdvance(phaser.arrive());
337		}});
338	<	phaser.register();
339	<	th1.start();
340	<	Thread.sleep(SHORT_DELAY_MS);
346	<	th1.interrupt();
347	<	Thread.sleep(LONG_DELAY_MS);
338	>	Thread.sleep(SMALL_DELAY_MS);
339	>	t.interrupt();
340	>	Thread.sleep(SMALL_DELAY_MS);
341		phaser.arrive();
342	<	assertFalse(th1.isInterrupted());
342	>	assertFalse(t.isInterrupted());
343	>	t.join();
344		}
345
346		/**
#	Line 358 | Line 352 | public class PhaserTest extends JSR166Te
352		final AtomicInteger phaseCount = new AtomicInteger(0);
353		List<Thread> threads = new ArrayList<Thread>();
354		for (int i = 0; i < 4; i++) {
355	<	threads.add(new Thread(new CheckedRunnable() {
356	<	void realRun() {
355	>	threads.add(newStartedThread(new CheckedRunnable() {
356	>	public void realRun() {
357		int phase = phaser.arrive();
358		phaseCount.incrementAndGet();
359	<	getRunnable(LONG_DELAY_MS).run();
359	>	sleepTillInterrupted(SMALL_DELAY_MS);
360		phaser.awaitAdvance(phase);
361	<	threadAssertTrue(phaseCount.get() == 4);
361	>	assertEquals(phaseCount.get(), 4);
362		}}));
363		}
364		for (Thread thread : threads)
371	–	thread.start();
372	–	for (Thread thread : threads)
365		thread.join();
366		}
367
368		/**
369		* awaitAdvance returns the current phase
370		*/
371	<	public void testAwaitAdvance5() {
371	>	public void testAwaitAdvance5() throws InterruptedException {
372		final Phaser phaser = new Phaser(1);
373		int phase = phaser.awaitAdvance(phaser.arrive());
374		assertEquals(phase, phaser.getPhase());
375		phaser.register();
376	<	for (int i = 0; i < eight; i++) {
377	<	new Thread(new CheckedRunnable() {
378	<	void realRun() {
379	<	getRunnable(SHORT_DELAY_MS).run();
376	>	List<Thread> threads = new ArrayList<Thread>();
377	>	for (int i = 0; i < 8; i++) {
378	>	threads.add(newStartedThread(new CheckedRunnable() {
379	>	public void realRun() {
380	>	sleepTillInterrupted(SHORT_DELAY_MS);
381		phaser.arrive();
382	<	}}).start();
382	>	}}));
383		phase = phaser.awaitAdvance(phaser.arrive());
384	<	threadAssertEquals(phase, phaser.getPhase());
384	>	assertEquals(phase, phaser.getPhase());
385		}
386	+	for (Thread thread : threads)
387	+	thread.join();
388		}
389
390		/**
391		* awaitAdvance returns when the phaser is externally terminated
392		*/
393	<	public void testAwaitAdvance6() {
393	>	public void testAwaitAdvance6() throws InterruptedException {
394		final Phaser phaser = new Phaser(3);
395		/*
396		* Start new thread. This thread waits a small amount of time
#	Line 403 | Line 398 | public class PhaserTest extends JSR166Te
398		* in the main thread arrives quickly so at best this thread
399		* waits for the second thread's party to arrive
400		*/
401	<	new Thread(new CheckedRunnable() {
402	<	void realRun() {
403	<	getRunnable(SMALL_DELAY_MS).run();
401	>	Thread t1 = newStartedThread(new CheckedRunnable() {
402	>	public void realRun() {
403	>	sleepTillInterrupted(SMALL_DELAY_MS);
404		int phase = phaser.awaitAdvance(phaser.arrive());
405		/*
406		* This point is reached when force termination is called in which phase = -1
407		*/
408	<	threadAssertTrue(phase < 0);
409	<	threadAssertTrue(phaser.isTerminated());
410	<	}}).start();
408	>	assertTrue(phase < 0);
409	>	assertTrue(phaser.isTerminated());
410	>	}});
411		/*
412		* This thread will cause the first thread run to wait, in doing so
413		* the main thread will force termination in which the first thread
414		* should exit peacefully as this one
415		*/
416	<	new Thread(new CheckedRunnable() {
417	<	void realRun() {
418	<	getRunnable(LONG_DELAY_MS).run();
416	>	Thread t2 = newStartedThread(new CheckedRunnable() {
417	>	public void realRun() {
418	>	sleepTillInterrupted(MEDIUM_DELAY_MS);
419		int p1 = phaser.arrive();
420		int phase = phaser.awaitAdvance(p1);
421	<	threadAssertTrue(phase < 0);
422	<	threadAssertTrue(phaser.isTerminated());
423	<	}}).start();
421	>	assertTrue(phase < 0);
422	>	assertTrue(phaser.isTerminated());
423	>	}});
424
425		phaser.arrive();
426		phaser.forceTermination();
427	+	t1.join();
428	+	t2.join();
429		}
430
431		/**
#	Line 440 | Line 437 | public class PhaserTest extends JSR166Te
437		Phaser phaser = new Phaser();
438		phaser.arriveAndAwaitAdvance();
439		shouldThrow();
440	<	} catch (IllegalStateException success) {
444	<	}
440	>	} catch (IllegalStateException success) {}
441		}
442
443		/**
#	Line 449 | Line 445 | public class PhaserTest extends JSR166Te
445		*/
446		public void testArriveAndAwaitAdvance2() throws InterruptedException {
447		final Phaser phaser = new Phaser(2);
448	<	Thread th = new Thread(new CheckedRunnable() {
449	<	void realRun() {
448	>	Thread th = newStartedThread(new CheckedRunnable() {
449	>	public void realRun() {
450		phaser.arriveAndAwaitAdvance();
451		}});
452
453	<	th.start();
458	<	Thread.sleep(LONG_DELAY_MS);
453	>	Thread.sleep(SMALL_DELAY_MS);
454		th.interrupt();
455	<	Thread.sleep(LONG_DELAY_MS);
455	>	Thread.sleep(SMALL_DELAY_MS);
456		phaser.arrive();
457		assertFalse(th.isInterrupted());
458	+	th.join();
459		}
460
461		/**
#	Line 467 | Line 463 | public class PhaserTest extends JSR166Te
463		* number of arrived parties is the same number that is accounted
464		* for when the main thread awaitsAdvance
465		*/
466	<	public void testArriveAndAwaitAdvance3() {
466	>	public void testArriveAndAwaitAdvance3() throws InterruptedException {
467		final Phaser phaser = new Phaser(1);
468	<	final AtomicInteger arrivingCount = new AtomicInteger(0);
469	<	for (final Runnable run : getRunnables(six, SHORT_DELAY_MS)) {
470	<	new Thread(new CheckedRunnable() {
471	<	void realRun() {
472	<	phaser.register();
473	<	run.run();
474	<	arrivingCount.getAndIncrement();
479	<	phaser.arrive();
480	<	}}).start();
468	>	final List<Thread> threads = new ArrayList<Thread>();
469	>	for (int i = 0; i < 3; i++) {
470	>	threads.add(newStartedThread(new CheckedRunnable() {
471	>	public void realRun() throws InterruptedException {
472	>	phaser.register();
473	>	phaser.arriveAndAwaitAdvance();
474	>	}}));
475		}
476	<	int phaseNumber = phaser.arriveAndAwaitAdvance();
477	<	arrivingCount.incrementAndGet();
478	<	//the + 1 adds to expectedArrive to account for the main threads arrival
479	<	int expectedArrived = phaseNumber > 0 ? phaseNumber * six + 1 : phaser.getArrivedParties() + 1;
480	<	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	<	};
476	>	Thread.sleep(MEDIUM_DELAY_MS);
477	>	assertEquals(phaser.getArrivedParties(), 3);
478	>	phaser.arriveAndAwaitAdvance();
479	>	for (Thread thread : threads)
480	>	thread.join();
481		}
482
483		}

Diff Legend

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