1 /**

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  stub classes for testing CVideoCollectionClient

    15 * 

    16 */

    17 

    18 #ifndef __STUBCOLLECTIONSIGNALRECEIVER_H

    19 #define __STUBCOLLECTIONSIGNALRECEIVER_H

    20 

    21 #include <QObject>

    22 // INCLUDES

    23 #include "videodatasignalreceiver.h"

    24 #include "stub/inc/videocollectionlistener.h"

    25 #include "videocollectionclient.h"

    26 

    27 /**

    28  * implementation class for slots to be connected

    29  */

    30 class  StubSignalReceiver  : public VideoDataSignalReceiver

    31 {

    32 

    33     Q_OBJECT

    34     

    35     Q_DISABLE_COPY(StubSignalReceiver)

    36     

    37 public:

    38     

    39     /**

    40      * contructor

    41      */

    42     StubSignalReceiver();

    43     

    44     /**

    45      * destructor

    46      */

    47     virtual ~StubSignalReceiver();

    48     

    49 public slots:   

    50     

    51     /**

    52      * No implementation needed for these tests

    53      */

    54     void newVideoListSlot(CMPXMediaArray *array);

    55     

    56     /**

    57      * No implementation needed for these tests

    58      */

    59     void appendVideoListSlot( CMPXMediaArray* videoList );

    60           

    61     /**

    62      * No implementation needed for these tests

    63      */

    64     void newVideoAvailableSlot(CMPXMedia *media);

    65     

    66     /**

    67      * No implementation needed for these tests

    68      */

    69     void videoDeletedSlot(TMPXItemId id);

    70            

    71     /**

    72      * No implementation needed for these tests

    73      */

    74     void videoDeleteCompletedSlot(int, QList<TMPXItemId> *failedIds);

    75     

    76     /**

    77      * No implementation needed for these tests

    78      */

    79     void videoDetailsCompletedSlot(TMPXItemId id);

    80  

    81 };

    82 

    83 /**

    84  * Class for testing signal connections, all signals exists

    85  */

    86 class StubListenerAllSignals : public VideoCollectionListener

    87 {

    88     Q_OBJECT

    89     

    90 public:

    91     /**

    92      * contructor

    93      */

    94     StubListenerAllSignals(VideoCollectionClient &collectionClient); 

    95 signals:

    96 

    97     /**

    98      * stub signal definition, not used

    99      */

   100     void newVideoList(CMPXMediaArray*);

   101     

   102     /**

   103      * stub signal definition, not used

   104      */

   105     void videoListAppended(CMPXMediaArray*);

   106               

   107     /**

   108      * stub signal definition, not used

   109      */

   110     void newVideoAvailable(CMPXMedia*);

   111         

   112     /**

   113      * stub signal definition, not used

   114      */

   115     void videoDeleted(TMPXItemId videoId);

   116                

   117     /**

   118      * stub signal definition, not used

   119      */

   120     void videoDeleteCompleted(int, QList<TMPXItemId>*);

   121         

   122     /**

   123      * stub signal definition, not used

   124      */

   125     void videoDetailsCompleted(TMPXItemId videoId);

   126 };

   127 

   128 

   129 /**

   130  * Class for testing signal connections, no expected newVideoList -signal

   131  */

   132 class StubListenerNoNewVideoList : public VideoCollectionListener

   133 {

   134     Q_OBJECT

   135     

   136 public:

   137     /**

   138      * contructor

   139      */

   140     StubListenerNoNewVideoList(VideoCollectionClient &collectionClient);  

   141 signals:

   142     

   143     /**

   144      * stub signal definition, not used

   145      */

   146     void videoListAppended(CMPXMediaArray*);

   147     

   148     /**

   149      * stub signal definition, not used

   150      */

   151     void newVideoAvailable(CMPXMedia*);

   152         

   153     /**

   154      * stub signal definition, not used

   155      */

   156     void videoDeleted(TMPXItemId videoId);

   157                

   158     /**

   159      * stub signal definition, not used

   160      */

   161     void videoDeleteCompleted(int, QList<TMPXItemId>*);

   162         

   163     /**

   164      * stub signal definition, not used

   165      */

   166     void videoDetailsCompleted(TMPXItemId videoId);

   167 };

   168 

   169 /**

   170  * Class for testing signal connections, no expected videoListAppended -signal

   171  */

   172 class StubListenerNoVideoListAppended : public VideoCollectionListener

   173 {   

   174     Q_OBJECT

   175     

   176 public:

   177     /**

   178      * contructor

   179      */

   180     StubListenerNoVideoListAppended(VideoCollectionClient &collectionClient);  

   181 signals:

   182 

   183     /**

   184      * stub signal definition, not used

   185      */

   186     void newVideoList(CMPXMediaArray*);

   187     

   188     /**

   189      * stub signal definition, not used

   190      */

   191     void newVideoAvailable(CMPXMedia*);

   192     

   193     /**

   194      * stub signal definition, not used

   195      */

   196     void videoDeleted(TMPXItemId videoId);

   197                

   198     /**

   199      * stub signal definition, not used

   200      */

   201     void videoDeleteCompleted(int, QList<TMPXItemId>*);

   202         

   203     /**

   204      * stub signal definition, not used

   205      */

   206     void videoDetailsCompleted(TMPXItemId videoId);

   207 };

   208 

   209 

   210 

   211 /**

   212  * Class for testing signal connections, no expected newVideoAvailable -signal

   213  */

   214 class StubListenerNoNewVideoAvailable : public VideoCollectionListener

   215 {   

   216     Q_OBJECT

   217     

   218 public:

   219     /**

   220      * contructor

   221      */

   222     StubListenerNoNewVideoAvailable(VideoCollectionClient &collectionClient);  

   223 signals:

   224 

   225     /**

   226      * stub signal definition, not used

   227      */

   228     void newVideoList(CMPXMediaArray*);

   229     

   230     /**

   231      * stub signal definition, not used

   232      */

   233     void videoListAppended(CMPXMediaArray*);

   234         

   235     /**

   236      * stub signal definition, not used

   237      */

   238     void videoDeleted(TMPXItemId videoId);

   239                

   240     /**

   241      * stub signal definition, not used

   242      */

   243     void videoDeleteCompleted(int, QList<TMPXItemId>*);

   244         

   245     /**

   246      * stub signal definition, not used

   247      */

   248     void videoDetailsCompleted(TMPXItemId videoId);

   249 };

   250 

   251 /**

   252  * Class for testing signal connections, no expected videoDeleted -signal

   253  */

   254 class StubListenerNoVideoDeleted : public VideoCollectionListener

   255 {   

   256     Q_OBJECT

   257     

   258 public:

   259     /**

   260      * contructor

   261      */ 

   262     StubListenerNoVideoDeleted(VideoCollectionClient &collectionClient); 

   263 signals:

   264 

   265     /**

   266      * stub signal definition, not used

   267      */

   268     void newVideoList(CMPXMediaArray*);

   269     

   270     /**

   271      * stub signal definition, not used

   272      */

   273     void videoListAppended(CMPXMediaArray*);

   274                

   275     /**

   276      * stub signal definition, not used

   277      */

   278     void newVideoAvailable(CMPXMedia*);

   279                

   280     /**

   281      * stub signal definition, not used

   282      */

   283     void videoDeleteCompleted(int, QList<TMPXItemId>*);

   284         

   285     /**

   286      * stub signal definition, not used

   287      */

   288     void videoDetailsCompleted(TMPXItemId videoId);

   289 };

   290 

   291 /**

   292  * Class for testing signal connections, no expected videoDeleteCompleted -signal

   293  */

   294 class StubListenerNoVideoDeleteCompleted : public VideoCollectionListener

   295 {

   296     Q_OBJECT

   297     

   298 public:

   299     /**

   300      * contructor

   301      */

   302     StubListenerNoVideoDeleteCompleted(VideoCollectionClient &collectionClient);         

   303 signals:

   304 

   305     /**

   306      * stub signal definition, not used

   307      */

   308     void newVideoList(CMPXMediaArray*);

   309     

   310     /**

   311      * stub signal definition, not used

   312      */

   313     void videoListAppended(CMPXMediaArray*);

   314                

   315     /**

   316      * stub signal definition, not used

   317      */

   318     void newVideoAvailable(CMPXMedia*);

   319         

   320     /**

   321      * stub signal definition, not used

   322      */

   323     void videoDeleted(TMPXItemId videoId);

   324         

   325     /**

   326      * stub signal definition, not used

   327      */

   328     void videoDetailsCompleted(TMPXItemId videoId);

   329 };

   330 

   331 /**

   332  * Class for testing signal connections, no expected videoDetailsCompleted -signal

   333  */

   334 class StubListenerNoVideoDetailsCompleted : public VideoCollectionListener

   335 {

   336     Q_OBJECT

   337     

   338 public:

   339     /**

   340      * contructor

   341      */

   342     StubListenerNoVideoDetailsCompleted(VideoCollectionClient &collectionClient);   

   343       

   344 signals:

   345 

   346     /**

   347      * stub signal definition, not used

   348      */

   349     void newVideoList(CMPXMediaArray*);

   350     

   351     /**

   352      * stub signal definition, not used

   353      */

   354     void videoListAppended(CMPXMediaArray*);

   355                

   356     /**

   357      * stub signal definition, not used

   358      */

   359     void newVideoAvailable(CMPXMedia*);

   360         

   361     /**

   362      * stub signal definition, not used

   363      */

   364     void videoDeleted(TMPXItemId videoId);

   365                

   366     /**

   367      * stub signal definition, not used

   368      */

   369     void videoDeleteCompleted(int, QList<TMPXItemId>*);

   370         

   371 };

   372 

   373 #endif