1 /*
2 * jDTAUS Core Test Suite
3 * Copyright (C) 2005 Christian Schulte
4 * <cs@schulte.it>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 */
21 package org.jdtaus.core.monitor.spi.it;
22
23 import java.util.Iterator;
24 import java.util.LinkedList;
25 import java.util.List;
26 import java.util.Locale;
27 import junit.framework.Assert;
28 import org.jdtaus.core.monitor.TaskEvent;
29 import org.jdtaus.core.monitor.TaskEventSource;
30 import org.jdtaus.core.monitor.TaskListener;
31 import org.jdtaus.core.monitor.it.TaskEventSourceTest;
32 import org.jdtaus.core.monitor.spi.Task;
33 import org.jdtaus.core.monitor.spi.TaskMonitor;
34 import org.jdtaus.core.text.Message;
35
36 /**
37 * Testcase for {@code TaskMonitor} implementations.
38 *
39 * @author <a href="mailto:cs@schulte.it">Christian Schulte</a>
40 * @version $JDTAUS: TaskMonitorTest.java 8641 2012-09-27 06:45:17Z schulte $
41 */
42 public class TaskMonitorTest extends TaskEventSourceTest
43 {
44 //--TaskEventSourceTest-----------------------------------------------------
45
46 /**
47 * {@inheritDoc}
48 * @see #getTaskMonitor()
49 */
50 public final TaskEventSource getTaskEventSource()
51 {
52 return this.monitor;
53 }
54
55 //-----------------------------------------------------TaskEventSourceTest--
56 //--TaskMonitorTest---------------------------------------------------------
57
58 /** Implementation to test. */
59 private TaskMonitor monitor;
60
61 /**
62 * Gets the {@code TaskMonitor} implementation tests are performed with.
63 *
64 * @return the {@code TaskMonitor} implementation tests are performed
65 * with.
66 */
67 public TaskMonitor getTaskMonitor()
68 {
69 return this.monitor;
70 }
71
72 /**
73 * Sets the {@code TaskMonitor} implementation tests are performed with.
74 *
75 * @param value the {@code TaskMonitor} implementation to perform tests
76 * with.
77 */
78 public final void setTaskMonitor( final TaskMonitor value )
79 {
80 this.monitor = value;
81 this.setTaskEventSource( value );
82 }
83
84 /** {@code Task} implementation monitoring is tested with. */
85 public static final class TestMessage extends Message
86 {
87
88 /** @serial */
89 String text = TaskMonitorTest.class.getName();
90
91 public Object[] getFormatArguments( final Locale locale )
92 {
93 return new Object[ 0 ];
94 }
95
96 public String getText( final Locale locale )
97 {
98 return this.text;
99 }
100
101 public void setText( final String value )
102 {
103 this.text = value;
104 }
105
106 }
107
108 /** {@code TaskListener} implementation monitoring is tested with. */
109 public static final class TestTaskListener implements TaskListener
110 {
111
112 /** The instance of the tested task. */
113 private Task task;
114
115 /** The timestamp the tested task started. */
116 private long startTime;
117
118 /** The timestamp the tested task ended. */
119 private long endTime;
120
121 /** Flag indicating that the tested task changed its state. */
122 private boolean changedState;
123
124 /**
125 * Creates a new {@code TestTaskListener} instance taking the tested
126 * task.
127 *
128 * @param task the tested task.
129 */
130 public TestTaskListener( final Task task )
131 {
132 if ( task == null )
133 {
134 throw new NullPointerException( "task" );
135 }
136
137 this.task = task;
138 this.reset();
139 }
140
141 /**
142 * Gets the timestamp the tested task started.
143 *
144 * @return the timestamp the tested task started or {@code -1} if no
145 * corresponding event got fired.
146 */
147 public long getStartTime()
148 {
149 return this.startTime;
150 }
151
152 /**
153 * Sets the timestamp the tested task ended.
154 *
155 * @return the timestamp the tested task ended or {@code -1} if no
156 * corresponding event got fired.
157 */
158 public long getEndTime()
159 {
160 return this.endTime;
161 }
162
163 /**
164 * Flag indicating that corresponding events caused by the task
165 * changing its state were fired.
166 *
167 * @return {@code true} if corresponding event got fired indicating
168 * the task having changed state; {@code false} if no corresponding
169 * events got fired.
170 */
171 public boolean getChangedState()
172 {
173 return this.changedState;
174 }
175
176 /** Resets the state of the listener. */
177 public void reset()
178 {
179 this.startTime = -1L;
180 this.endTime = -1L;
181 this.changedState = false;
182 }
183
184 public void onTaskEvent( final TaskEvent taskEvent )
185 {
186 if ( taskEvent.getTask().equals( this.task ) )
187 {
188 final int type = taskEvent.getType();
189 if ( type == TaskEvent.STARTED )
190 {
191 assert this.startTime == -1;
192 this.startTime = System.currentTimeMillis();
193 }
194 else if ( type == TaskEvent.ENDED )
195 {
196 assert this.endTime == -1;
197 this.endTime = System.currentTimeMillis();
198 }
199 else if ( type == TaskEvent.CHANGED_STATE )
200 {
201 this.changedState = true;
202 }
203 else
204 {
205 throw new IllegalStateException( Integer.toString( type ) );
206 }
207 }
208 }
209
210 }
211
212 //---------------------------------------------------------TaskMonitorTest--
213 //--Tests-------------------------------------------------------------------
214
215 /**
216 * Tests the {@link TaskMonitor#monitor(Task)} and
217 * {@link TaskMonitor#finish(Task)} implementation to handle illegal
218 * arguments correctly by throwing a corresponding
219 * {@code NullPointerException}.
220 */
221 public void testIllegalArguments() throws Exception
222 {
223 assert this.getTaskMonitor() != null;
224
225 try
226 {
227 this.getTaskMonitor().monitor( null );
228 throw new AssertionError();
229 }
230 catch ( NullPointerException e )
231 {
232 Assert.assertNotNull( e.getMessage() );
233 System.out.println( e.toString() );
234 }
235
236 try
237 {
238 this.getTaskMonitor().finish( null );
239 throw new AssertionError();
240 }
241 catch ( NullPointerException e )
242 {
243 Assert.assertNotNull( e.getMessage() );
244 System.out.println( e.toString() );
245 }
246
247
248 }
249
250 /**
251 * Tests the {@link TaskMonitor#monitor(Task)} and
252 * {@link TaskMonitor#finish(Task)} implementation to fire corresponding
253 * events during task monitoring.
254 */
255 public void testMonitoring() throws Exception
256 {
257 assert this.getTaskMonitor() != null;
258
259 final Task task = new Task();
260 final TestTaskListener listener = new TestTaskListener( task );
261
262 task.setDescription( new TestMessage() );
263
264 this.getTaskEventSource().addTaskListener( listener );
265
266 task.setIndeterminate( false );
267 task.setMinimum( 0 );
268 task.setMaximum( 10 );
269 task.setProgress( 0 );
270
271 this.getTaskMonitor().monitor( task );
272
273 for ( int i = 10; i > 0; i-- )
274 {
275 task.setProgress( i );
276 Thread.currentThread().sleep( 1000 );
277 }
278
279 this.getTaskMonitor().finish( task );
280
281 Assert.assertTrue( listener.getStartTime() > 0 );
282 Assert.assertTrue( listener.getEndTime() > 0 );
283 Assert.assertTrue( listener.getChangedState() );
284 }
285
286 /**
287 * Tests the {@link TaskMonitor#monitor(Task)} and
288 * {@link TaskMonitor#finish(Task)} implementation to fire corresponding
289 * events during task monitoring for property {@code progressDescription}.
290 */
291 public void testProgressDescriptionMonitoring() throws Exception
292 {
293 assert this.getTaskMonitor() != null;
294
295 final Task task = new Task();
296 final TestTaskListener listener = new TestTaskListener( task );
297 final TestMessage progressDescription = new TestMessage();
298
299 task.setDescription( new TestMessage() );
300 task.setProgressDescription( progressDescription );
301
302 this.getTaskEventSource().addTaskListener( listener );
303
304 task.setIndeterminate( true );
305
306 this.getTaskMonitor().monitor( task );
307
308 for ( int i = 2; i > 0; i-- )
309 {
310 Thread.currentThread().sleep( 1000 );
311 progressDescription.setText( Integer.toString( i ) );
312 }
313
314 this.getTaskMonitor().finish( task );
315
316 Assert.assertTrue( listener.getStartTime() > 0 );
317 Assert.assertTrue( listener.getEndTime() > 0 );
318 Assert.assertTrue( listener.getChangedState() );
319 }
320
321 /**
322 * Tests the {@link TaskMonitor#monitor(Task)} and
323 * {@link TaskMonitor#finish(Task)} implementation to fire corresponding
324 * events during task monitoring when an application updates property
325 * {@code cancelled}.
326 */
327 public void testCancelable() throws Exception
328 {
329 assert this.getTaskMonitor() != null;
330
331 final Task task = new Task();
332 final TestTaskListener listener = new TestTaskListener( task );
333
334 this.getTaskEventSource().addTaskListener( listener );
335
336 task.setCancelable( true );
337 task.setDescription( new TestMessage() );
338
339 this.getTaskMonitor().monitor( task );
340
341 for ( int i = 10; i > 0; i-- )
342 {
343 if ( i == 10 )
344 {
345 task.setCancelled( true );
346 }
347
348 Thread.currentThread().sleep( 1000 );
349 }
350
351 this.getTaskMonitor().finish( task );
352
353 Assert.assertTrue( listener.getStartTime() > 0 );
354 Assert.assertTrue( listener.getEndTime() > 0 );
355 Assert.assertTrue( listener.getChangedState() );
356 }
357
358 /**
359 * Tests the {@link TaskMonitor#monitor(Task)} and
360 * {@link TaskMonitor#finish(Task)} implementation to not throw any
361 * exceptions for parallel accessing tasks.
362 */
363 public void testSynchronization() throws Exception
364 {
365 final List threads = new LinkedList();
366 for ( int i = 10; i > 0; i-- )
367 {
368 final Thread thread = new Thread()
369 {
370
371 public void run()
372 {
373 try
374 {
375 final Task task = new Task();
376 task.setIndeterminate( true );
377 task.setDescription( new TestMessage() );
378
379 getTaskMonitor().monitor( task );
380 for ( int j = 10; j > 0; j-- )
381 {
382 Thread.sleep( 1000 );
383 }
384 getTaskMonitor().finish( task );
385 }
386 catch ( InterruptedException e )
387 {
388 throw new AssertionError( e );
389 }
390 }
391
392 };
393
394 threads.add( thread );
395 thread.start();
396 }
397
398 for ( Iterator it = threads.iterator(); it.hasNext();)
399 {
400 ( ( Thread ) it.next() ).join();
401 }
402 }
403
404 //-------------------------------------------------------------------Tests--
405 }