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.6 by dl, Thu Sep 25 11:02:41 2003 UTC vs.
Revision 1.11 by dl, Tue Dec 23 19:40:24 2003 UTC

#	Line 17 | Line 17 | public class ScheduledExecutorTest exten
17		return new TestSuite(ScheduledExecutorTest.class);
18		}
19
20	–	static class MyRunnable implements Runnable {
21	–	volatile boolean done = false;
22	–	public void run() {
23	–	try {
24	–	Thread.sleep(SMALL_DELAY_MS);
25	–	done = true;
26	–	} catch(Exception e){
27	–	}
28	–	}
29	–	}
30	–
31	–	static class MyCallable implements Callable {
32	–	volatile boolean done = false;
33	–	public Object call() {
34	–	try {
35	–	Thread.sleep(SMALL_DELAY_MS);
36	–	done = true;
37	–	} catch(Exception e){
38	–	}
39	–	return Boolean.TRUE;
40	–	}
41	–	}
20
21		/**
22		* execute successfully executes a runnable
23		*/
24		public void testExecute() {
25		try {
26	<	MyRunnable runnable =new MyRunnable();
27	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
26	>	TrackedShortRunnable runnable =new TrackedShortRunnable();
27	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
28		p1.execute(runnable);
29		assertFalse(runnable.done);
30		Thread.sleep(SHORT_DELAY_MS);
#	Line 72 | Line 50 | public class ScheduledExecutorTest exten
50		*/
51		public void testSchedule1() {
52		try {
53	<	MyCallable callable = new MyCallable();
54	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
53	>	TrackedCallable callable = new TrackedCallable();
54	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
55		Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
56		assertFalse(callable.done);
57		Thread.sleep(MEDIUM_DELAY_MS);
#	Line 83 | Line 61 | public class ScheduledExecutorTest exten
61		joinPool(p1);
62		} catch(RejectedExecutionException e){}
63		catch(Exception e){
64	+	e.printStackTrace();
65		unexpectedException();
66		}
67		}
#	Line 92 | Line 71 | public class ScheduledExecutorTest exten
71		*/
72		public void testSchedule3() {
73		try {
74	<	MyRunnable runnable = new MyRunnable();
75	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
74	>	TrackedShortRunnable runnable = new TrackedShortRunnable();
75	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
76		p1.schedule(runnable, SMALL_DELAY_MS, TimeUnit.MILLISECONDS);
77		Thread.sleep(SHORT_DELAY_MS);
78		assertFalse(runnable.done);
#	Line 111 | Line 90 | public class ScheduledExecutorTest exten
90		*/
91		public void testSchedule4() {
92		try {
93	<	MyRunnable runnable = new MyRunnable();
94	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
95	<	ScheduledCancellable h = p1.scheduleAtFixedRate(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
93	>	TrackedShortRunnable runnable = new TrackedShortRunnable();
94	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
95	>	ScheduledFuture h = p1.scheduleAtFixedRate(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
96		assertFalse(runnable.done);
97		Thread.sleep(MEDIUM_DELAY_MS);
98		assertTrue(runnable.done);
#	Line 130 | Line 109 | public class ScheduledExecutorTest exten
109		*/
110		public void testSchedule5() {
111		try {
112	<	MyRunnable runnable = new MyRunnable();
113	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
114	<	ScheduledCancellable h = p1.scheduleWithFixedDelay(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
112	>	TrackedShortRunnable runnable = new TrackedShortRunnable();
113	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
114	>	ScheduledFuture h = p1.scheduleWithFixedDelay(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
115		assertFalse(runnable.done);
116		Thread.sleep(MEDIUM_DELAY_MS);
117		assertTrue(runnable.done);
#	Line 148 | Line 127 | public class ScheduledExecutorTest exten
127		*  execute (null) throws NPE
128		*/
129		public void testExecuteNull() {
130	<	ScheduledExecutor se = null;
130	>	ScheduledThreadPoolExecutor se = null;
131		try {
132	<	se = new ScheduledExecutor(1);
132	>	se = new ScheduledThreadPoolExecutor(1);
133		se.execute(null);
134		shouldThrow();
135		} catch(NullPointerException success){}
#	Line 165 | Line 144 | public class ScheduledExecutorTest exten
144		* schedule (null) throws NPE
145		*/
146		public void testScheduleNull() {
147	<	ScheduledExecutor se = new ScheduledExecutor(1);
147	>	ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
148		try {
149	<	MyCallable callable = null;
149	>	TrackedCallable callable = null;
150		Future f = se.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
151		shouldThrow();
152		} catch(NullPointerException success){}
#	Line 181 | Line 160 | public class ScheduledExecutorTest exten
160		* execute throws RejectedExecutionException if shutdown
161		*/
162		public void testSchedule1_RejectedExecutionException() {
163	<	ScheduledExecutor se = new ScheduledExecutor(1);
163	>	ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
164		try {
165		se.shutdown();
166		se.schedule(new NoOpRunnable(),
#	Line 197 | Line 176 | public class ScheduledExecutorTest exten
176		* schedule throws RejectedExecutionException if shutdown
177		*/
178		public void testSchedule2_RejectedExecutionException() {
179	<	ScheduledExecutor se = new ScheduledExecutor(1);
179	>	ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
180		try {
181		se.shutdown();
182		se.schedule(new NoOpCallable(),
#	Line 212 | Line 191 | public class ScheduledExecutorTest exten
191		* schedule callable throws RejectedExecutionException if shutdown
192		*/
193		public void testSchedule3_RejectedExecutionException() {
194	<	ScheduledExecutor se = new ScheduledExecutor(1);
194	>	ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
195		try {
196		se.shutdown();
197		se.schedule(new NoOpCallable(),
#	Line 227 | Line 206 | public class ScheduledExecutorTest exten
206		*  scheduleAtFixedRate throws RejectedExecutionException if shutdown
207		*/
208		public void testScheduleAtFixedRate1_RejectedExecutionException() {
209	<	ScheduledExecutor se = new ScheduledExecutor(1);
209	>	ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
210		try {
211		se.shutdown();
212		se.scheduleAtFixedRate(new NoOpRunnable(),
#	Line 242 | Line 221 | public class ScheduledExecutorTest exten
221		* scheduleWithFixedDelay throws RejectedExecutionException if shutdown
222		*/
223		public void testScheduleWithFixedDelay1_RejectedExecutionException() {
224	<	ScheduledExecutor se = new ScheduledExecutor(1);
224	>	ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
225		try {
226		se.shutdown();
227		se.scheduleWithFixedDelay(new NoOpRunnable(),
#	Line 258 | Line 237 | public class ScheduledExecutorTest exten
237		*  thread becomes active
238		*/
239		public void testGetActiveCount() {
240	<	ScheduledExecutor p2 = new ScheduledExecutor(2);
240	>	ScheduledThreadPoolExecutor p2 = new ScheduledThreadPoolExecutor(2);
241		assertEquals(0, p2.getActiveCount());
242		p2.execute(new SmallRunnable());
243		try {
#	Line 275 | Line 254 | public class ScheduledExecutorTest exten
254		*   when tasks complete
255		*/
256		public void testGetCompletedTaskCount() {
257	<	ScheduledExecutor p2 = new ScheduledExecutor(2);
257	>	ScheduledThreadPoolExecutor p2 = new ScheduledThreadPoolExecutor(2);
258		assertEquals(0, p2.getCompletedTaskCount());
259		p2.execute(new SmallRunnable());
260		try {
#	Line 291 | Line 270 | public class ScheduledExecutorTest exten
270		*  getCorePoolSize returns size given in constructor if not otherwise set
271		*/
272		public void testGetCorePoolSize() {
273	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
273	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
274		assertEquals(1, p1.getCorePoolSize());
275		joinPool(p1);
276		}
#	Line 301 | Line 280 | public class ScheduledExecutorTest exten
280		*   multiple threads active
281		*/
282		public void testGetLargestPoolSize() {
283	<	ScheduledExecutor p2 = new ScheduledExecutor(2);
283	>	ScheduledThreadPoolExecutor p2 = new ScheduledThreadPoolExecutor(2);
284		assertEquals(0, p2.getLargestPoolSize());
285		p2.execute(new SmallRunnable());
286		p2.execute(new SmallRunnable());
#	Line 319 | Line 298 | public class ScheduledExecutorTest exten
298		*   become active
299		*/
300		public void testGetPoolSize() {
301	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
301	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
302		assertEquals(0, p1.getPoolSize());
303		p1.execute(new SmallRunnable());
304		assertEquals(1, p1.getPoolSize());
#	Line 331 | Line 310 | public class ScheduledExecutorTest exten
310		*    submitted
311		*/
312		public void testGetTaskCount() {
313	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
313	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
314		assertEquals(0, p1.getTaskCount());
315		for(int i = 0; i < 5; i++)
316		p1.execute(new SmallRunnable());
#	Line 343 | Line 322 | public class ScheduledExecutorTest exten
322		assertEquals(5, p1.getTaskCount());
323		joinPool(p1);
324		}
325	+
326	+	/**
327	+	* getThreadFactory returns factory in constructor if not set
328	+	*/
329	+	public void testGetThreadFactory() {
330	+	ThreadFactory tf = new SimpleThreadFactory();
331	+	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1, tf);
332	+	assertSame(tf, p.getThreadFactory());
333	+	p.shutdown();
334	+	joinPool(p);
335	+	}
336	+
337	+	/**
338	+	* setThreadFactory sets the thread factory returned by getThreadFactory
339	+	*/
340	+	public void testSetThreadFactory() {
341	+	ThreadFactory tf = new SimpleThreadFactory();
342	+	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
343	+	p.setThreadFactory(tf);
344	+	assertSame(tf, p.getThreadFactory());
345	+	p.shutdown();
346	+	joinPool(p);
347	+	}
348	+
349	+	/**
350	+	* setThreadFactory(null) throws NPE
351	+	*/
352	+	public void testSetThreadFactoryNull() {
353	+	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
354	+	try {
355	+	p.setThreadFactory(null);
356	+	shouldThrow();
357	+	} catch (NullPointerException success) {
358	+	} finally {
359	+	joinPool(p);
360	+	}
361	+	}
362
363		/**
364		*   is isShutDown is false before shutdown, true after
365		*/
366		public void testIsShutdown() {
367
368	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
368	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
369		try {
370		assertFalse(p1.isShutdown());
371		}
#	Line 364 | Line 380 | public class ScheduledExecutorTest exten
380		*   isTerminated is false before termination, true after
381		*/
382		public void testIsTerminated() {
383	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
383	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
384		try {
385		p1.execute(new SmallRunnable());
386		} finally {
#	Line 382 | Line 398 | public class ScheduledExecutorTest exten
398		*  isTerminating is not true when running or when terminated
399		*/
400		public void testIsTerminating() {
401	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
401	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
402		assertFalse(p1.isTerminating());
403		try {
404		p1.execute(new SmallRunnable());
#	Line 400 | Line 416 | public class ScheduledExecutorTest exten
416		}
417
418		/**
419	<	*   purge removes cancelled tasks from the queue
419	>	* getQueue returns the work queue, which contains queued tasks
420	>	*/
421	>	public void testGetQueue() {
422	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
423	>	ScheduledFuture[] tasks = new ScheduledFuture[5];
424	>	for(int i = 0; i < 5; i++){
425	>	tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), 1, TimeUnit.MILLISECONDS);
426	>	}
427	>	try {
428	>	Thread.sleep(SHORT_DELAY_MS);
429	>	BlockingQueue<Runnable> q = p1.getQueue();
430	>	assertTrue(q.contains(tasks[4]));
431	>	assertFalse(q.contains(tasks[0]));
432	>	p1.shutdownNow();
433	>	} catch(Exception e) {
434	>	unexpectedException();
435	>	} finally {
436	>	joinPool(p1);
437	>	}
438	>	}
439	>
440	>	/**
441	>	* remove(task) removes queued task, and fails to remove active task
442	>	*/
443	>	public void testRemove() {
444	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
445	>	ScheduledFuture[] tasks = new ScheduledFuture[5];
446	>	for(int i = 0; i < 5; i++){
447	>	tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), 1, TimeUnit.MILLISECONDS);
448	>	}
449	>	try {
450	>	Thread.sleep(SHORT_DELAY_MS);
451	>	BlockingQueue<Runnable> q = p1.getQueue();
452	>	assertFalse(p1.remove((Runnable)tasks[0]));
453	>	assertTrue(q.contains((Runnable)tasks[4]));
454	>	assertTrue(q.contains((Runnable)tasks[3]));
455	>	assertTrue(p1.remove((Runnable)tasks[4]));
456	>	assertFalse(p1.remove((Runnable)tasks[4]));
457	>	assertFalse(q.contains((Runnable)tasks[4]));
458	>	assertTrue(q.contains((Runnable)tasks[3]));
459	>	assertTrue(p1.remove((Runnable)tasks[3]));
460	>	assertFalse(q.contains((Runnable)tasks[3]));
461	>	p1.shutdownNow();
462	>	} catch(Exception e) {
463	>	unexpectedException();
464	>	} finally {
465	>	joinPool(p1);
466	>	}
467	>	}
468	>
469	>	/**
470	>	*  purge removes cancelled tasks from the queue
471		*/
472		public void testPurge() {
473	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
474	<	ScheduledCancellable[] tasks = new ScheduledCancellable[5];
473	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
474	>	ScheduledFuture[] tasks = new ScheduledFuture[5];
475		for(int i = 0; i < 5; i++){
476	<	tasks[i] = p1.schedule(new SmallRunnable(), 1, TimeUnit.MILLISECONDS);
476	>	tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), 1, TimeUnit.MILLISECONDS);
477		}
478		int max = 5;
479		if (tasks[4].cancel(true)) --max;
#	Line 421 | Line 488 | public class ScheduledExecutorTest exten
488		*  shutDownNow returns a list containing tasks that were not run
489		*/
490		public void testShutDownNow() {
491	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
491	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
492		for(int i = 0; i < 5; i++)
493	<	p1.schedule(new SmallRunnable(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
493	>	p1.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
494		List l = p1.shutdownNow();
495		assertTrue(p1.isShutdown());
496		assertTrue(l.size() > 0 && l.size() <= 5);
#	Line 436 | Line 503 | public class ScheduledExecutorTest exten
503		*/
504		public void testShutDown1() {
505		try {
506	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
506	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
507		assertTrue(p1.getExecuteExistingDelayedTasksAfterShutdownPolicy());
508		assertFalse(p1.getContinueExistingPeriodicTasksAfterShutdownPolicy());
509
510	<	ScheduledCancellable[] tasks = new ScheduledCancellable[5];
510	>	ScheduledFuture[] tasks = new ScheduledFuture[5];
511		for(int i = 0; i < 5; i++)
512		tasks[i] = p1.schedule(new NoOpRunnable(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
513		p1.shutdown();
514		BlockingQueue q = p1.getQueue();
515		for (Iterator it = q.iterator(); it.hasNext();) {
516	<	ScheduledCancellable t = (ScheduledCancellable)it.next();
516	>	ScheduledFuture t = (ScheduledFuture)it.next();
517		assertFalse(t.isCancelled());
518		}
519		assertTrue(p1.isShutdown());
#	Line 469 | Line 536 | public class ScheduledExecutorTest exten
536		*/
537		public void testShutDown2() {
538		try {
539	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
539	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
540		p1.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
541	<	ScheduledCancellable[] tasks = new ScheduledCancellable[5];
541	>	ScheduledFuture[] tasks = new ScheduledFuture[5];
542		for(int i = 0; i < 5; i++)
543		tasks[i] = p1.schedule(new NoOpRunnable(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
544		p1.shutdown();
#	Line 493 | Line 560 | public class ScheduledExecutorTest exten
560		*/
561		public void testShutDown3() {
562		try {
563	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
563	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
564		p1.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
565	<	ScheduledCancellable task =
565	>	ScheduledFuture task =
566		p1.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, TimeUnit.MILLISECONDS);
567		p1.shutdown();
568		assertTrue(p1.isShutdown());
#	Line 514 | Line 581 | public class ScheduledExecutorTest exten
581		* periodic tasks are cancelled at shutdown
582		*/
583		public void testShutDown4() {
584	<	ScheduledExecutor p1 = new ScheduledExecutor(1);
584	>	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
585		try {
586		p1.setContinueExistingPeriodicTasksAfterShutdownPolicy(true);
587	<	ScheduledCancellable task =
587	>	ScheduledFuture task =
588		p1.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, TimeUnit.MILLISECONDS);
589		assertFalse(task.isCancelled());
590		p1.shutdown();
#	Line 539 | Line 606 | public class ScheduledExecutorTest exten
606		}
607		}
608
609	+	/**
610	+	* completed submit of callable returns result
611	+	*/
612	+	public void testSubmitCallable() {
613	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
614	+	try {
615	+	Future<String> future = e.submit(new StringTask());
616	+	String result = future.get();
617	+	assertSame(TEST_STRING, result);
618	+	}
619	+	catch (ExecutionException ex) {
620	+	unexpectedException();
621	+	}
622	+	catch (InterruptedException ex) {
623	+	unexpectedException();
624	+	} finally {
625	+	joinPool(e);
626	+	}
627	+	}
628	+
629	+	/**
630	+	* completed submit of runnable returns successfully
631	+	*/
632	+	public void testSubmitRunnable() {
633	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
634	+	try {
635	+	Future<?> future = e.submit(new NoOpRunnable());
636	+	future.get();
637	+	assertTrue(future.isDone());
638	+	}
639	+	catch (ExecutionException ex) {
640	+	unexpectedException();
641	+	}
642	+	catch (InterruptedException ex) {
643	+	unexpectedException();
644	+	} finally {
645	+	joinPool(e);
646	+	}
647	+	}
648	+
649	+	/**
650	+	* completed submit of (runnable, result) returns result
651	+	*/
652	+	public void testSubmitRunnable2() {
653	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
654	+	try {
655	+	Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
656	+	String result = future.get();
657	+	assertSame(TEST_STRING, result);
658	+	}
659	+	catch (ExecutionException ex) {
660	+	unexpectedException();
661	+	}
662	+	catch (InterruptedException ex) {
663	+	unexpectedException();
664	+	} finally {
665	+	joinPool(e);
666	+	}
667	+	}
668	+
669	+
670	+
671	+
672	+
673	+	/**
674	+	* invokeAny(null) throws NPE
675	+	*/
676	+	public void testInvokeAny1() {
677	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
678	+	try {
679	+	e.invokeAny(null);
680	+	} catch (NullPointerException success) {
681	+	} catch(Exception ex) {
682	+	unexpectedException();
683	+	} finally {
684	+	joinPool(e);
685	+	}
686	+	}
687	+
688	+	/**
689	+	* invokeAny(empty collection) throws IAE
690	+	*/
691	+	public void testInvokeAny2() {
692	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
693	+	try {
694	+	e.invokeAny(new ArrayList<Callable<String>>());
695	+	} catch (IllegalArgumentException success) {
696	+	} catch(Exception ex) {
697	+	unexpectedException();
698	+	} finally {
699	+	joinPool(e);
700	+	}
701	+	}
702	+
703	+	/**
704	+	* invokeAny(c) throws NPE if c has null elements
705	+	*/
706	+	public void testInvokeAny3() {
707	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
708	+	try {
709	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
710	+	l.add(new StringTask());
711	+	l.add(null);
712	+	e.invokeAny(l);
713	+	} catch (NullPointerException success) {
714	+	} catch(Exception ex) {
715	+	unexpectedException();
716	+	} finally {
717	+	joinPool(e);
718	+	}
719	+	}
720	+
721	+	/**
722	+	* invokeAny(c) throws ExecutionException if no task completes
723	+	*/
724	+	public void testInvokeAny4() {
725	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
726	+	try {
727	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
728	+	l.add(new NPETask());
729	+	e.invokeAny(l);
730	+	} catch (ExecutionException success) {
731	+	} catch(Exception ex) {
732	+	unexpectedException();
733	+	} finally {
734	+	joinPool(e);
735	+	}
736	+	}
737	+
738	+	/**
739	+	* invokeAny(c) returns result of some task
740	+	*/
741	+	public void testInvokeAny5() {
742	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
743	+	try {
744	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
745	+	l.add(new StringTask());
746	+	l.add(new StringTask());
747	+	String result = e.invokeAny(l);
748	+	assertSame(TEST_STRING, result);
749	+	} catch (ExecutionException success) {
750	+	} catch(Exception ex) {
751	+	unexpectedException();
752	+	} finally {
753	+	joinPool(e);
754	+	}
755	+	}
756	+
757	+	/**
758	+	* invokeAll(null) throws NPE
759	+	*/
760	+	public void testInvokeAll1() {
761	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
762	+	try {
763	+	e.invokeAll(null);
764	+	} catch (NullPointerException success) {
765	+	} catch(Exception ex) {
766	+	unexpectedException();
767	+	} finally {
768	+	joinPool(e);
769	+	}
770	+	}
771	+
772	+	/**
773	+	* invokeAll(empty collection) returns empty collection
774	+	*/
775	+	public void testInvokeAll2() {
776	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
777	+	try {
778	+	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
779	+	assertTrue(r.isEmpty());
780	+	} catch(Exception ex) {
781	+	unexpectedException();
782	+	} finally {
783	+	joinPool(e);
784	+	}
785	+	}
786	+
787	+	/**
788	+	* invokeAll(c) throws NPE if c has null elements
789	+	*/
790	+	public void testInvokeAll3() {
791	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
792	+	try {
793	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
794	+	l.add(new StringTask());
795	+	l.add(null);
796	+	e.invokeAll(l);
797	+	} catch (NullPointerException success) {
798	+	} catch(Exception ex) {
799	+	unexpectedException();
800	+	} finally {
801	+	joinPool(e);
802	+	}
803	+	}
804	+
805	+	/**
806	+	* get of invokeAll(c) throws exception on failed task
807	+	*/
808	+	public void testInvokeAll4() {
809	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
810	+	try {
811	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
812	+	l.add(new NPETask());
813	+	List<Future<String>> result = e.invokeAll(l);
814	+	assertEquals(1, result.size());
815	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
816	+	it.next().get();
817	+	} catch(ExecutionException success) {
818	+	} catch(Exception ex) {
819	+	unexpectedException();
820	+	} finally {
821	+	joinPool(e);
822	+	}
823	+	}
824	+
825	+	/**
826	+	* invokeAll(c) returns results of all completed tasks
827	+	*/
828	+	public void testInvokeAll5() {
829	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
830	+	try {
831	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
832	+	l.add(new StringTask());
833	+	l.add(new StringTask());
834	+	List<Future<String>> result = e.invokeAll(l);
835	+	assertEquals(2, result.size());
836	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
837	+	assertSame(TEST_STRING, it.next().get());
838	+	} catch (ExecutionException success) {
839	+	} catch(Exception ex) {
840	+	unexpectedException();
841	+	} finally {
842	+	joinPool(e);
843	+	}
844	+	}
845	+
846	+	/**
847	+	* timed invokeAny(null) throws NPE
848	+	*/
849	+	public void testTimedInvokeAny1() {
850	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
851	+	try {
852	+	e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
853	+	} catch (NullPointerException success) {
854	+	} catch(Exception ex) {
855	+	unexpectedException();
856	+	} finally {
857	+	joinPool(e);
858	+	}
859	+	}
860	+
861	+	/**
862	+	* timed invokeAny(,,null) throws NPE
863	+	*/
864	+	public void testTimedInvokeAnyNullTimeUnit() {
865	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
866	+	try {
867	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
868	+	l.add(new StringTask());
869	+	e.invokeAny(l, MEDIUM_DELAY_MS, null);
870	+	} catch (NullPointerException success) {
871	+	} catch(Exception ex) {
872	+	unexpectedException();
873	+	} finally {
874	+	joinPool(e);
875	+	}
876	+	}
877	+
878	+	/**
879	+	* timed invokeAny(empty collection) throws IAE
880	+	*/
881	+	public void testTimedInvokeAny2() {
882	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
883	+	try {
884	+	e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
885	+	} catch (IllegalArgumentException success) {
886	+	} catch(Exception ex) {
887	+	unexpectedException();
888	+	} finally {
889	+	joinPool(e);
890	+	}
891	+	}
892	+
893	+	/**
894	+	* timed invokeAny(c) throws NPE if c has null elements
895	+	*/
896	+	public void testTimedInvokeAny3() {
897	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
898	+	try {
899	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
900	+	l.add(new StringTask());
901	+	l.add(null);
902	+	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
903	+	} catch (NullPointerException success) {
904	+	} catch(Exception ex) {
905	+	ex.printStackTrace();
906	+	unexpectedException();
907	+	} finally {
908	+	joinPool(e);
909	+	}
910	+	}
911	+
912	+	/**
913	+	* timed invokeAny(c) throws ExecutionException if no task completes
914	+	*/
915	+	public void testTimedInvokeAny4() {
916	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
917	+	try {
918	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
919	+	l.add(new NPETask());
920	+	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
921	+	} catch(ExecutionException success) {
922	+	} catch(Exception ex) {
923	+	unexpectedException();
924	+	} finally {
925	+	joinPool(e);
926	+	}
927	+	}
928	+
929	+	/**
930	+	* timed invokeAny(c) returns result of some task
931	+	*/
932	+	public void testTimedInvokeAny5() {
933	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
934	+	try {
935	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
936	+	l.add(new StringTask());
937	+	l.add(new StringTask());
938	+	String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
939	+	assertSame(TEST_STRING, result);
940	+	} catch (ExecutionException success) {
941	+	} catch(Exception ex) {
942	+	unexpectedException();
943	+	} finally {
944	+	joinPool(e);
945	+	}
946	+	}
947	+
948	+	/**
949	+	* timed invokeAll(null) throws NPE
950	+	*/
951	+	public void testTimedInvokeAll1() {
952	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
953	+	try {
954	+	e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
955	+	} catch (NullPointerException success) {
956	+	} catch(Exception ex) {
957	+	unexpectedException();
958	+	} finally {
959	+	joinPool(e);
960	+	}
961	+	}
962	+
963	+	/**
964	+	* timed invokeAll(,,null) throws NPE
965	+	*/
966	+	public void testTimedInvokeAllNullTimeUnit() {
967	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
968	+	try {
969	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
970	+	l.add(new StringTask());
971	+	e.invokeAll(l, MEDIUM_DELAY_MS, null);
972	+	} catch (NullPointerException success) {
973	+	} catch(Exception ex) {
974	+	unexpectedException();
975	+	} finally {
976	+	joinPool(e);
977	+	}
978	+	}
979	+
980	+	/**
981	+	* timed invokeAll(empty collection) returns empty collection
982	+	*/
983	+	public void testTimedInvokeAll2() {
984	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
985	+	try {
986	+	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
987	+	assertTrue(r.isEmpty());
988	+	} catch(Exception ex) {
989	+	unexpectedException();
990	+	} finally {
991	+	joinPool(e);
992	+	}
993	+	}
994	+
995	+	/**
996	+	* timed invokeAll(c) throws NPE if c has null elements
997	+	*/
998	+	public void testTimedInvokeAll3() {
999	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
1000	+	try {
1001	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1002	+	l.add(new StringTask());
1003	+	l.add(null);
1004	+	e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1005	+	} catch (NullPointerException success) {
1006	+	} catch(Exception ex) {
1007	+	unexpectedException();
1008	+	} finally {
1009	+	joinPool(e);
1010	+	}
1011	+	}
1012	+
1013	+	/**
1014	+	* get of element of invokeAll(c) throws exception on failed task
1015	+	*/
1016	+	public void testTimedInvokeAll4() {
1017	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
1018	+	try {
1019	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1020	+	l.add(new NPETask());
1021	+	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1022	+	assertEquals(1, result.size());
1023	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1024	+	it.next().get();
1025	+	} catch(ExecutionException success) {
1026	+	} catch(Exception ex) {
1027	+	unexpectedException();
1028	+	} finally {
1029	+	joinPool(e);
1030	+	}
1031	+	}
1032	+
1033	+	/**
1034	+	* timed invokeAll(c) returns results of all completed tasks
1035	+	*/
1036	+	public void testTimedInvokeAll5() {
1037	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
1038	+	try {
1039	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1040	+	l.add(new StringTask());
1041	+	l.add(new StringTask());
1042	+	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1043	+	assertEquals(2, result.size());
1044	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1045	+	assertSame(TEST_STRING, it.next().get());
1046	+	} catch (ExecutionException success) {
1047	+	} catch(Exception ex) {
1048	+	unexpectedException();
1049	+	} finally {
1050	+	joinPool(e);
1051	+	}
1052	+	}
1053	+
1054	+	/**
1055	+	* timed invokeAll(c) cancels tasks not completed by timeout
1056	+	*/
1057	+	public void testTimedInvokeAll6() {
1058	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
1059	+	try {
1060	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1061	+	l.add(new StringTask());
1062	+	l.add(Executors.callable(new MediumInterruptedRunnable(), TEST_STRING));
1063	+	List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
1064	+	assertEquals(2, result.size());
1065	+	Iterator<Future<String>> it = result.iterator();
1066	+	Future<String> f1 = it.next();
1067	+	Future<String> f2 = it.next();
1068	+	assertTrue(f1.isDone());
1069	+	assertFalse(f1.isCancelled());
1070	+	assertTrue(f2.isDone());
1071	+	assertTrue(f2.isCancelled());
1072	+	} catch(Exception ex) {
1073	+	unexpectedException();
1074	+	} finally {
1075	+	joinPool(e);
1076	+	}
1077	+	}
1078	+
1079	+
1080		}

Diff Legend

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