EMMA Coverage Report (generated Wed Oct 03 04:37:30 CEST 2012)
[all classes][org.jdtaus.core.monitor.spi.it]

COVERAGE SUMMARY FOR SOURCE FILE [TaskMonitorTest.java]

nameclass, %method, %block, %line, %
TaskMonitorTest.java0%   (0/4)0%   (0/23)0%   (0/521)0%   (0/121)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class TaskMonitorTest0%   (0/1)0%   (0/10)0%   (0/345)0%   (0/78)
<static initializer> 0%   (0/1)0%   (0/15)0%   (0/1)
TaskMonitorTest (): void 0%   (0/1)0%   (0/3)0%   (0/2)
getTaskEventSource (): TaskEventSource 0%   (0/1)0%   (0/3)0%   (0/1)
getTaskMonitor (): TaskMonitor 0%   (0/1)0%   (0/3)0%   (0/1)
setTaskMonitor (TaskMonitor): void 0%   (0/1)0%   (0/7)0%   (0/3)
testCancelable (): void 0%   (0/1)0%   (0/76)0%   (0/16)
testIllegalArguments (): void 0%   (0/1)0%   (0/42)0%   (0/12)
testMonitoring (): void 0%   (0/1)0%   (0/82)0%   (0/18)
testProgressDescriptionMonitoring (): void 0%   (0/1)0%   (0/81)0%   (0/17)
testSynchronization (): void 0%   (0/1)0%   (0/33)0%   (0/8)
     
class TaskMonitorTest$10%   (0/1)0%   (0/2)0%   (0/44)0%   (0/12)
TaskMonitorTest$1 (TaskMonitorTest): void 0%   (0/1)0%   (0/6)0%   (0/1)
run (): void 0%   (0/1)0%   (0/38)0%   (0/11)
     
class TaskMonitorTest$TestMessage0%   (0/1)0%   (0/4)0%   (0/24)0%   (0/6)
TaskMonitorTest$TestMessage (): void 0%   (0/1)0%   (0/14)0%   (0/2)
getFormatArguments (Locale): Object [] 0%   (0/1)0%   (0/3)0%   (0/1)
getText (Locale): String 0%   (0/1)0%   (0/3)0%   (0/1)
setText (String): void 0%   (0/1)0%   (0/4)0%   (0/2)
     
class TaskMonitorTest$TestTaskListener0%   (0/1)0%   (0/7)0%   (0/108)0%   (0/26)
<static initializer> 0%   (0/1)0%   (0/15)0%   (0/1)
TaskMonitorTest$TestTaskListener (Task): void 0%   (0/1)0%   (0/15)0%   (0/6)
getChangedState (): boolean 0%   (0/1)0%   (0/3)0%   (0/1)
getEndTime (): long 0%   (0/1)0%   (0/3)0%   (0/1)
getStartTime (): long 0%   (0/1)0%   (0/3)0%   (0/1)
onTaskEvent (TaskEvent): void 0%   (0/1)0%   (0/59)0%   (0/12)
reset (): void 0%   (0/1)0%   (0/10)0%   (0/4)

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 */
21package org.jdtaus.core.monitor.spi.it;
22 
23import java.util.Iterator;
24import java.util.LinkedList;
25import java.util.List;
26import java.util.Locale;
27import junit.framework.Assert;
28import org.jdtaus.core.monitor.TaskEvent;
29import org.jdtaus.core.monitor.TaskEventSource;
30import org.jdtaus.core.monitor.TaskListener;
31import org.jdtaus.core.monitor.it.TaskEventSourceTest;
32import org.jdtaus.core.monitor.spi.Task;
33import org.jdtaus.core.monitor.spi.TaskMonitor;
34import 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 */
42public 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}

[all classes][org.jdtaus.core.monitor.spi.it]
EMMA 2.1.5320 (stable) (C) Vladimir Roubtsov