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: 

    15 *

    16 */

    17 

    18 // INCLUDES

    19 

    20 #include "testvideodatacontainer.h"

    21 #include "mediaobjectfactory.h"

    22 #include "videocollectionutils.h"

    23 #include <mpxmedia.h>

    24 #include <mpxmediageneraldefs.h>

    25 #include <qhash.h>

    26 

    27 

    28 #define private public

    29 #include "videodatacontainer.h"

    30 #undef private

    31 

    32 const int MEDIA_COUNT = 10;

    33 

    34 /**

    35  * global qHash function required fo creating hash values for TMPXItemId -keys

    36  */

    37 inline uint qHash(TMPXItemId key) 

    38 { 

    39     QPair<uint, uint> keyPair(key.iId1, key.iId2); 

    40 

    41     return qHash(keyPair);

    42 }

    43 

    44 // -----------------------------------------------------------------------------

    45 // main

    46 // -----------------------------------------------------------------------------

    47 //

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

    49 {

    50     Q_UNUSED(argc);

    51     

    52     TestVideoDataContainer tv;

    53 

    54     int res;

    55     if(argc > 1)

    56     {   

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

    58     }

    59     else

    60     {

    61         char *pass[3];

    62         pass[0] = argv[0];

    63         pass[1] = "-o";

    64         pass[2] = "c:\\data\\testvideodatacontainer.txt";

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

    66     }

    67 

    68     return res;

    69 }

    70 

    71 // -----------------------------------------------------------------------------

    72 // initTestCase

    73 // -----------------------------------------------------------------------------

    74 //

    75 void TestVideoDataContainer::initTestCase()

    76 {

    77     mTestObject = 0;

    78     mMediaFactory = new MediaObjectFactory();    

    79 }

    80 

    81 // -----------------------------------------------------------------------------

    82 // cleanupTestCase

    83 // -----------------------------------------------------------------------------

    84 //

    85 void TestVideoDataContainer::cleanupTestCase()

    86 {

    87     delete mMediaFactory;

    88 }

    89 

    90 // -----------------------------------------------------------------------------

    91 // init

    92 // -----------------------------------------------------------------------------

    93 //

    94 void TestVideoDataContainer::init()

    95 {

    96     mTestObject = new VideoDataContainer();

    97 }

    98  

    99 // -----------------------------------------------------------------------------

   100 // cleanup

   101 // -----------------------------------------------------------------------------

   102 //

   103 void TestVideoDataContainer::cleanup()

   104 {

   105     delete mTestObject;

   106 }

   107   

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

   109 // testClear

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

   111 //

   112 void TestVideoDataContainer::testClear()

   113 {

   114     User::Heap().__DbgMarkStart();

   115     QVERIFY(mTestObject->count() == 0);

   116     // add few items to container

   117     for(int i = 0; i < MEDIA_COUNT; ++i)

   118     {

   119         mTestObject->append(mMediaFactory->getMedia(i));

   120     }

   121     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   122     

   123     mTestObject->clear();

   124     QVERIFY(mTestObject->count() == 0);

   125     int remHeap = User::Heap().__DbgMarkEnd(0);

   126     QVERIFY(remHeap == 0);

   127     

   128     User::Heap().__DbgMarkStart();

   129     mTestObject->clear();

   130     remHeap = User::Heap().__DbgMarkEnd(0);

   131     QVERIFY(remHeap == 0);

   132     

   133 }

   134 

   135 // -----------------------------------------------------------------------------

   136 // testRemove

   137 // -----------------------------------------------------------------------------

   138 //

   139 void TestVideoDataContainer::testRemove()

   140 {

   141     // add few items to container (id = i, index = i)

   142     int i;

   143     for(i = 0; i < MEDIA_COUNT; ++i)

   144     {

   145         mTestObject->append(mMediaFactory->getMedia(i));

   146     }

   147     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   148     

   149     // invalid indexes

   150     mTestObject->remove(-1);

   151     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   152     mTestObject->remove(MEDIA_COUNT);

   153     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   154     

   155     QHash<TMPXItemId, QPair<int, CMPXMedia*> >::const_iterator iter;

   156     // at this point, indexes and ids are in sync

   157     for(i = 0; i < mTestObject->count(); ++i)

   158     {

   159         iter = mTestObject->mMediaData.find(mTestObject->mMediaIds[i]);

   160         QVERIFY(iter != mTestObject->mMediaData.constEnd());

   161         QVERIFY(iter.key().iId1 == i);

   162         QVERIFY(iter->first == i);        

   163     }

   164     

   165     // remove first item

   166     TMPXItemId id(0,0);

   167     mTestObject->remove(id);

   168     QVERIFY(mTestObject->count() == MEDIA_COUNT - 1);

   169     // at this point, indexes after recently removed first 

   170     // item have decreased by one (whereas ids increase by one)

   171     for(i = 0; i < mTestObject->count(); ++i)

   172     {

   173        iter = mTestObject->mMediaData.find(mTestObject->mMediaIds[i]);

   174        QVERIFY(iter != mTestObject->mMediaData.constEnd());

   175        QVERIFY(iter.key().iId1 == i + 1);

   176        QVERIFY(iter->first == i );

   177 

   178     }

   179     

   180     // reset 

   181     mTestObject->clear();

   182     // (id = i, index = i)

   183     for(int i = 0; i < MEDIA_COUNT; ++i)

   184     {

   185         mTestObject->append(mMediaFactory->getMedia(i));

   186     }

   187     

   188     // remove from the middle

   189     id.iId1 = MEDIA_COUNT / 2;

   190     mTestObject->remove(id);

   191     QVERIFY(mTestObject->count() == MEDIA_COUNT - 1);

   192     

   193     // at this point, indexes after recently removed middle 

   194     // item have decreased by one (whereas ids increase by one)

   195     for(i = 0; i < mTestObject->count(); ++i)

   196     {

   197        iter = mTestObject->mMediaData.find(mTestObject->mMediaIds[i]);  

   198        QVERIFY(iter != mTestObject->mMediaData.constEnd());

   199        if( i <  MEDIA_COUNT / 2)

   200        {    

   201            QVERIFY(iter.key().iId1 == i);

   202            QVERIFY(iter->first == i); 

   203        }

   204        else

   205        {

   206            QVERIFY(iter.key().iId1 == i + 1);

   207            QVERIFY(iter->first == i);

   208        }

   209     }

   210    

   211     

   212     // reset 

   213     mTestObject->clear();

   214     // (id = i, index = i)

   215     for(int i = 0; i < MEDIA_COUNT; ++i)

   216     {

   217         mTestObject->append(mMediaFactory->getMedia(i));

   218     }

   219     

   220     // remove from the end

   221     id.iId1 = MEDIA_COUNT - 1;

   222     mTestObject->remove(id);

   223     QVERIFY(mTestObject->count() == MEDIA_COUNT - 1);

   224     TMPXItemId checkId;

   225     for(i = 0; i < mTestObject->count(); ++i)

   226     {

   227         checkId.iId1 = i;

   228         checkId.iId2 = 0;

   229         iter = mTestObject->mMediaData.find(checkId);

   230         QVERIFY(iter != mTestObject->mMediaData.constEnd());

   231         QVERIFY(iter.key().iId1 == i);

   232         QVERIFY(iter->first == i);        

   233     }

   234     mTestObject->clear();

   235     

   236 }

   237  

   238 // -----------------------------------------------------------------------------

   239 // testAppend

   240 // -----------------------------------------------------------------------------

   241 //

   242 void TestVideoDataContainer::testAppend()

   243 {

   244     // append null object

   245     mTestObject->append(0);

   246     QVERIFY(mTestObject->count() == 0); 

   247     

   248     // new item

   249     mTestObject->append(mMediaFactory->getMedia(1));

   250     QVERIFY(mTestObject->count() == 1);

   251     QString name;

   252     VideoCollectionUtils::instance().mediaValue<QString>(mTestObject->fromIndex(0), KMPXMediaGeneralTitle, name );

   253     QVERIFY(name == "MEDIATESTNAME_1");

   254     

   255     // existing item without data (except id)-> does not overwrite existing

   256     name = "";

   257     mTestObject->append(mMediaFactory->getMedia(1, MediaDataId));

   258     QVERIFY(mTestObject->count() == 1);

   259     VideoCollectionUtils::instance().mediaValue<QString>(mTestObject->fromIndex(0), KMPXMediaGeneralTitle, name );

   260     QVERIFY(name == "MEDIATESTNAME_1");

   261        

   262     // new unexistent item

   263     mTestObject->append(mMediaFactory->getMedia(2));

   264     QVERIFY(mTestObject->count() == 2);

   265     VideoCollectionUtils::instance().mediaValue<QString>(mTestObject->fromIndex(1), KMPXMediaGeneralTitle, name );

   266     QVERIFY(name == "MEDIATESTNAME_2");

   267     

   268     // item exists in removed -list

   269     mTestObject->append(mMediaFactory->getMedia(3));

   270     QVERIFY(mTestObject->count() == 3);

   271     mTestObject->markItemRemoved(2);

   272     mTestObject->append(mMediaFactory->getMedia(3));

   273     QVERIFY(mTestObject->count() == 2);

   274     

   275     mTestObject->clear();    

   276 }

   277 

   278 // -----------------------------------------------------------------------------

   279 // testFromIndex

   280 // -----------------------------------------------------------------------------

   281 //

   282 void TestVideoDataContainer::testFromIndex()

   283 {

   284     QVERIFY(mTestObject->fromIndex(-1) == 0);

   285     QVERIFY(mTestObject->fromIndex(0) == 0);

   286     QVERIFY(mTestObject->fromIndex(1) == 0);

   287  

   288     // add few items to container (id = i, index = i)

   289     for(int i = 0; i < MEDIA_COUNT; ++i)

   290     {

   291         mTestObject->append(mMediaFactory->getMedia(i));

   292     }

   293     int id = -1;

   294     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   295     QVERIFY(mTestObject->fromIndex(-1) == 0);    

   296     

   297     QVERIFY(mTestObject->fromIndex(0) != 0);

   298     VideoCollectionUtils::instance().mediaValue<int>(mTestObject->fromIndex(0), KMPXMediaGeneralId, id );

   299     QVERIFY(id == 0);

   300     

   301     QVERIFY(mTestObject->fromIndex(1) != 0);

   302     VideoCollectionUtils::instance().mediaValue<int>(mTestObject->fromIndex(1), KMPXMediaGeneralId, id );

   303     QVERIFY(id == 1);

   304         

   305     QVERIFY(mTestObject->fromIndex(MEDIA_COUNT-1) != 0);

   306     VideoCollectionUtils::instance().mediaValue<int>(mTestObject->fromIndex(MEDIA_COUNT-1), KMPXMediaGeneralId, id );

   307     QVERIFY(id == MEDIA_COUNT-1);

   308     

   309     QVERIFY(mTestObject->fromIndex(MEDIA_COUNT) == 0);

   310     mTestObject->clear();

   311 }

   312  

   313 // -----------------------------------------------------------------------------

   314 // testIndexOfId

   315 // -----------------------------------------------------------------------------

   316 //

   317 void TestVideoDataContainer::testIndexOfId()

   318 {

   319 

   320     QVERIFY(mTestObject->indexOfId(TMPXItemId::InvalidId()) == -1);

   321     QVERIFY(mTestObject->indexOfId(TMPXItemId(0,0)) == -1);

   322     QVERIFY(mTestObject->indexOfId(TMPXItemId(1,0)) == -1);

   323  

   324     // add few items to container (id = i, index = i)

   325     for(int i = 0; i < MEDIA_COUNT; ++i)

   326     {

   327         mTestObject->append(mMediaFactory->getMedia(i));

   328     }

   329     QVERIFY(mTestObject->indexOfId(TMPXItemId::InvalidId()) == -1);

   330     QVERIFY(mTestObject->indexOfId(TMPXItemId(0,0)) == 0);

   331     QVERIFY(mTestObject->indexOfId(TMPXItemId(1,0)) == 1);

   332     QVERIFY(mTestObject->indexOfId(TMPXItemId(MEDIA_COUNT - 1, 0)) == MEDIA_COUNT - 1);

   333     QVERIFY(mTestObject->indexOfId(TMPXItemId(MEDIA_COUNT, 0)) == -1);

   334     

   335     // remove one item at the middle of the list (id is same than index at this point)

   336     mTestObject->remove(TMPXItemId(MEDIA_COUNT / 2, 0));

   337     QVERIFY(mTestObject->indexOfId(TMPXItemId(0,0)) == 0);

   338     QVERIFY(mTestObject->indexOfId(TMPXItemId(1,0)) == 1);

   339     QVERIFY(mTestObject->indexOfId(TMPXItemId(MEDIA_COUNT - 1, 0)) == MEDIA_COUNT - 2);

   340     QVERIFY(mTestObject->indexOfId(TMPXItemId(MEDIA_COUNT - 2, 0)) == MEDIA_COUNT - 3);

   341     QVERIFY(mTestObject->indexOfId(TMPXItemId(MEDIA_COUNT, 0)) == -1);

   342     mTestObject->clear();

   343 }

   344 

   345 // -----------------------------------------------------------------------------

   346 // testIdFromIndex

   347 // -----------------------------------------------------------------------------

   348 //

   349 void TestVideoDataContainer::testIdFromIndex()

   350 {

   351     QVERIFY(mTestObject->idFromIndex(-1) == TMPXItemId::InvalidId());

   352     QVERIFY(mTestObject->idFromIndex(0) == TMPXItemId::InvalidId());

   353     QVERIFY(mTestObject->idFromIndex(1) == TMPXItemId::InvalidId());

   354     // add few items to container (id = i, index = i)

   355     for(int i = 0; i < MEDIA_COUNT; ++i)

   356     {

   357         mTestObject->append(mMediaFactory->getMedia(i));

   358     }

   359     QVERIFY(mTestObject->idFromIndex(-1) == TMPXItemId::InvalidId());

   360     QVERIFY(mTestObject->idFromIndex(0).iId1 == 0);

   361     QVERIFY(mTestObject->idFromIndex(1).iId1 == 1);

   362     QVERIFY(mTestObject->idFromIndex(MEDIA_COUNT - 1).iId1 == MEDIA_COUNT - 1);

   363     QVERIFY(mTestObject->idFromIndex(MEDIA_COUNT) == TMPXItemId::InvalidId());

   364     

   365     // remove one item at the middle of the list (id is same than index at this point)

   366     mTestObject->remove(TMPXItemId(MEDIA_COUNT / 2,0));

   367     QVERIFY(mTestObject->idFromIndex(0).iId1 == 0);

   368     QVERIFY(mTestObject->idFromIndex(1).iId1 == 1);

   369     QVERIFY(mTestObject->idFromIndex(MEDIA_COUNT - 1) == TMPXItemId::InvalidId());

   370     QVERIFY(mTestObject->idFromIndex(MEDIA_COUNT - 2).iId1 == MEDIA_COUNT - 1);

   371     QVERIFY(mTestObject->idFromIndex(MEDIA_COUNT) == TMPXItemId::InvalidId());

   372     mTestObject->clear();

   373     

   374 }

   375 

   376 // -----------------------------------------------------------------------------

   377 // testCount

   378 // -----------------------------------------------------------------------------

   379 //

   380 void TestVideoDataContainer::testCount()

   381 {

   382     // this is mostly tested in other parts of tests,

   383     // but let's just add few trivial cases

   384     QVERIFY(mTestObject->count() == 0);

   385     

   386     mTestObject->append(mMediaFactory->getMedia(0));

   387     QVERIFY(mTestObject->count() == 1);

   388     

   389     for(int i = 1; i < MEDIA_COUNT; ++i)

   390     {

   391         mTestObject->append(mMediaFactory->getMedia(i));

   392     }

   393     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   394     mTestObject->remove(TMPXItemId(MEDIA_COUNT / 2, 0));

   395     QVERIFY(mTestObject->count() == MEDIA_COUNT - 1);

   396     mTestObject->clear();

   397 }

   398 

   399 void TestVideoDataContainer::testMarkItemRemoved()

   400 {

   401     int i;

   402     for(i = 0; i < MEDIA_COUNT; ++i)

   403     {

   404         mTestObject->append(mMediaFactory->getMedia(i));

   405     }

   406     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   407     

   408     // invalid item at index

   409     QVERIFY(mTestObject->markItemRemoved(MEDIA_COUNT) == TMPXItemId::InvalidId());

   410     

   411     // item not in removed -list

   412     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   413     TMPXItemId id = mTestObject->idFromIndex(0);

   414     QVERIFY(mTestObject->markItemRemoved(0) == id);

   415     QVERIFY(mTestObject->count() == MEDIA_COUNT - 1);

   416     

   417     // at this point, indexes after recently marked first 

   418     // item have decreased by one (whereas ids increase by one)

   419     QHash<TMPXItemId, QPair<int, CMPXMedia*> >::const_iterator iter;

   420     for(i = 0; i < mTestObject->count(); ++i)

   421     {

   422        iter = mTestObject->mMediaData.find(mTestObject->mMediaIds[i]);

   423        QVERIFY(iter != mTestObject->mMediaData.constEnd());

   424        QVERIFY(iter.key().iId1 == i + 1);

   425        QVERIFY(iter->first == i );

   426 

   427     }

   428     CMPXMedia *media = 0;

   429     id = mTestObject->idFromIndex(0);

   430     // item already at removed -list

   431     mTestObject->mRemovedMedia[id] = media;

   432     QVERIFY(mTestObject->markItemRemoved(0) == id);

   433     QVERIFY(mTestObject->count() == MEDIA_COUNT - 2);

   434     

   435 }

   436 

   437 void TestVideoDataContainer::testClearRemoved()

   438 {

   439     int i;

   440     for(i = 0; i < MEDIA_COUNT; ++i)

   441     {

   442         mTestObject->append(mMediaFactory->getMedia(i));

   443     }

   444     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   445     for(i = MEDIA_COUNT; i >= 0; --i)

   446     {

   447         mTestObject->markItemRemoved(i);

   448     }

   449     QVERIFY(mTestObject->count() == 0);

   450     QVERIFY(mTestObject->mRemovedMedia.count() == MEDIA_COUNT);

   451     

   452     // null idlist provided

   453     QVERIFY(mTestObject->clearRemoved(0) == MEDIA_COUNT);

   454     QVERIFY(mTestObject->count() == 0);

   455     QVERIFY(mTestObject->mRemovedMedia.count() == 0);

   456     

   457     for(i = 0; i < MEDIA_COUNT; ++i)

   458     {

   459         mTestObject->append(mMediaFactory->getMedia(i));

   460     }

   461     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   462     for(i = MEDIA_COUNT; i >= 0; --i)

   463     {

   464         mTestObject->markItemRemoved(i);

   465     }

   466     QVERIFY(mTestObject->count() == 0);

   467     QVERIFY(mTestObject->mRemovedMedia.count() == MEDIA_COUNT);

   468     

   469     // empty id list

   470     QList<TMPXItemId> idList;

   471     QVERIFY(mTestObject->clearRemoved(&idList) == 0);

   472     QVERIFY(mTestObject->count() == 0);

   473     QVERIFY(mTestObject->mRemovedMedia.count() == MEDIA_COUNT);

   474     

   475     // id list containing some ids

   476     idList.append(TMPXItemId(0,0));

   477     idList.append(TMPXItemId(MEDIA_COUNT/2,0));

   478     idList.append(TMPXItemId(MEDIA_COUNT - 1,0));

   479     idList.append(TMPXItemId(MEDIA_COUNT,0));

   480     QVERIFY(mTestObject->clearRemoved(&idList) == 3);

   481     QVERIFY(mTestObject->count() == 0);

   482     QVERIFY(mTestObject->mRemovedMedia.count() == MEDIA_COUNT - 3);

   483     

   484 }

   485    

   486 void TestVideoDataContainer::testRestoreRemovedItems()

   487 {

   488     int i;

   489     for(i = 0; i < MEDIA_COUNT; ++i)

   490     {

   491         mTestObject->append(mMediaFactory->getMedia(i));

   492     }

   493     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   494     for(i = MEDIA_COUNT; i >= 0; --i)

   495     {

   496         mTestObject->markItemRemoved(i);

   497     }

   498     QVERIFY(mTestObject->count() == 0);

   499     QVERIFY(mTestObject->mRemovedMedia.count() == MEDIA_COUNT);

   500     

   501     // null id list, restores all

   502     QVERIFY(mTestObject->restoreRemovedItems(0) == MEDIA_COUNT);

   503     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   504     QVERIFY(mTestObject->mRemovedMedia.count() == 0);

   505     

   506     for(i = 0; i < MEDIA_COUNT; ++i)

   507     {

   508         mTestObject->append(mMediaFactory->getMedia(i));

   509     }

   510     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   511     for(i = MEDIA_COUNT; i >= 0; --i)

   512     {

   513         mTestObject->markItemRemoved(i);

   514     }

   515     QVERIFY(mTestObject->count() == 0);

   516     QVERIFY(mTestObject->mRemovedMedia.count() == MEDIA_COUNT);

   517     

   518     // second null id list, restores all 

   519     QVERIFY(mTestObject->restoreRemovedItems(0) == MEDIA_COUNT);

   520     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   521     QVERIFY(mTestObject->mRemovedMedia.count() == 0);

   522     

   523     mTestObject->clear();

   524     for(i = 0; i < MEDIA_COUNT; ++i)

   525     {

   526         mTestObject->append(mMediaFactory->getMedia(i));

   527     }

   528     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   529     for(i = MEDIA_COUNT; i >= 0; --i)

   530     {

   531         mTestObject->markItemRemoved(i);

   532     }

   533     QVERIFY(mTestObject->count() == 0);

   534     QVERIFY(mTestObject->mRemovedMedia.count() == MEDIA_COUNT);

   535     

   536     QList<TMPXItemId> idList;

   537     // empty list

   538     QVERIFY(mTestObject->restoreRemovedItems(&idList) == 0);

   539     QVERIFY(mTestObject->count() == 0);

   540     QVERIFY(mTestObject->mRemovedMedia.count() == MEDIA_COUNT);

   541     

   542     // some items with collection doesn't match

   543     idList.append(TMPXItemId(0,0));

   544     idList.append(TMPXItemId(MEDIA_COUNT/2,0));

   545     idList.append(TMPXItemId(MEDIA_COUNT - 1,0));

   546     idList.append(TMPXItemId(MEDIA_COUNT,0));

   547     QVERIFY(mTestObject->restoreRemovedItems(&idList) == 3);

   548     QVERIFY(mTestObject->count() == 3);

   549     QVERIFY(mTestObject->mRemovedMedia.count() == MEDIA_COUNT - 3);

   550     mTestObject->clearRemoved(0);

   551     mTestObject->clear();

   552     for(i = 0; i < MEDIA_COUNT; ++i)

   553     {

   554         mTestObject->append(mMediaFactory->getMedia(i));

   555     }

   556     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   557     for(i = MEDIA_COUNT; i >= 0; --i)

   558     {

   559         mTestObject->markItemRemoved(i);

   560     }

   561     QVERIFY(mTestObject->count() == 0);

   562     QVERIFY(mTestObject->mRemovedMedia.count() == MEDIA_COUNT);

   563     

   564     // some items with collection matching

   565     QVERIFY(mTestObject->restoreRemovedItems(&idList) == 3);

   566     QVERIFY(mTestObject->count() == 3);

   567     QVERIFY(mTestObject->mRemovedMedia.count() == MEDIA_COUNT - 3);

   568 }

   569    

   570 void TestVideoDataContainer::testGetRemovedMedia()

   571 {

   572     int i;

   573     for(i = 0; i < MEDIA_COUNT; ++i)

   574     {

   575         mTestObject->append(mMediaFactory->getMedia(i));

   576     }

   577     QVERIFY(mTestObject->count() == MEDIA_COUNT);

   578     mTestObject->markItemRemoved(MEDIA_COUNT - 1);

   579     mTestObject->markItemRemoved(MEDIA_COUNT / 2);

   580     mTestObject->markItemRemoved(0);

   581     QVERIFY(mTestObject->count() == MEDIA_COUNT - 3);

   582     QVERIFY(mTestObject->mRemovedMedia.count() == 3);

   583     

   584     CMPXMedia *media = 0;

   585     media = mTestObject->getRemovedMedia(TMPXItemId(1,0));

   586     QVERIFY(!media);

   587     media = mTestObject->getRemovedMedia(TMPXItemId(0,0));

   588     QVERIFY(media);

   589     media = 0; 

   590     media = mTestObject->getRemovedMedia(TMPXItemId(MEDIA_COUNT - 1,0));

   591     QVERIFY(media);        

   592 }

   593 

   594 // end of file