View Javadoc

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 8743 2012-10-07 03:06:20Z 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      /** Creates a new {@code TaskMonitorTest} instance. */
62      public TaskMonitorTest()
63      {
64          super();
65      }
66  
67      /**
68       * Gets the {@code TaskMonitor} implementation tests are performed with.
69       *
70       * @return the {@code TaskMonitor} implementation tests are performed
71       * with.
72       */
73      public TaskMonitor getTaskMonitor()
74      {
75          return this.monitor;
76      }
77  
78      /**
79       * Sets the {@code TaskMonitor} implementation tests are performed with.
80       *
81       * @param value the {@code TaskMonitor} implementation to perform tests
82       * with.
83       */
84      public final void setTaskMonitor( final TaskMonitor value )
85      {
86          this.monitor = value;
87          this.setTaskEventSource( value );
88      }
89  
90      /** {@code Task} implementation monitoring is tested with. */
91      public static final class TestMessage extends Message
92      {
93  
94          /** @serial */
95          private String text = TaskMonitorTest.class.getName();
96  
97          public TestMessage()
98          {
99              super();
100         }
101 
102         public Object[] getFormatArguments( final Locale locale )
103         {
104             return new Object[ 0 ];
105         }
106 
107         public String getText( final Locale locale )
108         {
109             return this.text;
110         }
111 
112         public void setText( final String value )
113         {
114             this.text = value;
115         }
116 
117     }
118 
119     /** {@code TaskListener} implementation monitoring is tested with. */
120     public static final class TestTaskListener implements TaskListener
121     {
122 
123         /** The instance of the tested task. */
124         private Task task;
125 
126         /** The timestamp the tested task started. */
127         private long startTime;
128 
129         /** The timestamp the tested task ended. */
130         private long endTime;
131 
132         /** Flag indicating that the tested task changed its state. */
133         private boolean changedState;
134 
135         /**
136          * Creates a new {@code TestTaskListener} instance taking the tested
137          * task.
138          *
139          * @param task the tested task.
140          */
141         public TestTaskListener( final Task task )
142         {
143             if ( task == null )
144             {
145                 throw new NullPointerException( "task" );
146             }
147 
148             this.task = task;
149             this.reset();
150         }
151 
152         /**
153          * Gets the timestamp the tested task started.
154          *
155          * @return the timestamp the tested task started or {@code -1} if no
156          * corresponding event got fired.
157          */
158         public long getStartTime()
159         {
160             return this.startTime;
161         }
162 
163         /**
164          * Sets the timestamp the tested task ended.
165          *
166          * @return the timestamp the tested task ended or {@code -1} if no
167          * corresponding event got fired.
168          */
169         public long getEndTime()
170         {
171             return this.endTime;
172         }
173 
174         /**
175          * Flag indicating that corresponding events caused by the task
176          * changing its state were fired.
177          *
178          * @return {@code true} if corresponding event got fired indicating
179          * the task having changed state; {@code false} if no corresponding
180          * events got fired.
181          */
182         public boolean getChangedState()
183         {
184             return this.changedState;
185         }
186 
187         /** Resets the state of the listener. */
188         public void reset()
189         {
190             this.startTime = -1L;
191             this.endTime = -1L;
192             this.changedState = false;
193         }
194 
195         public void onTaskEvent( final TaskEvent taskEvent )
196         {
197             if ( taskEvent.getTask().equals( this.task ) )
198             {
199                 final int type = taskEvent.getType();
200                 if ( type == TaskEvent.STARTED )
201                 {
202                     assert this.startTime == -1;
203                     this.startTime = System.currentTimeMillis();
204                 }
205                 else if ( type == TaskEvent.ENDED )
206                 {
207                     assert this.endTime == -1;
208                     this.endTime = System.currentTimeMillis();
209                 }
210                 else if ( type == TaskEvent.CHANGED_STATE )
211                 {
212                     this.changedState = true;
213                 }
214                 else
215                 {
216                     throw new IllegalStateException( Integer.toString( type ) );
217                 }
218             }
219         }
220 
221     }
222 
223     //---------------------------------------------------------TaskMonitorTest--
224     //--Tests-------------------------------------------------------------------
225 
226     /**
227      * Tests the {@link TaskMonitor#monitor(Task)} and
228      * {@link TaskMonitor#finish(Task)} implementation to handle illegal
229      * arguments correctly by throwing a corresponding
230      * {@code NullPointerException}.
231      */
232     public void testIllegalArguments() throws Exception
233     {
234         assert this.getTaskMonitor() != null;
235 
236         try
237         {
238             this.getTaskMonitor().monitor( null );
239             throw new AssertionError();
240         }
241         catch ( final NullPointerException e )
242         {
243             Assert.assertNotNull( e.getMessage() );
244             System.out.println( e.toString() );
245         }
246 
247         try
248         {
249             this.getTaskMonitor().finish( null );
250             throw new AssertionError();
251         }
252         catch ( final NullPointerException e )
253         {
254             Assert.assertNotNull( e.getMessage() );
255             System.out.println( e.toString() );
256         }
257 
258 
259     }
260 
261     /**
262      * Tests the {@link TaskMonitor#monitor(Task)} and
263      * {@link TaskMonitor#finish(Task)} implementation to fire corresponding
264      * events during task monitoring.
265      */
266     public void testMonitoring() throws Exception
267     {
268         assert this.getTaskMonitor() != null;
269 
270         final Task task = new Task();
271         final TestTaskListener listener = new TestTaskListener( task );
272 
273         task.setDescription( new TestMessage() );
274 
275         this.getTaskEventSource().addTaskListener( listener );
276 
277         task.setIndeterminate( false );
278         task.setMinimum( 0 );
279         task.setMaximum( 10 );
280         task.setProgress( 0 );
281 
282         this.getTaskMonitor().monitor( task );
283 
284         for ( int i = 10; i > 0; i-- )
285         {
286             task.setProgress( i );
287             Thread.currentThread().sleep( 1000 );
288         }
289 
290         this.getTaskMonitor().finish( task );
291 
292         Assert.assertTrue( listener.getStartTime() > 0 );
293         Assert.assertTrue( listener.getEndTime() > 0 );
294         Assert.assertTrue( listener.getChangedState() );
295     }
296 
297     /**
298      * Tests the {@link TaskMonitor#monitor(Task)} and
299      * {@link TaskMonitor#finish(Task)} implementation to fire corresponding
300      * events during task monitoring for property {@code progressDescription}.
301      */
302     public void testProgressDescriptionMonitoring() throws Exception
303     {
304         assert this.getTaskMonitor() != null;
305 
306         final Task task = new Task();
307         final TestTaskListener listener = new TestTaskListener( task );
308         final TestMessage progressDescription = new TestMessage();
309 
310         task.setDescription( new TestMessage() );
311         task.setProgressDescription( progressDescription );
312 
313         this.getTaskEventSource().addTaskListener( listener );
314 
315         task.setIndeterminate( true );
316 
317         this.getTaskMonitor().monitor( task );
318 
319         for ( int i = 2; i > 0; i-- )
320         {
321             Thread.currentThread().sleep( 1000 );
322             progressDescription.setText( Integer.toString( i ) );
323         }
324 
325         this.getTaskMonitor().finish( task );
326 
327         Assert.assertTrue( listener.getStartTime() > 0 );
328         Assert.assertTrue( listener.getEndTime() > 0 );
329         Assert.assertTrue( listener.getChangedState() );
330     }
331 
332     /**
333      * Tests the {@link TaskMonitor#monitor(Task)} and
334      * {@link TaskMonitor#finish(Task)} implementation to fire corresponding
335      * events during task monitoring when an application updates property
336      * {@code cancelled}.
337      */
338     public void testCancelable() throws Exception
339     {
340         assert this.getTaskMonitor() != null;
341 
342         final Task task = new Task();
343         final TestTaskListener listener = new TestTaskListener( task );
344 
345         this.getTaskEventSource().addTaskListener( listener );
346 
347         task.setCancelable( true );
348         task.setDescription( new TestMessage() );
349 
350         this.getTaskMonitor().monitor( task );
351 
352         for ( int i = 10; i > 0; i-- )
353         {
354             if ( i == 10 )
355             {
356                 task.setCancelled( true );
357             }
358 
359             Thread.currentThread().sleep( 1000 );
360         }
361 
362         this.getTaskMonitor().finish( task );
363 
364         Assert.assertTrue( listener.getStartTime() > 0 );
365         Assert.assertTrue( listener.getEndTime() > 0 );
366         Assert.assertTrue( listener.getChangedState() );
367     }
368 
369     /**
370      * Tests the {@link TaskMonitor#monitor(Task)} and
371      * {@link TaskMonitor#finish(Task)} implementation to not throw any
372      * exceptions for parallel accessing tasks.
373      */
374     public void testSynchronization() throws Exception
375     {
376         final List threads = new LinkedList();
377         for ( int i = 10; i > 0; i-- )
378         {
379             final Thread thread = new Thread()
380             {
381 
382                 public void run()
383                 {
384                     try
385                     {
386                         final Task task = new Task();
387                         task.setIndeterminate( true );
388                         task.setDescription( new TestMessage() );
389 
390                         getTaskMonitor().monitor( task );
391                         for ( int j = 10; j > 0; j-- )
392                         {
393                             Thread.sleep( 1000 );
394                         }
395                         getTaskMonitor().finish( task );
396                     }
397                     catch ( final InterruptedException e )
398                     {
399                         throw new AssertionError( e );
400                     }
401                 }
402 
403             };
404 
405             threads.add( thread );
406             thread.start();
407         }
408 
409         for ( final Iterator it = threads.iterator(); it.hasNext();)
410         {
411             ( ( Thread ) it.next() ).join();
412         }
413     }
414 
415     //-------------------------------------------------------------------Tests--
416 }