KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > cocoon > components > thread > DefaultRunnableManagerTestCase


1 /*
2  * Copyright 1999-2004 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package org.apache.cocoon.components.thread;
17
18 import org.apache.avalon.framework.configuration.Configuration;
19 import org.apache.avalon.framework.configuration.ConfigurationException;
20 import org.apache.avalon.framework.logger.Logger;
21 import org.easymock.MockControl;
22
23 /**
24  * The $classType$ class ...
25  *
26  * @author <a HREF="mailto:giacomo.at.apache.org">Giacomo Pati </a>
27  * @version $Id$
28  */
29 public class DefaultRunnableManagerTestCase extends AbstractTestCase
30 {
31     //~ Constructors -----------------------------------------------------------
32
33     /**
34      * Constructor for DefaultRunnableManagerTestCase.
35      *
36      * @param name
37      */
38     public DefaultRunnableManagerTestCase( String JavaDoc name )
39     {
40         super( name );
41     }
42
43     //~ Methods ----------------------------------------------------------------
44
45     /**
46      * DOCUMENT ME!
47      *
48      * @throws Exception DOCUMENT ME!
49      */
50     public final void testConfigureDaemonPool( )
51     throws Exception JavaDoc
52     {
53         final MockControl threadPoolConfigControl =
54             createStrictControl( Configuration.class );
55         final Configuration threadPoolConfig =
56             (Configuration)threadPoolConfigControl.getMock( );
57         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "name" ),
58                                                  createValueConfigMock( "daemon" ) );
59         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "queue-size" ),
60                                                  createIntegerConfigMock( 2 * DefaultRunnableManager.DEFAULT_QUEUE_SIZE,
61                                                                           DefaultRunnableManager.DEFAULT_QUEUE_SIZE ) );
62         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "max-pool-size" ),
63                                                  createIntegerConfigMock( 2 * DefaultRunnableManager.DEFAULT_MAX_POOL_SIZE,
64                                                                           DefaultRunnableManager.DEFAULT_MAX_POOL_SIZE ) );
65         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "min-pool-size" ),
66                                                  createIntegerConfigMock( DefaultRunnableManager.DEFAULT_MIN_POOL_SIZE / 3,
67                                                                           DefaultRunnableManager.DEFAULT_MIN_POOL_SIZE ) );
68         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "priority" ),
69                                                  createValueConfigMock( "LOW",
70                                                                         DefaultRunnableManager.DEFAULT_THREAD_PRIORITY ) );
71         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "daemon" ),
72                                                  createBooleanConfigMock( false,
73                                                                           DefaultRunnableManager.DEFAULT_DAEMON_MODE ) );
74         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "keep-alive-time-ms" ),
75                                                  createLongConfigMock( DefaultRunnableManager.DEFAULT_KEEP_ALIVE_TIME / 2,
76                                                                        DefaultRunnableManager.DEFAULT_KEEP_ALIVE_TIME ) );
77         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "block-policy" ),
78                                                  createValueConfigMock( "WAIT",
79                                                                         DefaultThreadPool.POLICY_DEFAULT ) );
80         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "shutdown-graceful" ),
81                                                  createBooleanConfigMock( true,
82                                                                           DefaultRunnableManager.DEFAULT_SHUTDOWN_GRACEFUL ) );
83         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "shutdown-wait-time-ms" ),
84                                                  createIntegerConfigMock( DefaultRunnableManager.DEFAULT_SHUTDOWN_WAIT_TIME / 2,
85                                                                           DefaultRunnableManager.DEFAULT_SHUTDOWN_WAIT_TIME ) );
86         threadPoolConfigControl.replay( );
87
88         final MockControl mainConfigControl =
89             createStrictControl( Configuration.class );
90         final Configuration mainConfig =
91             (Configuration)mainConfigControl.getMock( );
92         mainConfigControl.expectAndReturn( mainConfig.getChild( "thread-factory" ),
93                                            createValueConfigMock( DefaultRunnableManager.DEFAULT_THREAD_FACTORY,
94                                                                   DefaultRunnableManager.DEFAULT_THREAD_FACTORY ) );
95         mainConfigControl.expectAndReturn( mainConfig.getChild( "thread-pools" ),
96                                            createChildrenConfigMock( "thread-pool",
97                                                                      new Configuration []
98                                                                      {
99                                                                          threadPoolConfig
100                                                                      } ) );
101         mainConfigControl.replay( );
102
103         final MockControl childLoggerDaemonControl =
104             createStrictControl( Logger.class );
105         final Logger childLoggerDaemon =
106             (Logger)childLoggerDaemonControl.getMock( );
107         childLoggerDaemonControl.replay( );
108
109         final MockControl childLoggerDefaultControl =
110             createStrictControl( Logger.class );
111         final Logger childLoggerDefault =
112             (Logger)childLoggerDefaultControl.getMock( );
113         childLoggerDefaultControl.replay( );
114
115         final MockControl loggerControl = createStrictControl( Logger.class );
116         final Logger logger = (Logger)loggerControl.getMock( );
117         logger.warn( "Unknown thread priority \"LOW\". Set to \"NORM\"." );
118         loggerControl.expectAndReturn( logger.getChildLogger( "daemon" ),
119                                        childLoggerDaemon );
120         loggerControl.expectAndReturn( logger.isInfoEnabled( ), true );
121         logger.info( "ThreadPool named \"daemon\" created with maximum queue-size=2147483647,max-pool-size=10,min-pool-size=1,priority=5,isDaemon=false,keep-alive-time-ms=30000,block-policy=\"WAIT\",shutdown-wait-time-ms=0" );
122         loggerControl.expectAndReturn( logger.getChildLogger( "default" ),
123                                        childLoggerDefault );
124         loggerControl.expectAndReturn( logger.isInfoEnabled( ), true );
125         logger.info( "ThreadPool named \"default\" created with maximum queue-size=2147483647,max-pool-size=5,min-pool-size=5,priority=5,isDaemon=false,keep-alive-time-ms=60000,block-policy=\"RUN\",shutdown-wait-time-ms=-1" );
126         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
127         logger.debug( "Disposing all thread pools" );
128         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
129         logger.debug( "Disposing thread pool daemon" );
130         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
131         logger.debug( "Thread pool daemon disposed" );
132         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
133         logger.debug( "Disposing thread pool default" );
134         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
135         logger.debug( "Thread pool default disposed" );
136         loggerControl.replay( );
137
138         final DefaultRunnableManager runnableManager =
139             new DefaultRunnableManager( );
140         runnableManager.enableLogging( logger );
141
142         try
143         {
144             runnableManager.configure( mainConfig );
145         }
146         catch( final ConfigurationException ce )
147         {
148             assertTrue( "Throw unexpected ConfigurationException", false );
149         }
150
151         runnableManager.dispose( );
152         verify( );
153     }
154
155     /**
156      * DOCUMENT ME!
157      */
158     public final void testConfigureMinimal( )
159     {
160         final MockControl mainConfigControl =
161             createStrictControl( Configuration.class );
162         final Configuration mainConfig =
163             (Configuration)mainConfigControl.getMock( );
164         mainConfigControl.expectAndReturn( mainConfig.getChild( "thread-factory" ),
165                                            createValueConfigMock( DefaultRunnableManager.DEFAULT_THREAD_FACTORY,
166                                                                   DefaultRunnableManager.DEFAULT_THREAD_FACTORY ) );
167         mainConfigControl.expectAndReturn( mainConfig.getChild( "thread-pools" ),
168                                            createChildrenConfigMock( "thread-pool",
169                                                                      new Configuration[ 0 ] ) );
170         mainConfigControl.replay( );
171
172         final MockControl childLoggerDefaultControl =
173             createStrictControl( Logger.class );
174         final Logger childLoggerDefault =
175             (Logger)childLoggerDefaultControl.getMock( );
176         childLoggerDefaultControl.replay( );
177
178         final MockControl loggerControl = createStrictControl( Logger.class );
179         final Logger logger = (Logger)loggerControl.getMock( );
180         loggerControl.expectAndReturn( logger.getChildLogger( "default" ),
181                                        childLoggerDefault );
182         loggerControl.expectAndReturn( logger.isInfoEnabled( ), true );
183         logger.info( "ThreadPool named \"default\" created with maximum queue-size=2147483647,max-pool-size=5,min-pool-size=5,priority=5,isDaemon=false,keep-alive-time-ms=60000,block-policy=\"RUN\",shutdown-wait-time-ms=-1" );
184         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
185         logger.debug( "Disposing all thread pools" );
186         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
187         logger.debug( "Disposing thread pool default" );
188         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
189         logger.debug( "Thread pool default disposed" );
190         loggerControl.replay( );
191
192         final DefaultRunnableManager runnableManager =
193             new DefaultRunnableManager( );
194         runnableManager.enableLogging( logger );
195
196         try
197         {
198             runnableManager.configure( mainConfig );
199         }
200         catch( final ConfigurationException ce )
201         {
202             assertTrue( "Throw unexpected ConfigurationException", false );
203         }
204
205         runnableManager.dispose( );
206         verify( );
207     }
208
209     /**
210      * DOCUMENT ME!
211      *
212      * @throws Exception DOCUMENT ME!
213      */
214     public final void testConfigureMyPool( )
215         throws Exception JavaDoc
216     {
217         final MockControl threadPoolConfigControl =
218             createStrictControl( Configuration.class );
219         final Configuration threadPoolConfig =
220             (Configuration)threadPoolConfigControl.getMock( );
221         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "name" ),
222                                                  createValueConfigMock( "mypool" ) );
223         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "queue-size" ),
224                                                  createIntegerConfigMock( 2 * DefaultRunnableManager.DEFAULT_QUEUE_SIZE,
225                                                                           DefaultRunnableManager.DEFAULT_QUEUE_SIZE ) );
226         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "max-pool-size" ),
227                                                  createIntegerConfigMock( 2 * DefaultRunnableManager.DEFAULT_MAX_POOL_SIZE,
228                                                                           DefaultRunnableManager.DEFAULT_MAX_POOL_SIZE ) );
229         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "min-pool-size" ),
230                                                  createIntegerConfigMock( DefaultRunnableManager.DEFAULT_MIN_POOL_SIZE / 3,
231                                                                           DefaultRunnableManager.DEFAULT_MIN_POOL_SIZE ) );
232         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "priority" ),
233                                                  createValueConfigMock( "MIN",
234                                                                         DefaultRunnableManager.DEFAULT_THREAD_PRIORITY ) );
235         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "daemon" ),
236                                                  createBooleanConfigMock( false,
237                                                                           DefaultRunnableManager.DEFAULT_DAEMON_MODE ) );
238         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "keep-alive-time-ms" ),
239                                                  createLongConfigMock( DefaultRunnableManager.DEFAULT_KEEP_ALIVE_TIME / 2,
240                                                                        DefaultRunnableManager.DEFAULT_KEEP_ALIVE_TIME ) );
241         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "block-policy" ),
242                                                  createValueConfigMock( "WAIT",
243                                                                         DefaultThreadPool.POLICY_DEFAULT ) );
244         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "shutdown-graceful" ),
245                                                  createBooleanConfigMock( true,
246                                                                           DefaultRunnableManager.DEFAULT_SHUTDOWN_GRACEFUL ) );
247         threadPoolConfigControl.expectAndReturn( threadPoolConfig.getChild( "shutdown-wait-time-ms" ),
248                                                  createIntegerConfigMock( DefaultRunnableManager.DEFAULT_SHUTDOWN_WAIT_TIME / 2,
249                                                                           DefaultRunnableManager.DEFAULT_SHUTDOWN_WAIT_TIME ) );
250         threadPoolConfigControl.replay( );
251
252         final MockControl mainConfigControl =
253             createStrictControl( Configuration.class );
254         final Configuration mainConfig =
255             (Configuration)mainConfigControl.getMock( );
256         mainConfigControl.expectAndReturn( mainConfig.getChild( "thread-factory" ),
257                                            createValueConfigMock( DefaultRunnableManager.DEFAULT_THREAD_FACTORY,
258                                                                   DefaultRunnableManager.DEFAULT_THREAD_FACTORY ) );
259         mainConfigControl.expectAndReturn( mainConfig.getChild( "thread-pools" ),
260                                            createChildrenConfigMock( "thread-pool",
261                                                                      new Configuration []
262                                                                      {
263                                                                          threadPoolConfig
264                                                                      } ) );
265         mainConfigControl.replay( );
266
267         final MockControl childLoggerDefaultControl =
268             createStrictControl( Logger.class );
269         final Logger childLoggerDefault =
270             (Logger)childLoggerDefaultControl.getMock( );
271         childLoggerDefaultControl.replay( );
272
273         final MockControl childLoggerMyPoolControl =
274             createStrictControl( Logger.class );
275         final Logger childLoggerMyPool =
276             (Logger)childLoggerMyPoolControl.getMock( );
277         childLoggerMyPoolControl.replay( );
278
279         final MockControl loggerControl = createStrictControl( Logger.class );
280         final Logger logger = (Logger)loggerControl.getMock( );
281         loggerControl.expectAndReturn( logger.getChildLogger( "mypool" ),
282                                        childLoggerMyPool );
283         loggerControl.expectAndReturn( logger.isInfoEnabled( ), true );
284         logger.info( "ThreadPool named \"mypool\" created with maximum queue-size=2147483647,max-pool-size=10,min-pool-size=1,priority=1,isDaemon=false,keep-alive-time-ms=30000,block-policy=\"WAIT\",shutdown-wait-time-ms=0" );
285         loggerControl.expectAndReturn( logger.getChildLogger( "default" ),
286                                        childLoggerDefault );
287         loggerControl.expectAndReturn( logger.isInfoEnabled( ), true );
288         logger.info( "ThreadPool named \"default\" created with maximum queue-size=2147483647,max-pool-size=5,min-pool-size=5,priority=5,isDaemon=false,keep-alive-time-ms=60000,block-policy=\"RUN\",shutdown-wait-time-ms=-1" );
289         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
290         logger.debug( "Disposing all thread pools" );
291         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
292         logger.debug( "Disposing thread pool mypool" );
293         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
294         logger.debug( "Thread pool mypool disposed" );
295         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
296         logger.debug( "Disposing thread pool default" );
297         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
298         logger.debug( "Thread pool default disposed" );
299         loggerControl.replay( );
300
301         final DefaultRunnableManager runnableManager =
302             new DefaultRunnableManager( );
303         runnableManager.enableLogging( logger );
304
305         try
306         {
307             runnableManager.configure( mainConfig );
308         }
309         catch( final ConfigurationException ce )
310         {
311             assertTrue( "Throw unexpected ConfigurationException", false );
312         }
313
314         runnableManager.dispose( );
315         verify( );
316     }
317
318     /**
319      * Class under test for void createPool(String, int, int, int, int,
320      * boolean, long, String, boolean, int)
321      */
322     public final void testCreatePoolStringintintintintbooleanlongStringbooleanint( )
323     {
324         final MockControl mainConfigControl =
325             createStrictControl( Configuration.class );
326         final Configuration mainConfig =
327             (Configuration)mainConfigControl.getMock( );
328         mainConfigControl.expectAndReturn( mainConfig.getChild( "thread-factory" ),
329                                            createValueConfigMock( DefaultRunnableManager.DEFAULT_THREAD_FACTORY,
330                                                                   DefaultRunnableManager.DEFAULT_THREAD_FACTORY ) );
331         mainConfigControl.expectAndReturn( mainConfig.getChild( "thread-pools" ),
332                                            createChildrenConfigMock( "thread-pool",
333                                                                      new Configuration[ 0 ] ) );
334         mainConfigControl.replay( );
335
336         final MockControl childLoggerDefaultControl =
337             createStrictControl( Logger.class );
338         final Logger childLoggerDefault =
339             (Logger)childLoggerDefaultControl.getMock( );
340         childLoggerDefaultControl.replay( );
341
342         final MockControl childLoggerMyPoolControl =
343             createStrictControl( Logger.class );
344         final Logger childLoggerMyPool =
345             (Logger)childLoggerMyPoolControl.getMock( );
346         childLoggerMyPoolControl.replay( );
347
348         final MockControl loggerControl = createStrictControl( Logger.class );
349         final Logger logger = (Logger)loggerControl.getMock( );
350         loggerControl.expectAndReturn( logger.getChildLogger( "default" ),
351                                        childLoggerDefault );
352         loggerControl.expectAndReturn( logger.isInfoEnabled( ), true );
353         logger.info( "ThreadPool named \"default\" created with maximum queue-size=2147483647,max-pool-size=5,min-pool-size=5,priority=5,isDaemon=false,keep-alive-time-ms=60000,block-policy=\"RUN\",shutdown-wait-time-ms=-1" );
354         loggerControl.expectAndReturn( logger.getChildLogger( "mypool" ),
355                                        childLoggerMyPool );
356         loggerControl.expectAndReturn( logger.isInfoEnabled( ), true );
357         logger.info( "ThreadPool named \"mypool\" created with maximum queue-size=230,max-pool-size=15,min-pool-size=12,priority=1,isDaemon=false,keep-alive-time-ms=15500,block-policy=\"DISCARD\",shutdown-wait-time-ms=22200" );
358         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
359         logger.debug( "Disposing all thread pools" );
360         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
361         logger.debug( "Disposing thread pool mypool" );
362         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
363         logger.debug( "Thread pool mypool disposed" );
364         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
365         logger.debug( "Disposing thread pool default" );
366         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
367         logger.debug( "Thread pool default disposed" );
368         loggerControl.replay( );
369
370         final DefaultRunnableManager runnableManager =
371             new DefaultRunnableManager( );
372         runnableManager.enableLogging( logger );
373
374         try
375         {
376             runnableManager.configure( mainConfig );
377         }
378         catch( final ConfigurationException ce )
379         {
380             assertTrue( "Throw unexpected ConfigurationException", false );
381         }
382
383         runnableManager.createPool( "mypool", 230, 15, 12, Thread.MIN_PRIORITY,
384                                     false, 15500, "DISCARD", false, 22200 );
385         runnableManager.dispose( );
386         verify( );
387     }
388
389     /**
390      * Class under test for ThreadPool createPool(int, int, int, int, boolean,
391      * long, String, boolean, int)
392      */
393     public final void testCreatePoolintintintintbooleanlongStringbooleanint( )
394     {
395         final MockControl mainConfigControl =
396             createStrictControl( Configuration.class );
397         final Configuration mainConfig =
398             (Configuration)mainConfigControl.getMock( );
399         mainConfigControl.expectAndReturn( mainConfig.getChild( "thread-factory" ),
400                                            createValueConfigMock( DefaultRunnableManager.DEFAULT_THREAD_FACTORY,
401                                                                   DefaultRunnableManager.DEFAULT_THREAD_FACTORY ) );
402         mainConfigControl.expectAndReturn( mainConfig.getChild( "thread-pools" ),
403                                            createChildrenConfigMock( "thread-pool",
404                                                                      new Configuration[ 0 ] ) );
405         mainConfigControl.replay( );
406
407         final MockControl childLoggerDefaultControl =
408             createStrictControl( Logger.class );
409         final Logger childLoggerDefault =
410             (Logger)childLoggerDefaultControl.getMock( );
411         childLoggerDefaultControl.replay( );
412
413         final MockControl childLoggerAnonControl =
414             createStrictControl( Logger.class );
415         final Logger childLoggerAnon =
416             (Logger)childLoggerAnonControl.getMock( );
417         childLoggerAnonControl.replay( );
418
419         final MockControl loggerControl = createStrictControl( Logger.class );
420         final Logger logger = (Logger)loggerControl.getMock( );
421         loggerControl.expectAndReturn( logger.getChildLogger( "default" ),
422                                        childLoggerDefault );
423         loggerControl.expectAndReturn( logger.isInfoEnabled( ), true );
424         logger.info( "ThreadPool named \"default\" created with maximum queue-size=2147483647,max-pool-size=5,min-pool-size=5,priority=5,isDaemon=false,keep-alive-time-ms=60000,block-policy=\"RUN\",shutdown-wait-time-ms=-1" );
425         loggerControl.expectAndReturn( logger.getChildLogger( "anon-xxx" ),
426                                        childLoggerAnon );
427         loggerControl.setMatcher( MockControl.ALWAYS_MATCHER );
428         loggerControl.expectAndReturn( logger.isInfoEnabled( ), true );
429         logger.info( "ThreadPool named \"anon-xxx\" created with maximum queue-size=2147483647,max-pool-size=5,min-pool-size=5,priority=10,isDaemon=false,keep-alive-time-ms=60000,block-policy=\"RUN\",shutdown-wait-time-ms=-1" );
430         loggerControl.setMatcher( MockControl.ALWAYS_MATCHER );
431         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
432         logger.debug( "Disposing all thread pools" );
433         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
434         logger.debug( "Disposing thread pool anon-xxx" );
435         loggerControl.setMatcher( MockControl.ALWAYS_MATCHER );
436         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
437         logger.debug( "Thread pool anon-xxx disposed" );
438         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
439         logger.debug( "Disposing thread pool default" );
440         loggerControl.setMatcher( MockControl.ALWAYS_MATCHER );
441         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
442         logger.debug( "Thread pool default disposed" );
443         loggerControl.replay( );
444
445         final DefaultRunnableManager runnableManager =
446             new DefaultRunnableManager( );
447         runnableManager.enableLogging( logger );
448
449         try
450         {
451             runnableManager.configure( mainConfig );
452         }
453         catch( final ConfigurationException ce )
454         {
455             assertTrue( "Throw unexpected ConfigurationException", false );
456         }
457
458         final ThreadPool threadPool =
459             runnableManager.createPool( 200, 5, 2, Thread.MAX_PRIORITY, true,
460                                         15000, "ABORT", true, 22000 );
461         assertEquals( "queue-size", 200, threadPool.getMaximumQueueSize( ) );
462         assertEquals( "max-pool-size", 5, threadPool.getMaximumPoolSize( ) );
463         assertEquals( "min-pool-size", 2, threadPool.getMinimumPoolSize( ) );
464         assertEquals( "priority", Thread.MAX_PRIORITY,
465                       threadPool.getPriority( ) );
466         assertEquals( "keep-alive-time-ms", 15000,
467                       threadPool.getKeepAliveTime( ) );
468         assertEquals( "block-policy", "ABORT", threadPool.getBlockPolicy( ) );
469         runnableManager.dispose( );
470         verify( );
471     }
472
473     /**
474      * Class under test for void execute(Runnable)
475      */
476     public final void testExecuteRunnable( )
477     {
478         final MockControl mainConfigControl =
479             createStrictControl( Configuration.class );
480         final Configuration mainConfig =
481             (Configuration)mainConfigControl.getMock( );
482         mainConfigControl.expectAndReturn( mainConfig.getChild( "thread-factory" ),
483                                            createValueConfigMock( DefaultRunnableManager.DEFAULT_THREAD_FACTORY,
484                                                                   DefaultRunnableManager.DEFAULT_THREAD_FACTORY ) );
485         mainConfigControl.expectAndReturn( mainConfig.getChild( "thread-pools" ),
486                                            createChildrenConfigMock( "thread-pool",
487                                                                      new Configuration[ 0 ] ) );
488         mainConfigControl.replay( );
489
490         final MockControl childLoggerControl =
491             createStrictControl( Logger.class );
492         final Logger childLogger = (Logger)childLoggerControl.getMock( );
493         childLoggerControl.expectAndReturn( childLogger.isDebugEnabled( ), true );
494         childLogger.debug( "Executing Command: org.apache.cocoon.components.thread.DefaultRunnableManager" );
495         childLoggerControl.setMatcher( MockControl.ALWAYS_MATCHER );
496         childLoggerControl.expectAndReturn( childLogger.isDebugEnabled( ), true );
497         childLogger.debug( "Executing Command: org.apache.cocoon.components.thread.DefaultRunnableManager" );
498         childLoggerControl.replay( );
499
500         final MockControl loggerControl = createStrictControl( Logger.class );
501         final Logger logger = (Logger)loggerControl.getMock( );
502         loggerControl.expectAndReturn( logger.getChildLogger( "default" ),
503                                        childLogger );
504         loggerControl.expectAndReturn( logger.isInfoEnabled( ), true );
505         logger.info( "ThreadPool named \"default\" created with maximum queue-size=2147483647,max-pool-size=5,min-pool-size=5,priority=5,isDaemon=false,keep-alive-time-ms=60000,block-policy=\"RUN\",shutdown-wait-time-ms=-1" );
506         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
507         logger.debug( "Starting the heart" );
508         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
509         logger.debug( "Entering loop" );
510         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
511         logger.debug( "No commands available. Will just wait for one" );
512         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
513         logger.debug( "Command entered: EasyMock for interface java.lang.Runnable, pool=default, delay=0, interval=0" );
514         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
515         logger.debug( "Executing command EasyMock for interface java.lang.Runnable in pool \"default\", schedule with interval=0" );
516         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
517         logger.debug( "No commands available. Will just wait for one" );
518         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
519         logger.debug( "Exiting loop" );
520         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
521         logger.debug( "Disposing all thread pools" );
522         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
523         logger.debug( "Disposing thread pool default" );
524         loggerControl.expectAndReturn( logger.isDebugEnabled( ), true );
525         logger.debug( "Thread pool default disposed" );
526         loggerControl.replay( );
527
528         final DefaultRunnableManager runnableManager =
529             new DefaultRunnableManager( );
530         runnableManager.enableLogging( logger );
531
532         try
533         {
534             runnableManager.configure( mainConfig );
535         }
536         catch( final ConfigurationException ce )
537         {
538             assertTrue( "Throw unexpected ConfigurationException", false );
539         }
540
541         final MockControl runnableControl =
542             createStrictControl( Runnable JavaDoc.class );
543         final Runnable JavaDoc runnable = (Runnable JavaDoc)runnableControl.getMock( );
544         runnable.run( );
545         runnableControl.replay( );
546
547         try
548         {
549             runnableManager.start( );
550             Thread.yield( );
551             Thread.sleep( 20 );
552             runnableManager.execute( runnable );
553             Thread.yield( );
554             Thread.sleep( 20 );
555             runnableManager.stop( );
556             Thread.yield( );
557             Thread.sleep( 20 );
558             runnableManager.dispose( );
559             Thread.sleep( 20 );
560         }
561         catch( final Throwable JavaDoc ex )
562         {
563             ex.printStackTrace( );
564             assertTrue( "Unexpected Exception", false );
565         }
566
567         verify( );
568     }
569
570     /**
571      * Class under test for void execute(Runnable, long)
572      */
573     public final void testExecuteRunnablelong( )
574     {
575         final MockControl mainConfigControl =
576             createStrictControl( Configuration.class );
577         final Configuration mainConfig =
578             (Configuration)mainConfigControl.getMock( );
579         mainConfigControl.expectAndReturn( mainConfig.getChild( "thread-factory" ),
580                                            createValueConfigMock( DefaultRunnableManager.DEFAULT_THREAD_FACTORY,
581                                                                   DefaultRunnableManager.DEFAULT_THREAD_FACTORY ) );
582         mainConfigControl.expectAndReturn( mainConfig.getChild( "thread-pools" ),
583                                            createChildrenConfigMock( "thread-pool",
584                                                                      new Configuration[ 0 ] ) );
585         mainConfigControl.replay( );
586
587         final MockControl childLoggerControl =
588             createStrictControl( Logger.class );
589         final Logger childLogger = (Logger)childLoggerControl.getMock( );
590         childLoggerControl.expectAndReturn( childLogger.isDebugEnabled( ), true );
591         childLogger.debug( "Executing Command: org.apache.cocoon.components.thread.DefaultRunnableManager" );
592         childLoggerControl.setMatcher( MockControl.ALWAYS_MATCHER );
593         childLoggerControl.expectAndReturn( childLogger.isDebugEnabled( ), true );
594         childLogger.debug( "Executing Command: org.apache.cocoon.components.thread.DefaultRunnableManager" );
595         childLoggerControl.replay( );
596
597         final MockControl loggerControl = createStrictControl( Logger.class );
598         final Logger logger = (Logger)loggerControl.getMock( );
599         loggerControl.expectAndReturn( logger.getChildLogger( "default" ),
600