ViewVC Help

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

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

Comparing jsr166/src/test/tck/ThreadPoolExecutorTest.java (file contents):
Revision 1.3 by dl, Sun Sep 14 20:42:41 2003 UTC vs.
Revision 1.6 by dl, Thu Sep 25 11:02:41 2003 UTC

#	Line 36 | Line 36 | public class ThreadPoolExecutorTest exte
36		/**
37		*   execute successfully executes a runnable
38		*/
39	<	public void testExecute(){
40	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
39	>	public void testExecute() {
40	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
41		try {
42	<	one.execute(new Runnable(){
43	<	public void run(){
44	<	try{
42	>	p1.execute(new Runnable() {
43	>	public void run() {
44	>	try {
45		Thread.sleep(SHORT_DELAY_MS);
46		} catch(InterruptedException e){
47	<	fail("unexpected exception");
47	>	threadUnexpectedException();
48		}
49		}
50		});
51		Thread.sleep(SMALL_DELAY_MS);
52		} catch(InterruptedException e){
53	<	fail("unexpected exception");
53	>	unexpectedException();
54		}
55	<	joinPool(one);
55	>	joinPool(p1);
56		}
57
58		/**
59	<	*   getActiveCount gives correct values
59	>	*  getActiveCount increases but doesn't overestimate, when a
60	>	*  thread becomes active
61		*/
62	<	public void testGetActiveCount(){
63	<	ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
64	<	assertEquals(0, two.getActiveCount());
65	<	two.execute(new MediumRunnable());
66	<	try{
62	>	public void testGetActiveCount() {
63	>	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
64	>	assertEquals(0, p2.getActiveCount());
65	>	p2.execute(new MediumRunnable());
66	>	try {
67		Thread.sleep(SHORT_DELAY_MS);
68		} catch(Exception e){
69	<	fail("unexpected exception");
69	>	unexpectedException();
70		}
71	<	assertEquals(1, two.getActiveCount());
72	<	joinPool(two);
71	>	assertEquals(1, p2.getActiveCount());
72	>	joinPool(p2);
73		}
74
75		/**
76	<	*   getCompleteTaskCount gives correct values
76	>	*   getCompletedTaskCount increases, but doesn't overestimate,
77	>	*   when tasks complete
78		*/
79	<	public void testGetCompletedTaskCount(){
80	<	ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
81	<	assertEquals(0, two.getCompletedTaskCount());
82	<	two.execute(new ShortRunnable());
83	<	try{
79	>	public void testGetCompletedTaskCount() {
80	>	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
81	>	assertEquals(0, p2.getCompletedTaskCount());
82	>	p2.execute(new ShortRunnable());
83	>	try {
84		Thread.sleep(MEDIUM_DELAY_MS);
85		} catch(Exception e){
86	<	fail("unexpected exception");
86	>	unexpectedException();
87		}
88	<	assertEquals(1, two.getCompletedTaskCount());
89	<	two.shutdown();
90	<	joinPool(two);
88	>	assertEquals(1, p2.getCompletedTaskCount());
89	>	p2.shutdown();
90	>	joinPool(p2);
91		}
92
93		/**
94	<	*   getCorePoolSize gives correct values
94	>	*   getCorePoolSize returns size given in constructor if not otherwise set
95		*/
96	<	public void testGetCorePoolSize(){
97	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
98	<	assertEquals(1, one.getCorePoolSize());
99	<	joinPool(one);
96	>	public void testGetCorePoolSize() {
97	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
98	>	assertEquals(1, p1.getCorePoolSize());
99	>	joinPool(p1);
100		}
101
102		/**
103	<	*   getKeepAliveTime gives correct values
103	>	*   getKeepAliveTime returns value given in constructor if not otherwise set
104		*/
105	<	public void testGetKeepAliveTime(){
106	<	ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
107	<	assertEquals(1, two.getKeepAliveTime(TimeUnit.SECONDS));
108	<	joinPool(two);
105	>	public void testGetKeepAliveTime() {
106	>	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
107	>	assertEquals(1, p2.getKeepAliveTime(TimeUnit.SECONDS));
108	>	joinPool(p2);
109		}
110
111		/**
112	<	*   getLargestPoolSize gives correct values
112	>	*   getLargestPoolSize increases, but doesn't overestimate, when
113	>	*   multiple threads active
114		*/
115	<	public void testGetLargestPoolSize(){
116	<	ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
115	>	public void testGetLargestPoolSize() {
116	>	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
117		try {
118	<	assertEquals(0, two.getLargestPoolSize());
119	<	two.execute(new MediumRunnable());
120	<	two.execute(new MediumRunnable());
118	>	assertEquals(0, p2.getLargestPoolSize());
119	>	p2.execute(new MediumRunnable());
120	>	p2.execute(new MediumRunnable());
121		Thread.sleep(SHORT_DELAY_MS);
122	<	assertEquals(2, two.getLargestPoolSize());
122	>	assertEquals(2, p2.getLargestPoolSize());
123		} catch(Exception e){
124	<	fail("unexpected exception");
124	>	unexpectedException();
125		}
126	<	joinPool(two);
126	>	joinPool(p2);
127		}
128
129		/**
130	<	*   getMaximumPoolSize gives correct values
130	>	*   getMaximumPoolSize returns value given in constructor if not
131	>	*   otherwise set
132		*/
133	<	public void testGetMaximumPoolSize(){
134	<	ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
135	<	assertEquals(2, two.getMaximumPoolSize());
136	<	joinPool(two);
133	>	public void testGetMaximumPoolSize() {
134	>	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
135	>	assertEquals(2, p2.getMaximumPoolSize());
136	>	joinPool(p2);
137		}
138
139		/**
140	<	*   getPoolSize gives correct values
140	>	*   getPoolSize increases, but doesn't overestimate, when threads
141	>	*   become active
142		*/
143	<	public void testGetPoolSize(){
144	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
145	<	assertEquals(0, one.getPoolSize());
146	<	one.execute(new MediumRunnable());
147	<	assertEquals(1, one.getPoolSize());
148	<	joinPool(one);
143	>	public void testGetPoolSize() {
144	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
145	>	assertEquals(0, p1.getPoolSize());
146	>	p1.execute(new MediumRunnable());
147	>	assertEquals(1, p1.getPoolSize());
148	>	joinPool(p1);
149		}
150
151		/**
152	<	*   getTaskCount gives correct values
152	>	*   getTaskCount increases, but doesn't overestimate, when tasks submitted
153		*/
154	<	public void testGetTaskCount(){
155	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
154	>	public void testGetTaskCount() {
155	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
156		try {
157	<	assertEquals(0, one.getTaskCount());
158	<	for(int i = 0; i < 5; i++)
154	<	one.execute(new MediumRunnable());
157	>	assertEquals(0, p1.getTaskCount());
158	>	p1.execute(new MediumRunnable());
159		Thread.sleep(SHORT_DELAY_MS);
160	<	assertEquals(5, one.getTaskCount());
160	>	assertEquals(1, p1.getTaskCount());
161		} catch(Exception e){
162	<	fail("unexpected exception");
162	>	unexpectedException();
163		}
164	<	joinPool(one);
164	>	joinPool(p1);
165		}
166
167		/**
168	<	*   isShutDown gives correct values
168	>	*   isShutDown is false before shutdown, true after
169		*/
170	<	public void testIsShutdown(){
170	>	public void testIsShutdown() {
171
172	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
173	<	assertFalse(one.isShutdown());
174	<	one.shutdown();
175	<	assertTrue(one.isShutdown());
176	<	joinPool(one);
172	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
173	>	assertFalse(p1.isShutdown());
174	>	p1.shutdown();
175	>	assertTrue(p1.isShutdown());
176	>	joinPool(p1);
177		}
178
179
180		/**
181	<	*   isTerminated gives correct values
178	<	*  Makes sure termination does not take an innapropriate
179	<	*  amount of time
181	>	*  isTerminated is false before termination, true after
182		*/
183	<	public void testIsTerminated(){
184	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
183	>	public void testIsTerminated() {
184	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
185	>	assertFalse(p1.isTerminated());
186		try {
187	<	one.execute(new MediumRunnable());
187	>	p1.execute(new MediumRunnable());
188		} finally {
189	<	one.shutdown();
189	>	p1.shutdown();
190		}
191		try {
192	<	assertTrue(one.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
193	<	assertTrue(one.isTerminated());
192	>	assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
193	>	assertTrue(p1.isTerminated());
194	>	} catch(Exception e){
195	>	unexpectedException();
196	>	}
197	>	}
198	>
199	>	/**
200	>	*  isTerminating is not true when running or when terminated
201	>	*/
202	>	public void testIsTerminating() {
203	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
204	>	assertFalse(p1.isTerminating());
205	>	try {
206	>	p1.execute(new SmallRunnable());
207	>	assertFalse(p1.isTerminating());
208	>	} finally {
209	>	p1.shutdown();
210	>	}
211	>	try {
212	>	assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
213	>	assertTrue(p1.isTerminated());
214	>	assertFalse(p1.isTerminating());
215		} catch(Exception e){
216	<	fail("unexpected exception");
216	>	unexpectedException();
217		}
218		}
219
220		/**
221	<	*   purge correctly removes cancelled tasks
198	<	*  from the queue
221	>	*   purge removes cancelled tasks from the queue
222		*/
223	<	public void testPurge(){
224	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
223	>	public void testPurge() {
224	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
225		CancellableTask[] tasks = new CancellableTask[5];
226		for(int i = 0; i < 5; i++){
227		tasks[i] = new CancellableTask(new MediumPossiblyInterruptedRunnable());
228	<	one.execute(tasks[i]);
228	>	p1.execute(tasks[i]);
229		}
230		tasks[4].cancel(true);
231		tasks[3].cancel(true);
232	<	one.purge();
233	<	long count = one.getTaskCount();
232	>	p1.purge();
233	>	long count = p1.getTaskCount();
234		assertTrue(count >= 2 && count < 5);
235	<	joinPool(one);
235	>	joinPool(p1);
236		}
237
238		/**
239	<	*   shutDownNow returns a list
217	<	*  containing the correct number of elements
239	>	*  shutDownNow returns a list containing tasks that were not run
240		*/
241	<	public void testShutDownNow(){
242	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
241	>	public void testShutDownNow() {
242	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
243		List l;
244		try {
245		for(int i = 0; i < 5; i++)
246	<	one.execute(new MediumPossiblyInterruptedRunnable());
246	>	p1.execute(new MediumPossiblyInterruptedRunnable());
247		}
248		finally {
249	<	l = one.shutdownNow();
249	>	l = p1.shutdownNow();
250		}
251	<	assertTrue(one.isShutdown());
251	>	assertTrue(p1.isShutdown());
252		assertTrue(l.size() <= 4);
253		}
254
255		// Exception Tests
256
257
258	<	/** Throws if corePoolSize argument is less than zero */
258	>	/**
259	>	* Constructor throws if corePoolSize argument is less than zero
260	>	*/
261		public void testConstructor1() {
262	<	try{
262	>	try {
263		new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
264	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
264	>	shouldThrow();
265		}
266		catch (IllegalArgumentException success){}
267		}
268
269	<	/** Throws if maximumPoolSize is less than zero */
269	>	/**
270	>	* Constructor throws if maximumPoolSize is less than zero
271	>	*/
272		public void testConstructor2() {
273	<	try{
273	>	try {
274		new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
275	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
275	>	shouldThrow();
276		}
277		catch (IllegalArgumentException success){}
278		}
279
280	<	/** Throws if maximumPoolSize is equal to zero */
280	>	/**
281	>	* Constructor throws if maximumPoolSize is equal to zero
282	>	*/
283		public void testConstructor3() {
284	<	try{
284	>	try {
285		new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
286	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
286	>	shouldThrow();
287		}
288		catch (IllegalArgumentException success){}
289		}
290
291	<	/** Throws if keepAliveTime is less than zero */
291	>	/**
292	>	* Constructor throws if keepAliveTime is less than zero
293	>	*/
294		public void testConstructor4() {
295	<	try{
295	>	try {
296		new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
297	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
297	>	shouldThrow();
298		}
299		catch (IllegalArgumentException success){}
300		}
301
302	<	/** Throws if corePoolSize is greater than the maximumPoolSize */
302	>	/**
303	>	* Constructor throws if corePoolSize is greater than the maximumPoolSize
304	>	*/
305		public void testConstructor5() {
306	<	try{
306	>	try {
307		new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
308	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
308	>	shouldThrow();
309		}
310		catch (IllegalArgumentException success){}
311		}
312
313	<	/** Throws if workQueue is set to null */
313	>	/**
314	>	* Constructor throws if workQueue is set to null
315	>	*/
316		public void testNullPointerException() {
317	<	try{
317	>	try {
318		new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null);
319	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
319	>	shouldThrow();
320		}
321		catch (NullPointerException success){}
322		}
323
324
325
326	<	/** Throws if corePoolSize argument is less than zero */
326	>	/**
327	>	* Constructor throws if corePoolSize argument is less than zero
328	>	*/
329		public void testConstructor6() {
330	<	try{
330	>	try {
331		new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
332	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
332	>	shouldThrow();
333		} catch (IllegalArgumentException success){}
334		}
335
336	<	/** Throws if maximumPoolSize is less than zero */
336	>	/**
337	>	* Constructor throws if maximumPoolSize is less than zero
338	>	*/
339		public void testConstructor7() {
340	<	try{
340	>	try {
341		new ThreadPoolExecutor(1,-1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
342	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
342	>	shouldThrow();
343		}
344		catch (IllegalArgumentException success){}
345		}
346
347	<	/** Throws if maximumPoolSize is equal to zero */
347	>	/**
348	>	* Constructor throws if maximumPoolSize is equal to zero
349	>	*/
350		public void testConstructor8() {
351	<	try{
351	>	try {
352		new ThreadPoolExecutor(1,0,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
353	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
353	>	shouldThrow();
354		}
355		catch (IllegalArgumentException success){}
356		}
357
358	<	/** Throws if keepAliveTime is less than zero */
358	>	/**
359	>	* Constructor throws if keepAliveTime is less than zero
360	>	*/
361		public void testConstructor9() {
362	<	try{
362	>	try {
363		new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
364	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
364	>	shouldThrow();
365		}
366		catch (IllegalArgumentException success){}
367		}
368
369	<	/** Throws if corePoolSize is greater than the maximumPoolSize */
369	>	/**
370	>	* Constructor throws if corePoolSize is greater than the maximumPoolSize
371	>	*/
372		public void testConstructor10() {
373	<	try{
373	>	try {
374		new ThreadPoolExecutor(2,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
375	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
375	>	shouldThrow();
376		}
377		catch (IllegalArgumentException success){}
378		}
379
380	<	/** Throws if workQueue is set to null */
380	>	/**
381	>	* Constructor throws if workQueue is set to null
382	>	*/
383		public void testNullPointerException2() {
384	<	try{
384	>	try {
385		new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null,new MyThreadFactory());
386	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
386	>	shouldThrow();
387		}
388		catch (NullPointerException success){}
389		}
390
391	<	/** Throws if threadFactory is set to null */
391	>	/**
392	>	* Constructor throws if threadFactory is set to null
393	>	*/
394		public void testNullPointerException3() {
395	<	try{
395	>	try {
396		ThreadFactory f = null;
397		new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f);
398	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
398	>	shouldThrow();
399		}
400		catch (NullPointerException success){}
401		}
402
403
404	<	/** Throws if corePoolSize argument is less than zero */
404	>	/**
405	>	* Constructor throws if corePoolSize argument is less than zero
406	>	*/
407		public void testConstructor11() {
408	<	try{
408	>	try {
409		new ThreadPoolExecutor(-1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
410	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
410	>	shouldThrow();
411		}
412		catch (IllegalArgumentException success){}
413		}
414
415	<	/** Throws if maximumPoolSize is less than zero */
415	>	/**
416	>	* Constructor throws if maximumPoolSize is less than zero
417	>	*/
418		public void testConstructor12() {
419	<	try{
419	>	try {
420		new ThreadPoolExecutor(1,-1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
421	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
421	>	shouldThrow();
422		}
423		catch (IllegalArgumentException success){}
424		}
425
426	<	/** Throws if maximumPoolSize is equal to zero */
426	>	/**
427	>	* Constructor throws if maximumPoolSize is equal to zero
428	>	*/
429		public void testConstructor13() {
430	<	try{
430	>	try {
431		new ThreadPoolExecutor(1,0,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
432	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
432	>	shouldThrow();
433		}
434		catch (IllegalArgumentException success){}
435		}
436
437	<	/** Throws if keepAliveTime is less than zero */
437	>	/**
438	>	* Constructor throws if keepAliveTime is less than zero
439	>	*/
440		public void testConstructor14() {
441	<	try{
441	>	try {
442		new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
443	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
443	>	shouldThrow();
444		}
445		catch (IllegalArgumentException success){}
446		}
447
448	<	/** Throws if corePoolSize is greater than the maximumPoolSize */
448	>	/**
449	>	* Constructor throws if corePoolSize is greater than the maximumPoolSize
450	>	*/
451		public void testConstructor15() {
452	<	try{
452	>	try {
453		new ThreadPoolExecutor(2,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
454	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
454	>	shouldThrow();
455		}
456		catch (IllegalArgumentException success){}
457		}
458
459	<	/** Throws if workQueue is set to null */
459	>	/**
460	>	* Constructor throws if workQueue is set to null
461	>	*/
462		public void testNullPointerException4() {
463	<	try{
463	>	try {
464		new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null,new MyREHandler());
465	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
465	>	shouldThrow();
466		}
467		catch (NullPointerException success){}
468		}
469
470	<	/** Throws if handler is set to null */
470	>	/**
471	>	* Constructor throws if handler is set to null
472	>	*/
473		public void testNullPointerException5() {
474	<	try{
474	>	try {
475		RejectedExecutionHandler r = null;
476		new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r);
477	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
477	>	shouldThrow();
478		}
479		catch (NullPointerException success){}
480		}
481
482
483	<	/** Throws if corePoolSize argument is less than zero */
483	>	/**
484	>	* Constructor throws if corePoolSize argument is less than zero
485	>	*/
486		public void testConstructor16() {
487	<	try{
487	>	try {
488		new ThreadPoolExecutor(-1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
489	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
489	>	shouldThrow();
490		}
491		catch (IllegalArgumentException success){}
492		}
493
494	<	/** Throws if maximumPoolSize is less than zero */
494	>	/**
495	>	* Constructor throws if maximumPoolSize is less than zero
496	>	*/
497		public void testConstructor17() {
498	<	try{
498	>	try {
499		new ThreadPoolExecutor(1,-1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
500	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
500	>	shouldThrow();
501		}
502		catch (IllegalArgumentException success){}
503		}
504
505	<	/** Throws if maximumPoolSize is equal to zero */
505	>	/**
506	>	* Constructor throws if maximumPoolSize is equal to zero
507	>	*/
508		public void testConstructor18() {
509	<	try{
509	>	try {
510		new ThreadPoolExecutor(1,0,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
511	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
511	>	shouldThrow();
512		}
513		catch (IllegalArgumentException success){}
514		}
515
516	<	/** Throws if keepAliveTime is less than zero */
516	>	/**
517	>	* Constructor throws if keepAliveTime is less than zero
518	>	*/
519		public void testConstructor19() {
520	<	try{
520	>	try {
521		new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
522	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
522	>	shouldThrow();
523		}
524		catch (IllegalArgumentException success){}
525		}
526
527	<	/** Throws if corePoolSize is greater than the maximumPoolSize */
527	>	/**
528	>	* Constructor throws if corePoolSize is greater than the maximumPoolSize
529	>	*/
530		public void testConstructor20() {
531	<	try{
531	>	try {
532		new ThreadPoolExecutor(2,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
533	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
533	>	shouldThrow();
534		}
535		catch (IllegalArgumentException success){}
536		}
537
538	<	/** Throws if workQueue is set to null */
538	>	/**
539	>	* Constructor throws if workQueue is set to null
540	>	*/
541		public void testNullPointerException6() {
542	<	try{
542	>	try {
543		new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null,new MyThreadFactory(),new MyREHandler());
544	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
544	>	shouldThrow();
545		}
546		catch (NullPointerException success){}
547		}
548
549	<	/** Throws if handler is set to null */
549	>	/**
550	>	* Constructor throws if handler is set to null
551	>	*/
552		public void testNullPointerException7() {
553	<	try{
553	>	try {
554		RejectedExecutionHandler r = null;
555		new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),r);
556	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
556	>	shouldThrow();
557		}
558		catch (NullPointerException success){}
559		}
560
561	<	/** Throws if ThreadFactory is set top null */
561	>	/**
562	>	* Constructor throws if ThreadFactory is set top null
563	>	*/
564		public void testNullPointerException8() {
565	<	try{
565	>	try {
566		ThreadFactory f = null;
567		new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new MyREHandler());
568	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
568	>	shouldThrow();
569		}
570		catch (NullPointerException successdn8){}
571		}
572
573
574		/**
575	<	*   execute will throw RejectedExcutionException
498	<	*  ThreadPoolExecutor will throw one when more runnables are
499	<	*  executed then will fit in the Queue.
575	>	*  execute throws RejectedExecutionException if shutdown
576		*/
577	<	public void testRejectedExecutionException(){
577	>	public void testRejectedExecutionException() {
578		ThreadPoolExecutor tpe = null;
579	<	try{
579	>	try {
580		tpe = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
581		} catch(Exception e){}
582		tpe.shutdown();
583	<	try{
583	>	try {
584		tpe.execute(new NoOpRunnable());
585	<	fail("ThreadPoolExecutor - void execute(Runnable) should throw RejectedExecutionException");
585	>	shouldThrow();
586		} catch(RejectedExecutionException success){}
587
588		joinPool(tpe);
589		}
590	+
591	+	/**
592	+	*  execute throws RejectedExecutionException
593	+	*  if saturated.
594	+	*/
595	+	public void testSaturatedExecute() {
596	+	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
597	+	try {
598	+
599	+	for(int i = 0; i < 5; ++i){
600	+	p.execute(new MediumRunnable());
601	+	}
602	+	shouldThrow();
603	+	} catch(RejectedExecutionException success){}
604	+	joinPool(p);
605	+	}
606	+
607	+	/**
608	+	*  execute (null) throws NPE
609	+	*/
610	+	public void testExecuteNull() {
611	+	ThreadPoolExecutor tpe = null;
612	+	try {
613	+	tpe = new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
614	+	tpe.execute(null);
615	+	shouldThrow();
616	+	} catch(NullPointerException success){}
617	+
618	+	joinPool(tpe);
619	+	}
620
621		/**
622	<	*   setCorePoolSize will throw IllegalArgumentException
517	<	*  when given a negative
622	>	*  setCorePoolSize of netaitev value throws IllegalArgumentException
623		*/
624	<	public void testCorePoolSizeIllegalArgumentException(){
624	>	public void testCorePoolSizeIllegalArgumentException() {
625		ThreadPoolExecutor tpe = null;
626	<	try{
626	>	try {
627		tpe = new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
628		} catch(Exception e){}
629	<	try{
629	>	try {
630		tpe.setCorePoolSize(-1);
631	<	fail("ThreadPoolExecutor - void setCorePoolSize(int) should throw IllegalArgumentException");
631	>	shouldThrow();
632		} catch(IllegalArgumentException success){
633		} finally {
634		tpe.shutdown();
#	Line 531 | Line 636 | public class ThreadPoolExecutorTest exte
636		joinPool(tpe);
637		}
638
534	–
639		/**
640	<	*   setMaximumPoolSize(int) will throw IllegalArgumentException
641	<	*  if given a value less the it's actual core pool size
640	>	*  setMaximumPoolSize(int) throws IllegalArgumentException if
641	>	*  given a value less the core pool size
642		*/
643	<	public void testMaximumPoolSizeIllegalArgumentException(){
643	>	public void testMaximumPoolSizeIllegalArgumentException() {
644		ThreadPoolExecutor tpe = null;
645	<	try{
645	>	try {
646		tpe = new ThreadPoolExecutor(2,3,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
647		} catch(Exception e){}
648	<	try{
648	>	try {
649		tpe.setMaximumPoolSize(1);
650	<	fail("ThreadPoolExecutor - void setMaximumPoolSize(int) should throw IllegalArgumentException");
650	>	shouldThrow();
651		} catch(IllegalArgumentException success){
652		} finally {
653		tpe.shutdown();
#	Line 552 | Line 656 | public class ThreadPoolExecutorTest exte
656		}
657
658		/**
659	<	*   setMaximumPoolSize will throw IllegalArgumentException
660	<	*  if given a negative number
659	>	*  setMaximumPoolSize throws IllegalArgumentException
660	>	*  if given a negative value
661		*/
662	<	public void testMaximumPoolSizeIllegalArgumentException2(){
662	>	public void testMaximumPoolSizeIllegalArgumentException2() {
663		ThreadPoolExecutor tpe = null;
664	<	try{
664	>	try {
665		tpe = new ThreadPoolExecutor(2,3,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
666		} catch(Exception e){}
667	<	try{
667	>	try {
668		tpe.setMaximumPoolSize(-1);
669	<	fail("ThreadPoolExecutor - void setMaximumPoolSize(int) should throw IllegalArgumentException");
669	>	shouldThrow();
670		} catch(IllegalArgumentException success){
671		} finally {
672		tpe.shutdown();
#	Line 572 | Line 676 | public class ThreadPoolExecutorTest exte
676
677
678		/**
679	<	*   setKeepAliveTime will throw IllegalArgumentException
679	>	*  setKeepAliveTime  throws IllegalArgumentException
680		*  when given a negative value
681		*/
682	<	public void testKeepAliveTimeIllegalArgumentException(){
682	>	public void testKeepAliveTimeIllegalArgumentException() {
683		ThreadPoolExecutor tpe = null;
684	<	try{
684	>	try {
685		tpe = new ThreadPoolExecutor(2,3,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
686		} catch(Exception e){}
687
688	<	try{
688	>	try {
689		tpe.setKeepAliveTime(-1,TimeUnit.MILLISECONDS);
690	<	fail("ThreadPoolExecutor - void setKeepAliveTime(long, TimeUnit) should throw IllegalArgumentException");
690	>	shouldThrow();
691		} catch(IllegalArgumentException success){
692		} finally {
693		tpe.shutdown();

Diff Legend

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