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.5 by dl, Sat Sep 20 18:20:08 2003 UTC vs.
Revision 1.7 by dl, Fri Sep 26 15:33:13 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	<	*
22	>	* execute successfully executes a runnable
23		*/
24		public void testExecute() {
25		try {
26	<	MyRunnable runnable =new MyRunnable();
26	>	TrackedRunnable runnable =new TrackedRunnable();
27		ScheduledExecutor p1 = new ScheduledExecutor(1);
28		p1.execute(runnable);
29		assertFalse(runnable.done);
#	Line 66 | Line 44 | public class ScheduledExecutorTest exten
44
45		}
46
47	+
48		/**
49	<	*
49	>	* delayed schedule of callable successfully executes after delay
50		*/
51		public void testSchedule1() {
52		try {
53	<	MyCallable callable = new MyCallable();
53	>	TrackedCallable callable = new TrackedCallable();
54		ScheduledExecutor p1 = new ScheduledExecutor(1);
55		Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
56		assertFalse(callable.done);
#	Line 87 | Line 66 | public class ScheduledExecutorTest exten
66		}
67
68		/**
69	<	*
69	>	*  delayed schedule of runnable successfully executes after delay
70		*/
71		public void testSchedule3() {
72		try {
73	<	MyRunnable runnable = new MyRunnable();
73	>	TrackedRunnable runnable = new TrackedRunnable();
74		ScheduledExecutor p1 = new ScheduledExecutor(1);
75		p1.schedule(runnable, SMALL_DELAY_MS, TimeUnit.MILLISECONDS);
76		Thread.sleep(SHORT_DELAY_MS);
#	Line 106 | Line 85 | public class ScheduledExecutorTest exten
85		}
86
87		/**
88	<	*
88	>	* scheduleAtFixedRate executes runnable after given initial delay
89		*/
90		public void testSchedule4() {
91		try {
92	<	MyRunnable runnable = new MyRunnable();
92	>	TrackedRunnable runnable = new TrackedRunnable();
93	>	ScheduledExecutor p1 = new ScheduledExecutor(1);
94	>	ScheduledCancellable h = p1.scheduleAtFixedRate(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
95	>	assertFalse(runnable.done);
96	>	Thread.sleep(MEDIUM_DELAY_MS);
97	>	assertTrue(runnable.done);
98	>	h.cancel(true);
99	>	p1.shutdown();
100	>	joinPool(p1);
101	>	} catch(Exception e){
102	>	unexpectedException();
103	>	}
104	>	}
105	>
106	>	/**
107	>	* scheduleWithFixedDelay executes runnable after given initial delay
108	>	*/
109	>	public void testSchedule5() {
110	>	try {
111	>	TrackedRunnable runnable = new TrackedRunnable();
112		ScheduledExecutor p1 = new ScheduledExecutor(1);
113	<	p1.schedule(runnable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
113	>	ScheduledCancellable h = p1.scheduleWithFixedDelay(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
114		assertFalse(runnable.done);
115		Thread.sleep(MEDIUM_DELAY_MS);
116		assertTrue(runnable.done);
117	+	h.cancel(true);
118		p1.shutdown();
119		joinPool(p1);
120		} catch(Exception e){
#	Line 123 | Line 122 | public class ScheduledExecutorTest exten
122		}
123		}
124
125	<
126	<	// exception tests
125	>	/**
126	>	*  execute (null) throws NPE
127	>	*/
128	>	public void testExecuteNull() {
129	>	ScheduledExecutor se = null;
130	>	try {
131	>	se = new ScheduledExecutor(1);
132	>	se.execute(null);
133	>	shouldThrow();
134	>	} catch(NullPointerException success){}
135	>	catch(Exception e){
136	>	unexpectedException();
137	>	}
138	>
139	>	joinPool(se);
140	>	}
141
142		/**
143	<	*   schedule(Runnable, long) throws RejectedExecutionException
144	<	*  This occurs on an attempt to schedule a task on a shutdown executor
143	>	* schedule (null) throws NPE
144	>	*/
145	>	public void testScheduleNull() {
146	>	ScheduledExecutor se = new ScheduledExecutor(1);
147	>	try {
148	>	TrackedCallable callable = null;
149	>	Future f = se.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
150	>	shouldThrow();
151	>	} catch(NullPointerException success){}
152	>	catch(Exception e){
153	>	unexpectedException();
154	>	}
155	>	joinPool(se);
156	>	}
157	>
158	>	/**
159	>	* execute throws RejectedExecutionException if shutdown
160		*/
161		public void testSchedule1_RejectedExecutionException() {
162		ScheduledExecutor se = new ScheduledExecutor(1);
#	Line 144 | Line 172 | public class ScheduledExecutorTest exten
172		}
173
174		/**
175	<	*   schedule(Callable, long, TimeUnit) throws RejectedExecutionException
148	<	*  This occurs on an attempt to schedule a task on a shutdown executor
175	>	* schedule throws RejectedExecutionException if shutdown
176		*/
177		public void testSchedule2_RejectedExecutionException() {
178		ScheduledExecutor se = new ScheduledExecutor(1);
#	Line 160 | Line 187 | public class ScheduledExecutorTest exten
187		}
188
189		/**
190	<	*   schedule(Callable, long) throws RejectedExecutionException
164	<	*  This occurs on an attempt to schedule a task on a shutdown executor
190	>	* schedule callable throws RejectedExecutionException if shutdown
191		*/
192		public void testSchedule3_RejectedExecutionException() {
193		ScheduledExecutor se = new ScheduledExecutor(1);
#	Line 176 | Line 202 | public class ScheduledExecutorTest exten
202		}
203
204		/**
205	<	*   scheduleAtFixedRate(Runnable, long, long, TimeUnit) throws
180	<	*  RejectedExecutionException.
181	<	*  This occurs on an attempt to schedule a task on a shutdown executor
205	>	*  scheduleAtFixedRate throws RejectedExecutionException if shutdown
206		*/
207		public void testScheduleAtFixedRate1_RejectedExecutionException() {
208		ScheduledExecutor se = new ScheduledExecutor(1);
#	Line 193 | Line 217 | public class ScheduledExecutorTest exten
217		}
218
219		/**
220	<	*   scheduleAtFixedRate(Runnable, long, long, TimeUnit) throws
197	<	*  RejectedExecutionException.
198	<	*  This occurs on an attempt to schedule a task on a shutdown executor
199	<	*/
200	<	public void testScheduleAtFixedRate2_RejectedExecutionException() {
201	<	ScheduledExecutor se = new ScheduledExecutor(1);
202	<	try {
203	<	se.shutdown();
204	<	se.scheduleAtFixedRate(new NoOpRunnable(),
205	<	1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
206	<	shouldThrow();
207	<	} catch(RejectedExecutionException success){
208	<	}
209	<	joinPool(se);
210	<	}
211	<
212	<	/**
213	<	*   scheduleWithFixedDelay(Runnable, long, long, TimeUnit) throws
214	<	*  RejectedExecutionException.
215	<	*  This occurs on an attempt to schedule a task on a shutdown executor
220	>	* scheduleWithFixedDelay throws RejectedExecutionException if shutdown
221		*/
222		public void testScheduleWithFixedDelay1_RejectedExecutionException() {
223		ScheduledExecutor se = new ScheduledExecutor(1);
#	Line 227 | Line 232 | public class ScheduledExecutorTest exten
232		}
233
234		/**
235	<	*   scheduleWithFixedDelay(Runnable, long, long, TimeUnit) throws
236	<	*  RejectedExecutionException.
232	<	*  This occurs on an attempt to schedule a task on a shutdown executor
233	<	*/
234	<	public void testScheduleWithFixedDelay2_RejectedExecutionException() {
235	<	ScheduledExecutor se = new ScheduledExecutor(1);
236	<	try {
237	<	se.shutdown();
238	<	se.scheduleWithFixedDelay(new NoOpRunnable(),
239	<	1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
240	<	shouldThrow();
241	<	} catch(RejectedExecutionException success){
242	<	}
243	<	joinPool(se);
244	<	}
245	<
246	<	/**
247	<	*   execute throws RejectedExecutionException
248	<	*  This occurs on an attempt to schedule a task on a shutdown executor
249	<	*/
250	<	public void testExecute_RejectedExecutionException() {
251	<	ScheduledExecutor se = new ScheduledExecutor(1);
252	<	try {
253	<	se.shutdown();
254	<	se.execute(new NoOpRunnable());
255	<	shouldThrow();
256	<	} catch(RejectedExecutionException success){
257	<	}
258	<	joinPool(se);
259	<	}
260	<
261	<	/**
262	<	*   getActiveCount gives correct values
235	>	*  getActiveCount increases but doesn't overestimate, when a
236	>	*  thread becomes active
237		*/
238		public void testGetActiveCount() {
239		ScheduledExecutor p2 = new ScheduledExecutor(2);
#	Line 275 | Line 249 | public class ScheduledExecutorTest exten
249		}
250
251		/**
252	<	*   getCompleteTaskCount gives correct values
252	>	*    getCompletedTaskCount increases, but doesn't overestimate,
253	>	*   when tasks complete
254		*/
255		public void testGetCompletedTaskCount() {
256		ScheduledExecutor p2 = new ScheduledExecutor(2);
#	Line 291 | Line 266 | public class ScheduledExecutorTest exten
266		}
267
268		/**
269	<	*   getCorePoolSize gives correct values
269	>	*  getCorePoolSize returns size given in constructor if not otherwise set
270		*/
271		public void testGetCorePoolSize() {
272		ScheduledExecutor p1 = new ScheduledExecutor(1);
#	Line 300 | Line 275 | public class ScheduledExecutorTest exten
275		}
276
277		/**
278	<	*   getLargestPoolSize gives correct values
278	>	*    getLargestPoolSize increases, but doesn't overestimate, when
279	>	*   multiple threads active
280		*/
281		public void testGetLargestPoolSize() {
282		ScheduledExecutor p2 = new ScheduledExecutor(2);
#	Line 317 | Line 293 | public class ScheduledExecutorTest exten
293		}
294
295		/**
296	<	*   getPoolSize gives correct values
296	>	*   getPoolSize increases, but doesn't overestimate, when threads
297	>	*   become active
298		*/
299		public void testGetPoolSize() {
300		ScheduledExecutor p1 = new ScheduledExecutor(1);
#	Line 328 | Line 305 | public class ScheduledExecutorTest exten
305		}
306
307		/**
308	<	*   getTaskCount gives correct values
308	>	*    getTaskCount increases, but doesn't overestimate, when tasks
309	>	*    submitted
310		*/
311		public void testGetTaskCount() {
312		ScheduledExecutor p1 = new ScheduledExecutor(1);
#	Line 345 | Line 323 | public class ScheduledExecutorTest exten
323		}
324
325		/**
326	<	*   isShutDown gives correct values
326	>	*   is isShutDown is false before shutdown, true after
327		*/
328		public void testIsShutdown() {
329
#	Line 361 | Line 339 | public class ScheduledExecutorTest exten
339
340
341		/**
342	<	*  isTerminated gives correct values
342	>	*   isTerminated is false before termination, true after
343		*/
344		public void testIsTerminated() {
345		ScheduledExecutor p1 = new ScheduledExecutor(1);
#	Line 379 | Line 357 | public class ScheduledExecutorTest exten
357		}
358
359		/**
360	<	*  isTerminating gives correct values
360	>	*  isTerminating is not true when running or when terminated
361		*/
362		public void testIsTerminating() {
363		ScheduledExecutor p1 = new ScheduledExecutor(1);
#	Line 400 | Line 378 | public class ScheduledExecutorTest exten
378		}
379
380		/**
381	<	*   that purge correctly removes cancelled tasks
404	<	*  from the queue
381	>	*   purge removes cancelled tasks from the queue
382		*/
383		public void testPurge() {
384		ScheduledExecutor p1 = new ScheduledExecutor(1);
#	Line 419 | Line 396 | public class ScheduledExecutorTest exten
396		}
397
398		/**
399	<	*   shutDownNow returns a list
423	<	*  containing the correct number of elements
399	>	*  shutDownNow returns a list containing tasks that were not run
400		*/
401		public void testShutDownNow() {
402		ScheduledExecutor p1 = new ScheduledExecutor(1);
#	Line 433 | Line 409 | public class ScheduledExecutorTest exten
409		}
410
411		/**
412	<	*
412	>	* In default setting, shutdown cancels periodic but not delayed
413	>	* tasks at shutdown
414		*/
415		public void testShutDown1() {
416		try {
#	Line 465 | Line 442 | public class ScheduledExecutorTest exten
442
443
444		/**
445	<	*
445	>	* If setExecuteExistingDelayedTasksAfterShutdownPolicy is false,
446	>	* delayed tasks are cancelled at shutdown
447		*/
448		public void testShutDown2() {
449		try {
#	Line 488 | Line 466 | public class ScheduledExecutorTest exten
466
467
468		/**
469	<	*
469	>	* If setContinueExistingPeriodicTasksAfterShutdownPolicy is set false,
470	>	* periodic tasks are not cancelled at shutdown
471		*/
472		public void testShutDown3() {
473		try {
#	Line 509 | Line 488 | public class ScheduledExecutorTest exten
488		}
489
490		/**
491	<	*
491	>	* if setContinueExistingPeriodicTasksAfterShutdownPolicy is true,
492	>	* periodic tasks are cancelled at shutdown
493		*/
494		public void testShutDown4() {
495		ScheduledExecutor p1 = new ScheduledExecutor(1);

Diff Legend

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