1 

     2 /**

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

     4 * All rights reserved.

     5 * This component and the accompanying materials are made available

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

     7 * which accompanies this distribution, and is available

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

     9 *

    10 * Initial Contributors:

    11 * Nokia Corporation - initial contribution.

    12 *

    13 * Contributors:

    14 *

    15 * Description:   tester for methods in CVideoCollectionWrapperPrivate

    16 * 

    17 */

    18 

    19 

    20 // INCLUDES

    21 

    22 #include "testvideocollectionclient.h"

    23 #include "videocollectioncommon.h"

    24 #include "stubcollectionsignalreceiver.h"

    25 #include "videocollectionlistener.h"

    26 

    27 #define private public

    28 #include "videocollectionclient.h"

    29 #undef private

    30 

    31 

    32 

    33 Q_DECLARE_METATYPE(QList<int>)

    34 

    35 // -----------------------------------------------------------------------------

    36 // main

    37 // -----------------------------------------------------------------------------

    38 //

    39 int main(int argc, char *argv[])

    40 {

    41     TestVideoCollectionClient tv;

    42 

    43     int res;

    44     if(argc > 1)

    45     {   

    46         res = QTest::qExec(&tv, argc, argv);

    47     }

    48     else

    49     {

    50         char *pass[3];

    51         pass[0] = argv[0];

    52         pass[1] = "-o";

    53         pass[2] = "c:\\data\\testvideocollectionclient.txt";

    54         res = QTest::qExec(&tv, 3, pass);

    55     }

    56     

    57     return res;

    58 }

    59 

    60 Q_DECLARE_METATYPE(QList<TMPXItemId>) 

    61 

    62 // -----------------------------------------------------------------------------

    63 // init

    64 // -----------------------------------------------------------------------------

    65 //

    66 void TestVideoCollectionClient::init()

    67 {    

    68     mTestObject = new VideoCollectionClient();

    69     mSignalReceiver = new StubSignalReceiver();

    70 }

    71     

    72 // -----------------------------------------------------------------------------

    73 // cleanup

    74 // -----------------------------------------------------------------------------

    75 //

    76 void TestVideoCollectionClient::cleanup()

    77 {

    78     delete mTestObject;

    79     mTestObject = 0;

    80 }

    81 

    82 // -----------------------------------------------------------------------------

    83 // testInitializeCollUtilityExists

    84 // -----------------------------------------------------------------------------

    85 //

    86 void TestVideoCollectionClient::testInitializeCollUtilityExists()

    87 {

    88     MMPXCollectionUtility *tmpUtility = new MMPXCollectionUtility();

    89     mTestObject->mCollectionUtility = tmpUtility;

    90     QVERIFY(mTestObject->initialize(mSignalReceiver) == 0);

    91     QVERIFY(mTestObject->mCollectionUtility != 0);

    92     QVERIFY(mTestObject->mCollectionListener != 0);

    93 }

    94     

    95 // -----------------------------------------------------------------------------

    96 // testInitializeCollUtilityExists

    97 // -----------------------------------------------------------------------------

    98 //

    99 void TestVideoCollectionClient::testInitializeCollListenerExist()

   100 {

   101     VideoCollectionListener *tmpListener = new VideoCollectionListener(*mTestObject, *mSignalReceiver);

   102     mTestObject->mCollectionListener = tmpListener;

   103     QVERIFY(mTestObject->initialize(mSignalReceiver) == 0);    

   104     QVERIFY(mTestObject->mCollectionUtility != 0);

   105     QVERIFY(mTestObject->mCollectionListener != 0);

   106 }

   107     

   108 // -----------------------------------------------------------------------------

   109 // testInitializeCollUtilityExists

   110 // -----------------------------------------------------------------------------

   111 //

   112 void TestVideoCollectionClient::testInitializeUtilCreateFail()

   113 {

   114     MMPXCollectionUtility::setNewLLeave(true);

   115     QVERIFY(mTestObject->initialize(mSignalReceiver) < 0);  

   116     QVERIFY(mTestObject->mCollectionUtility == 0);

   117     QVERIFY(mTestObject->mCollectionListener == 0);

   118     MMPXCollectionUtility::setNewLLeave(false);

   119 }

   120 

   121 // -----------------------------------------------------------------------------

   122 // testInitializeNullReceiverCreateFail

   123 // -----------------------------------------------------------------------------

   124 //

   125 void TestVideoCollectionClient::testInitializeNullReceiverCreateFail()

   126 {

   127     QVERIFY(mTestObject->initialize(0) < 0);  

   128     QVERIFY(mTestObject->mCollectionUtility == 0);

   129     QVERIFY(mTestObject->mCollectionListener == 0);

   130 }

   131     

   132 // -----------------------------------------------------------------------------

   133 // testInitializeCollUtilityExists

   134 // -----------------------------------------------------------------------------

   135 //

   136 void TestVideoCollectionClient::testInitializeSucceed()

   137 {   

   138     MMPXCollectionUtility::setNewLLeave(false);

   139     QVERIFY(mTestObject->initialize(mSignalReceiver) == 0);  

   140     // none exists

   141     QVERIFY(mTestObject->initialize(mSignalReceiver) == 0);  

   142     QVERIFY(mTestObject->mCollectionUtility != 0);

   143     QVERIFY(mTestObject->mCollectionListener != 0);

   144     

   145     // both items exists

   146     QVERIFY(mTestObject->initialize(mSignalReceiver) == 0);  

   147     QVERIFY(mTestObject->mCollectionUtility != 0);

   148     QVERIFY(mTestObject->mCollectionListener != 0);

   149     

   150     MMPXCollectionUtility::resetCloseCounter();

   151     QPointer<VideoCollectionListener> listener = mTestObject->mCollectionListener;

   152     

   153     cleanup();

   154     

   155     QVERIFY(MMPXCollectionUtility::getCloseCounter() == 1);

   156     QVERIFY(listener == 0);   

   157 }

   158        

   159 // -----------------------------------------------------------------------------

   160 // testInitializeCollUtilityExists

   161 // -----------------------------------------------------------------------------

   162 //

   163 void TestVideoCollectionClient::testCollectionLevel()

   164 {

   165     // no collection utility

   166     QVERIFY(mTestObject->getCollectionLevel() == -1);

   167     

   168     QVERIFY(mTestObject->initialize(mSignalReceiver) == 0);  

   169     

   170     // path level not setted

   171     QVERIFY(mTestObject->getCollectionLevel() == -1);

   172 

   173     // succeeds

   174     mTestObject->mCollectionPathLevel = VideoCollectionCommon::ELevelCategory;

   175     QVERIFY(mTestObject->getCollectionLevel() == VideoCollectionCommon::ELevelCategory);

   176 }

   177     

   178 // -----------------------------------------------------------------------------

   179 // testInitializeCollUtilityExists

   180 // -----------------------------------------------------------------------------

   181 //

   182 void TestVideoCollectionClient::testGetOpenStatus()

   183 {

   184     QVERIFY(mTestObject->getOpenStatus() == VideoCollectionClient::ECollectionNotOpen);

   185     

   186     mTestObject->setOpenStatus(100);

   187     

   188     QVERIFY(mTestObject->getOpenStatus() == 100);  

   189 }

   190      

   191 // -----------------------------------------------------------------------------

   192 // testInitializeCollUtilityExists

   193 // -----------------------------------------------------------------------------

   194 //

   195 void TestVideoCollectionClient::testSetOpenStatus()

   196 {

   197     mTestObject->setOpenStatus(VideoCollectionClient::ECollectionNotOpen);

   198     QVERIFY(mTestObject->getOpenStatus() == VideoCollectionClient::ECollectionNotOpen);

   199     

   200     mTestObject->setOpenStatus(VideoCollectionClient::ECollectionOpened);

   201     QVERIFY(mTestObject->getOpenStatus() == VideoCollectionClient::ECollectionOpened);

   202     

   203     mTestObject->setOpenStatus(100);

   204     QVERIFY(mTestObject->getOpenStatus() == 100);

   205     

   206 }

   207     

   208 // -----------------------------------------------------------------------------

   209 // testInitializeCollUtilityExists

   210 // -----------------------------------------------------------------------------

   211 //

   212 void TestVideoCollectionClient::testStartOpenCollection()

   213 {

   214     // no collection utility    

   215     QVERIFY(mTestObject->startOpenCollection(VideoCollectionCommon::ELevelVideos) == -1);

   216 

   217     QVERIFY(mTestObject->startOpenCollection(VideoCollectionCommon::ELevelCategory) == -1);

   218 

   219     QVERIFY(mTestObject->initialize(mSignalReceiver) == 0); 

   220     // open status setted allready

   221     mTestObject->setOpenStatus(VideoCollectionClient::ECollectionOpening); 

   222     QVERIFY(mTestObject->startOpenCollection(VideoCollectionCommon::ELevelVideos) == 0);

   223     mTestObject->setOpenStatus(VideoCollectionClient::ECollectionOpened);

   224     QVERIFY(mTestObject->startOpenCollection(VideoCollectionCommon::ELevelVideos) == 0);

   225 

   226     mTestObject->setOpenStatus(VideoCollectionClient::ECollectionOpening); 

   227     QVERIFY(mTestObject->startOpenCollection(VideoCollectionCommon::ELevelCategory) == 0);

   228     mTestObject->setOpenStatus(VideoCollectionClient::ECollectionOpened);

   229     QVERIFY(mTestObject->startOpenCollection(VideoCollectionCommon::ELevelCategory) == 0);

   230     

   231     // open status and level setted allready

   232     mTestObject->setOpenStatus(VideoCollectionClient::ECollectionOpening); 

   233     mTestObject->mCollectionPathLevel = VideoCollectionCommon::ELevelVideos;

   234     QVERIFY(mTestObject->startOpenCollection(VideoCollectionCommon::ELevelVideos) == 0);

   235     mTestObject->setOpenStatus(VideoCollectionClient::ECollectionOpened);

   236     QVERIFY(mTestObject->startOpenCollection(VideoCollectionCommon::ELevelVideos) == 0);

   237 

   238     mTestObject->mCollectionPathLevel = VideoCollectionCommon::ELevelCategory;

   239     mTestObject->setOpenStatus(VideoCollectionClient::ECollectionOpening); 

   240     QVERIFY(mTestObject->startOpenCollection(VideoCollectionCommon::ELevelCategory) == 0);

   241     mTestObject->setOpenStatus(VideoCollectionClient::ECollectionOpened);

   242     QVERIFY(mTestObject->startOpenCollection(VideoCollectionCommon::ELevelCategory) == 0);

   243 

   244     mTestObject->setOpenStatus(VideoCollectionClient::ECollectionNotOpen); 

   245     

   246     // startOpenCollectionL -leaves

   247     MMPXCollection::setOpenLPathLeave(true);

   248     QVERIFY(mTestObject->startOpenCollection(VideoCollectionCommon::ELevelVideos) < 0);

   249 

   250     QVERIFY(mTestObject->startOpenCollection(VideoCollectionCommon::ELevelCategory) < 0);

   251 

   252     MMPXCollection::setOpenLPathLeave(false);

   253     QVERIFY(mTestObject->startOpenCollection(VideoCollectionCommon::ELevelVideos) == 0);

   254     QVERIFY(mTestObject->getOpenStatus() == VideoCollectionClient::ECollectionOpening);

   255     TMPXItemId categoryId;

   256     mTestObject->getCategoryId(categoryId);

   257     QVERIFY(categoryId.iId1 == KVcxMvcCategoryIdAll);

   258     QVERIFY(categoryId.iId2 == 1);

   259 

   260     mTestObject->setOpenStatus(VideoCollectionClient::ECollectionOpened);  

   261     QVERIFY(mTestObject->startOpenCollection(VideoCollectionCommon::ELevelCategory) == 0);

   262     QVERIFY(mTestObject->getOpenStatus() == VideoCollectionClient::ECollectionOpening);

   263     mTestObject->getCategoryId(categoryId);

   264     QVERIFY(categoryId == TMPXItemId::InvalidId());

   265 

   266     mTestObject->setOpenStatus(VideoCollectionClient::ECollectionOpened);  

   267     QVERIFY(mTestObject->startOpenCollection(VideoCollectionCommon::ELevelVideos) == 0);

   268     QVERIFY(mTestObject->getOpenStatus() == VideoCollectionClient::ECollectionOpening);

   269 

   270 }

   271 

   272 // -----------------------------------------------------------------------------

   273 // testStartOpenCurrentState

   274 // -----------------------------------------------------------------------------

   275 //

   276 void TestVideoCollectionClient::testStartOpenCurrentState()

   277 {

   278     // no collection utility

   279     QVERIFY(mTestObject->startOpenCurrentState() == -1);    

   280     mTestObject->setOpenStatus(VideoCollectionClient::ECollectionNotOpen);

   281     QVERIFY(mTestObject->startOpenCurrentState() == -1);  

   282     

   283     // collection not opened

   284     QVERIFY(mTestObject->initialize(mSignalReceiver) == 0); 

   285     QVERIFY(mTestObject->startOpenCurrentState() == -1); 

   286     

   287     // OpenL -leaves

   288     mTestObject->setOpenStatus(VideoCollectionClient::ECollectionOpened);

   289     MMPXCollection::setOpenLLeave(true);

   290     QVERIFY(mTestObject->startOpenCurrentState() < 0); 

   291    

   292     // succeed

   293     MMPXCollection::setOpenLLeave(false);

   294     QVERIFY(mTestObject->startOpenCurrentState() == 0); 

   295     

   296 }

   297 

   298 // -----------------------------------------------------------------------------

   299 // testDeleteVideos

   300 // -----------------------------------------------------------------------------

   301 //

   302 void TestVideoCollectionClient::testDeleteVideos()

   303 {

   304     // no collection utility

   305     QVERIFY(mTestObject->deleteVideos(0) == -1);       

   306     QList<TMPXItemId> ids;

   307     QVERIFY(mTestObject->deleteVideos(&ids) == -1); 

   308     

   309     QVERIFY(mTestObject->initialize(mSignalReceiver) == 0); 

   310     // empty list

   311     QVERIFY(mTestObject->deleteVideos(&ids) < 0); 

   312     

   313     // one item

   314     ids.append(TMPXItemId(1,0));

   315     MMPXCollection::setCommandLLeave(true);

   316     QVERIFY(mTestObject->deleteVideos(&ids) < 0); 

   317     MMPXCollection::setCommandLLeave(false);

   318     QVERIFY(mTestObject->deleteVideos(&ids) == 0);

   319     

   320     // more than one

   321     ids.append(TMPXItemId(2,0));

   322     ids.append(TMPXItemId(3,0));

   323     MMPXCollection::setCommandLLeave(true);

   324     QVERIFY(mTestObject->deleteVideos(&ids) < 0); 

   325     MMPXCollection::setCommandLLeave(false);

   326     QVERIFY(mTestObject->deleteVideos(&ids) == 0);

   327 

   328 }

   329  

   330 // -----------------------------------------------------------------------------

   331 // testOpenCategory

   332 // -----------------------------------------------------------------------------

   333 //

   334 void TestVideoCollectionClient::testOpenCategory()

   335 {

   336     TMPXItemId id(0,0);

   337     // no collection utility    

   338     QVERIFY(mTestObject->openItem(id) == -1);  

   339     

   340     // collection exists

   341     QVERIFY(mTestObject->initialize(mSignalReceiver) == 0); 

   342       

   343     MMPXCollection::setOpenLPathLeave(true);

   344     QVERIFY(mTestObject->openItem(id)< 0);

   345     

   346     MMPXCollection::setOpenLPathLeave(false);

   347 

   348     

   349     mTestObject->mCollectionPathLevel = VideoCollectionCommon::ELevelCategory;

   350     QVERIFY(mTestObject->openItem(id) == 0);

   351       

   352 }

   353 

   354 // -----------------------------------------------------------------------------

   355 // testOpenVideo

   356 // -----------------------------------------------------------------------------

   357 //

   358 void TestVideoCollectionClient::testOpenVideo()

   359 {

   360     TMPXItemId id(0,0);

   361     // no collection utility    

   362     QVERIFY(mTestObject->openItem(id) == -1);  

   363     

   364     // collection exists: media type KVcxMvcMediaTypeVideo

   365     QVERIFY(mTestObject->initialize(mSignalReceiver) == 0); 

   366     MMPXCollection::setOpenLPathLeave(true);

   367     QVERIFY(mTestObject->openItem(id)< 0);

   368     MMPXCollection::setOpenLPathLeave(false);    

   369     QVERIFY(mTestObject->openItem(id) == 0);

   370     

   371     // collection exists: media type !=  KVcxMvcMediaTypeVideo

   372     id.iId2 = 2;

   373     MMPXCollection::setOpenLPathLeave(true);

   374     QVERIFY(mTestObject->openItem(id)< 0);

   375     MMPXCollection::setOpenLPathLeave(false);    

   376     QVERIFY(mTestObject->openItem(id) == 0);

   377 }

   378 

   379 // -----------------------------------------------------------------------------

   380 // testFetchMpxMediaByMpxId

   381 // -----------------------------------------------------------------------------

   382 //

   383 void TestVideoCollectionClient::testFetchMpxMediaByMpxId()

   384 {

   385     // no collection utility 

   386     TMPXItemId id;

   387     QVERIFY(mTestObject->fetchMpxMediaByMpxId(id) == -1); 

   388     

   389     // collection exists

   390     QVERIFY(mTestObject->initialize(mSignalReceiver) == 0); 

   391     

   392     MMPXCollection::setCommandLLeave(true);

   393     QVERIFY(mTestObject->fetchMpxMediaByMpxId(id) < 0);

   394     

   395     MMPXCollection::setCommandLLeave(false);

   396     QVERIFY(mTestObject->fetchMpxMediaByMpxId(id) == 0);

   397     

   398 }

   399 

   400 // -----------------------------------------------------------------------------

   401 // testGetVideoDetails

   402 // -----------------------------------------------------------------------------

   403 //

   404 void TestVideoCollectionClient::testGetVideoDetails()

   405 {

   406     // no collection utility 

   407     TMPXItemId id(0,0); 

   408     QVERIFY(mTestObject->getVideoDetails(id) == -1); 

   409     

   410     // collection exists

   411     QVERIFY(mTestObject->initialize(mSignalReceiver) == 0); 

   412     

   413     MMPXCollection::setCommandLLeave(true);

   414     QVERIFY(mTestObject->getVideoDetails(id) < 0);

   415     

   416     MMPXCollection::setCommandLLeave(false);

   417     QVERIFY(mTestObject->getVideoDetails(id) == 0);

   418     

   419 }

   420 

   421 // -----------------------------------------------------------------------------

   422 // testRemoveAlbums

   423 // -----------------------------------------------------------------------------

   424 //

   425 void TestVideoCollectionClient::testRemoveAlbums()

   426 {

   427     TMPXItemId id(1,1); 

   428     QList<TMPXItemId> albums;

   429     

   430     // no collectionutility

   431     QVERIFY(mTestObject->removeAlbums(albums) == -1); 

   432     

   433     // collection exists

   434     QVERIFY(mTestObject->initialize(mSignalReceiver) == 0); 

   435     

   436     // command leaves, no items

   437     MMPXCollection::setCommandLLeave(true);

   438     QVERIFY(mTestObject->removeAlbums(albums) < 0); 

   439     

   440     // command leaves items exists

   441     albums.append(TMPXItemId(1,2));

   442     albums.append(TMPXItemId(1,2));

   443     QVERIFY(mTestObject->removeAlbums(albums) < 0); 

   444     

   445     // command does not leave, no items

   446     albums.clear();

   447     MMPXCollection::setCommandLLeave(false);

   448     QVERIFY(mTestObject->removeAlbums(albums) < 0);

   449     

   450     // command does not leave, items exist, both albums and non abums

   451     albums.append(TMPXItemId(1,2));

   452     albums.append(TMPXItemId(2,0));

   453     albums.append(TMPXItemId(2,2));

   454     QVERIFY(mTestObject->removeAlbums(albums) == 0); 

   455     

   456     // command does not leave, items exist, only non abums

   457     albums.clear();

   458     albums.append(TMPXItemId(1,0));

   459     albums.append(TMPXItemId(2,0));

   460     albums.append(TMPXItemId(3,0));

   461     QVERIFY(mTestObject->removeAlbums(albums) < 0); 

   462     

   463 }

   464 

   465 // -----------------------------------------------------------------------------

   466 // testAddNewCollection

   467 // -----------------------------------------------------------------------------

   468 //

   469 void TestVideoCollectionClient::testAddNewCollection()

   470 {

   471     QString name("");

   472     // no collection utility

   473     TMPXItemId id = TMPXItemId(1,1);

   474     id = mTestObject->addNewAlbum(name);

   475     QVERIFY(id == TMPXItemId::InvalidId());

   476     id = TMPXItemId(1,1);

   477     

   478     // empty title

   479     mTestObject->initialize(mSignalReceiver);    

   480     id = mTestObject->addNewAlbum(name);

   481     QVERIFY(id == TMPXItemId::InvalidId());

   482     id = TMPXItemId(1,1);

   483     name = "TestAlbum";

   484     

   485     // cmd not supported

   486     CMPXMedia::mIsSupported = false;

   487     id = mTestObject->addNewAlbum(name);

   488     QVERIFY(id == TMPXItemId::InvalidId());

   489     CMPXMedia::mIsSupported = true;

   490     id = TMPXItemId(1,1);

   491     

   492     // id getting leaves

   493     CMPXMedia::mValueTObjectLeaves = true; 

   494     id = mTestObject->addNewAlbum(name);

   495     QVERIFY(id == TMPXItemId::InvalidId());

   496     CMPXMedia::mValueTObjectLeaves = false;

   497     id = TMPXItemId(1,1); 

   498     

   499     // succeed

   500     CMPXMedia::mIdFromValueTObject = id;

   501     id = TMPXItemId::InvalidId();

   502     id = mTestObject->addNewAlbum(name);

   503     QVERIFY(id == CMPXMedia::mIdFromValueTObject);

   504 }

   505 

   506 

   507 // -----------------------------------------------------------------------------

   508 // testAddItemsInAlbum

   509 // -----------------------------------------------------------------------------

   510 //

   511 void TestVideoCollectionClient::testAddItemsInAlbum()

   512 {

   513     TMPXItemId albumId = TMPXItemId(1,2);

   514     QList<TMPXItemId> mediaIds;

   515     

   516     // no collectionutility

   517     QVERIFY(mTestObject->addItemsInAlbum(albumId, mediaIds) < 0);

   518     

   519     albumId = TMPXItemId::InvalidId();

   520     mTestObject->initialize(mSignalReceiver);

   521     // invalid album id

   522     QVERIFY(mTestObject->addItemsInAlbum(albumId, mediaIds) < 0);

   523         

   524     albumId = TMPXItemId(1,0);

   525     // media type not album

   526     QVERIFY(mTestObject->addItemsInAlbum(albumId, mediaIds) < 0);

   527     

   528     // command leaves

   529     albumId = TMPXItemId(1,2);

   530     MMPXCollection::setCommandLLeave(true);

   531     QVERIFY(mTestObject->addItemsInAlbum(albumId, mediaIds) < 0);

   532     MMPXCollection::setCommandLLeave(false);

   533     

   534     // empty list

   535     QVERIFY(mTestObject->addItemsInAlbum(albumId, mediaIds) < 0);

   536     

   537     mediaIds.append(TMPXItemId(1,0));

   538     mediaIds.append(TMPXItemId(2,2));

   539     mediaIds.append(TMPXItemId(2,0));

   540     // list contains items, both videos and non-videos

   541     QVERIFY(mTestObject->addItemsInAlbum(albumId, mediaIds) == 0);

   542     

   543     // list contains only non-videos

   544     mediaIds.clear();

   545     mediaIds.append(TMPXItemId(1,2));

   546     mediaIds.append(TMPXItemId(2,2));

   547     mediaIds.append(TMPXItemId(2,1));

   548        

   549    QVERIFY(mTestObject->addItemsInAlbum(albumId, mediaIds) < 0);

   550    

   551 }

   552 

   553 // -----------------------------------------------------------------------------

   554 // testRemoveItemsFromAlbum

   555 // -----------------------------------------------------------------------------

   556 //

   557 void TestVideoCollectionClient::testRemoveItemsFromAlbum()

   558 {

   559     TMPXItemId albumId = TMPXItemId(1,2);

   560     QList<TMPXItemId> mediaIds;

   561     

   562     // no collectionutility

   563     QVERIFY(mTestObject->removeItemsFromAlbum(albumId, mediaIds) < 0);

   564     

   565     albumId = TMPXItemId::InvalidId();

   566     mTestObject->initialize(mSignalReceiver);

   567     // invalid album id

   568     QVERIFY(mTestObject->removeItemsFromAlbum(albumId, mediaIds) < 0);

   569        

   570     albumId = TMPXItemId(1,0);

   571     // media type not album

   572     QVERIFY(mTestObject->removeItemsFromAlbum(albumId, mediaIds) < 0);

   573     

   574     // command leaves

   575     albumId = TMPXItemId(1,2);

   576     MMPXCollection::setCommandLLeave(true);

   577     QVERIFY(mTestObject->removeItemsFromAlbum(albumId, mediaIds) < 0);

   578     MMPXCollection::setCommandLLeave(false);

   579     

   580     // empty list

   581     QVERIFY(mTestObject->removeItemsFromAlbum(albumId, mediaIds) < 0);

   582     

   583     mediaIds.append(TMPXItemId(1,0));

   584     mediaIds.append(TMPXItemId(2,2));

   585     mediaIds.append(TMPXItemId(2,0));

   586     

   587     // list contains items, both videos and non-videos

   588     QVERIFY(mTestObject->removeItemsFromAlbum(albumId, mediaIds) == 0);

   589     

   590     // list contains only non-videos

   591     mediaIds.clear();

   592     mediaIds.append(TMPXItemId(1,2));

   593     mediaIds.append(TMPXItemId(2,2));

   594     mediaIds.append(TMPXItemId(2,1));

   595     

   596     QVERIFY(mTestObject->removeItemsFromAlbum(albumId, mediaIds) < 0);    

   597 }

   598 

   599 // -----------------------------------------------------------------------------

   600 // testRenameItem

   601 // -----------------------------------------------------------------------------

   602 //

   603 void TestVideoCollectionClient::testRenameItem()

   604 {

   605     MMPXCollection::setCommandLLeave(false);

   606     

   607     QString title = "test";

   608     TMPXItemId itemId = TMPXItemId(1, 2);

   609     

   610     // no collectionutility

   611     QVERIFY(mTestObject->renameItem(itemId, title) < 0);

   612     

   613     mTestObject->initialize(mSignalReceiver);

   614     

   615     // invalid album id

   616     itemId = TMPXItemId::InvalidId();

   617     QVERIFY(mTestObject->renameItem(itemId, title) < 0);

   618     

   619     // empty title

   620     title = "";

   621     QVERIFY(mTestObject->renameItem(itemId, title) < 0);

   622     

   623     // video id

   624     title = "test";

   625     itemId = TMPXItemId(0, 0);

   626     QVERIFY(mTestObject->renameItem(itemId, title) == 0);

   627 

   628     // category id

   629     itemId = TMPXItemId(0, 1);

   630     QVERIFY(mTestObject->renameItem(itemId, title) < 0);

   631     

   632     // good case

   633     itemId = TMPXItemId(0, 2);

   634     QVERIFY(mTestObject->renameItem(itemId, title) == 0);

   635     

   636     // command leaves

   637     itemId = TMPXItemId(1, 2);

   638     MMPXCollection::setCommandLLeave(true);

   639     QVERIFY(mTestObject->renameItem(itemId, title) < 0);

   640     MMPXCollection::setCommandLLeave(false);

   641 }

   642 

   643 // -----------------------------------------------------------------------------

   644 // testBack

   645 // -----------------------------------------------------------------------------

   646 //

   647 void TestVideoCollectionClient::testBack()

   648 {

   649     MMPXCollection::setCommandLLeave(false);

   650     

   651     CMPXCollectionPath::setLevel(3);

   652     // not initialized    

   653     QVERIFY(mTestObject->back() == -1);  

   654     

   655     QVERIFY(mTestObject->initialize(mSignalReceiver) == 0); 

   656     mTestObject->mCollectionPathLevel = VideoCollectionCommon::ELevelVideos;   

   657     MMPXCollection::setBackLLeave(true);

   658     QVERIFY(mTestObject->back()< 0);

   659     MMPXCollection::setBackLLeave(false);

   660     QVERIFY(mTestObject->back() == 0); 

   661     

   662     mTestObject->mCollectionPathLevel = VideoCollectionCommon::ELevelCategory;

   663     QVERIFY(mTestObject->back() == 0); 

   664 }

   665 

   666 // End of file

   667