ViewVC Help

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

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

Comparing jsr166/src/test/tck/ScheduledExecutorTest.java (file contents):
Revision 1.65 by jsr166, Mon Oct 5 21:42:48 2015 UTC vs.
Revision 1.69 by jsr166, Tue Oct 6 00:41:47 2015 UTC

#	Line 48 | Line 48 | public class ScheduledExecutorTest exten
48		final Runnable task = new CheckedRunnable() {
49		public void realRun() { done.countDown(); }};
50		p.execute(task);
51	<	assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
51	>	assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
52		}
53		}
54
#	Line 317 | Line 317 | public class ScheduledExecutorTest exten
317		assertEquals(1, p.getActiveCount());
318		done.await();
319		}});
320	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
320	>	assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
321		assertEquals(1, p.getActiveCount());
322		done.countDown();
323		}
#	Line 382 | Line 382 | public class ScheduledExecutorTest exten
382		done.await();
383		assertEquals(THREADS, p.getLargestPoolSize());
384		}});
385	<	assertTrue(threadsStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
385	>	assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
386		assertEquals(THREADS, p.getLargestPoolSize());
387		done.countDown();
388		}
#	Line 405 | Line 405 | public class ScheduledExecutorTest exten
405		assertEquals(1, p.getPoolSize());
406		done.await();
407		}});
408	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
408	>	assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
409		assertEquals(1, p.getPoolSize());
410		done.countDown();
411		}
#	Line 514 | Line 514 | public class ScheduledExecutorTest exten
514		threadStarted.countDown();
515		done.await();
516		}});
517	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
517	>	assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
518		assertFalse(p.isTerminating());
519		done.countDown();
520		try { p.shutdown(); } catch (SecurityException ok) { return; }
#	Line 538 | Line 538 | public class ScheduledExecutorTest exten
538		threadStarted.countDown();
539		done.await();
540		}});
541	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
541	>	assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
542		assertFalse(p.isTerminating());
543		done.countDown();
544		try { p.shutdown(); } catch (SecurityException ok) { return; }
#	Line 565 | Line 565 | public class ScheduledExecutorTest exten
565		}};
566		tasks[i] = p.schedule(r, 1, MILLISECONDS);
567		}
568	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
568	>	assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
569		BlockingQueue<Runnable> q = p.getQueue();
570		assertTrue(q.contains(tasks[tasks.length - 1]));
571		assertFalse(q.contains(tasks[0]));
#	Line 590 | Line 590 | public class ScheduledExecutorTest exten
590		}};
591		tasks[i] = p.schedule(r, 1, MILLISECONDS);
592		}
593	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
593	>	assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
594		BlockingQueue<Runnable> q = p.getQueue();
595		assertFalse(p.remove((Runnable)tasks[0]));
596		assertTrue(q.contains((Runnable)tasks[4]));
#	Line 609 | Line 609 | public class ScheduledExecutorTest exten
609		* purge eventually removes cancelled tasks from the queue
610		*/
611		public void testPurge() throws InterruptedException {
612	<	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
613	<	ScheduledFuture[] tasks = new ScheduledFuture[5];
614	<	for (int i = 0; i < tasks.length; i++)
615	<	tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(),
616	<	LONG_DELAY_MS, MILLISECONDS);
617	<	try {
612	>	final ScheduledFuture[] tasks = new ScheduledFuture[5];
613	>	final Runnable releaser = new Runnable() { public void run() {
614	>	for (ScheduledFuture task : tasks)
615	>	if (task != null) task.cancel(true); }};
616	>	final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
617	>	try (PoolCleaner cleaner = cleaner(p, releaser)) {
618	>	for (int i = 0; i < tasks.length; i++)
619	>	tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(),
620	>	LONG_DELAY_MS, MILLISECONDS);
621		int max = tasks.length;
622		if (tasks[4].cancel(true)) --max;
623		if (tasks[3].cancel(true)) --max;
#	Line 626 | Line 629 | public class ScheduledExecutorTest exten
629		long count = p.getTaskCount();
630		if (count == max)
631		return;
632	<	} while (millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
632	>	} while (millisElapsedSince(startTime) < LONG_DELAY_MS);
633		fail("Purge failed to remove cancelled tasks");
631	–	} finally {
632	–	for (ScheduledFuture task : tasks)
633	–	task.cancel(true);
634	–	joinPool(p);
634		}
635		}
636
#	Line 1142 | Line 1141 | public class ScheduledExecutorTest exten
1141		List<Callable<String>> l = new ArrayList<Callable<String>>();
1142		l.add(new NPETask());
1143		List<Future<String>> futures =
1144	<	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1144	>	e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1145		assertEquals(1, futures.size());
1146		try {
1147		futures.get(0).get();

Diff Legend

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